diff --git a/.clang-format b/.clang-format index 88b4e9a..8bf36d7 100644 --- a/.clang-format +++ b/.clang-format @@ -21,7 +21,7 @@ BreakBeforeBinaryOperators: NonAssignment BreakBeforeBraces: Custom BreakBeforeTernaryOperators: 'false' BreakConstructorInitializersBeforeComma: 'true' -ColumnLimit: '120' +ColumnLimit: '80' ConstructorInitializerAllOnOneLineOrOnePerLine: 'false' Cpp11BracedListStyle: 'true' IndentCaseLabels: 'true' diff --git a/.gitignore b/.gitignore index cf57f0b..7d9997d 100644 --- a/.gitignore +++ b/.gitignore @@ -2,6 +2,7 @@ bin_x64/ build*/ .cache/ .vscode/ +.clangd *.code-workspace log_nvprosample.txt ucode.bin @@ -15,4 +16,5 @@ ucode.elf zbsgfxpack.lua _install downloaded_resources/ -camera_paths.json \ No newline at end of file +camera_paths.json +screenshot.png diff --git a/.gitmodules b/.gitmodules index 12e647a..9da1077 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,6 +1,6 @@ -[submodule "nvpro_core"] - path = nvpro_core - url = https://github.com/nvpro-samples/nvpro_core.git [submodule "nv_cluster_lod_builder"] path = nv_cluster_lod_builder - url = https://github.com/pknowles/nv_cluster_lod_builder.git + url = ../nv_cluster_lod_builder.git +[submodule "vulkan_objects"] + path = vulkan_objects + url = ../vulkan_objects.git diff --git a/CMakeLists.txt b/CMakeLists.txt index d877d8a..f289dc1 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -22,13 +22,13 @@ set(SOURCE_FILES src/acceleration_structures.cpp src/acceleration_structures.hpp src/gltf_view.hpp + src/imgui_docking_helper.hpp src/lod_streaming_jobs.cpp src/lod_streaming_jobs.hpp src/lod_streaming_scene.cpp src/lod_streaming_scene.hpp src/lod_traverser.cpp src/lod_traverser.hpp - src/main.cpp src/meshops_array_view.h src/debug_range_summary.hpp src/renderer_common.cpp @@ -40,12 +40,15 @@ set(SOURCE_FILES src/sample_allocation.hpp src/sample_camera_paths.hpp src/sample_camera_paths.cpp - src/sample_app_element.hpp src/sample_glsl_compiler.hpp src/sample_image.hpp src/sample_producer_consumer.hpp + src/sample_profiler.hpp + src/sample_profiler.cpp src/sample_raytracing_objects.hpp src/sample_vulkan_objects.hpp + src/sample_vulkan_context.cpp + src/sample_vulkan_context.hpp src/scene.cpp src/scene.hpp src/nvhiz_vk.cpp @@ -53,82 +56,235 @@ set(SOURCE_FILES src/generate_mesh.cpp src/generate_mesh.hpp src/mesh_util.hpp - src/sample_dlss_objects.hpp + src/platform_utils.hpp + src/main.cpp ) +# Create a separate library for nvpro_core_legacy files to isolate warnings/errors +add_library(nvpro_core_legacy_static STATIC + nvpro_core_legacy/nvvkhl/tonemap_postprocess.cpp + nvpro_core_legacy/fileformats/texture_formats.cpp + nvpro_core_legacy/fileformats/nv_dds.cpp + nvpro_core_legacy/fileformats/nv_ktx.cpp + nvpro_core_legacy/imgui/imgui_icon.cpp +) + +target_include_directories(nvpro_core_legacy_static PUBLIC + ${CMAKE_CURRENT_SOURCE_DIR} + ${CMAKE_CURRENT_SOURCE_DIR}/nvpro_core_legacy + ${CMAKE_CURRENT_SOURCE_DIR}/nvpro_core_legacy/third_party/dxh/include/directx +) + +# Link dependencies for nvpro_core_legacy (defer until after imgui_static is defined) +target_compile_definitions(nvpro_core_legacy_static PUBLIC + NVP_SUPPORTS_VULKANSDK +) + +# Disable C5246 warning for nvpro_core_legacy (legacy code doesn't use C++20 aggregate init style) +if(MSVC) + target_compile_options(nvpro_core_legacy_static PRIVATE /wd5246) +endif() + file(GLOB GLSL_FILES shaders/*.*) source_group("Shaders" FILES ${GLSL_FILES}) -# Look for nvpro_core 1) as a sub-folder 2) at some other locations -if(NOT BASE_DIRECTORY) - find_path(BASE_DIRECTORY - NAMES nvpro_core/cmake/setup.cmake - PATHS ${CMAKE_CURRENT_SOURCE_DIR}/external ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/.. ${CMAKE_CURRENT_SOURCE_DIR}/../.. - REQUIRED - DOC "Directory containing nvpro_core" +include(FetchContent) + +# Find GLFW for window management (needed by imgui) +find_package(glfw3 QUIET) +if(NOT glfw3_FOUND) + FetchContent_Declare( + glfw + GIT_REPOSITORY https://github.com/glfw/glfw.git + GIT_TAG 3.4 + GIT_SHALLOW TRUE + OVERRIDE_FIND_PACKAGE ) + set(GLFW_BUILD_DOCS OFF CACHE BOOL "" FORCE) + set(GLFW_BUILD_TESTS OFF CACHE BOOL "" FORCE) + set(GLFW_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE) + FetchContent_MakeAvailable(glfw) endif() -# Include nvpro_core makefiles -if(EXISTS ${BASE_DIRECTORY}/nvpro_core/cmake/setup.cmake) - include(${BASE_DIRECTORY}/nvpro_core/cmake/setup.cmake) - include(${BASE_DIRECTORY}/nvpro_core/cmake/utilities.cmake) -else() - message(FATAL_ERROR "could not find base directory, please set BASE_DIRECTORY to folder containing nvpro_core") +# Use vulkan_objects instead of nvpro_core +set(DECODELESS_SEARCH_DEPENDENCIES OFF) +set(DECODELESS_FETCH_DEPENDENCIES ON) +set(BUILD_DECODELESS_TESTING OFF) + +set(VULKAN_OBJECTS_FETCH_VMA ON) +set(VULKAN_OBJECTS_FETCH_SHADERC ON) # continue using the glsl compiler that was used before +set(VULKAN_OBJECTS_FETCH_SLANG OFF CACHE BOOL "") # We'll use shaderc instead, but don't force it off +set(VULKAN_OBJECTS_FETCH_VVL ON) # Useful for debugging validation layer errors +add_subdirectory(vulkan_objects) + +# Now that vulkan_objects is defined, link it to nvpro_core_legacy_static +target_link_libraries(nvpro_core_legacy_static + PUBLIC + vulkan_objects + glm::glm +) + +FetchContent_Declare( + imgui + GIT_REPOSITORY https://github.com/ocornut/imgui.git + GIT_TAG v1.92.5-docking + GIT_SHALLOW TRUE + OVERRIDE_FIND_PACKAGE +) +FetchContent_MakeAvailable(imgui) + +# Build imgui as a static library +add_library(imgui_static STATIC + ${imgui_SOURCE_DIR}/imgui.cpp + ${imgui_SOURCE_DIR}/imgui_draw.cpp + ${imgui_SOURCE_DIR}/imgui_tables.cpp + ${imgui_SOURCE_DIR}/imgui_widgets.cpp + ${imgui_SOURCE_DIR}/imgui_demo.cpp + ${imgui_SOURCE_DIR}/backends/imgui_impl_glfw.cpp + ${imgui_SOURCE_DIR}/backends/imgui_impl_vulkan.cpp + ${imgui_SOURCE_DIR}/misc/cpp/imgui_stdlib.cpp +) +target_compile_definitions(imgui_static PUBLIC + IMGUI_DEFINE_MATH_OPERATORS + IMGUI_IMPL_VULKAN_NO_PROTOTYPES +) +target_include_directories(imgui_static PUBLIC + ${imgui_SOURCE_DIR} + ${imgui_SOURCE_DIR}/backends +) +target_link_libraries(imgui_static PUBLIC glfw Vulkan::Headers) +set_property(TARGET imgui_static PROPERTY FOLDER "ThirdParty") + +# Alias for compatibility with ImGuiFileDialog expecting imgui::imgui +if(NOT TARGET imgui::imgui) + add_library(imgui::imgui ALIAS imgui_static) endif() -# Download the bunny as the default mesh to load -download_files(FILENAMES bunny_v2.zip EXTRACT) +# Suppress warnings from imgui (it's external code) +if(MSVC) + target_compile_options(imgui_static PRIVATE /w) +endif() -# Set a default CMAKE_INSTALL_PREFIX for nvpro samples -_add_project_definitions(${SAMPLE_EXECUTABLE}) +# Now link nvpro_core_legacy_static dependencies +# (vulkan_objects will be linked later after it's defined) +target_link_libraries(nvpro_core_legacy_static + PUBLIC + imgui_static +) + +# Fetch implot +FetchContent_Declare( + implot + GIT_REPOSITORY https://github.com/epezent/implot.git + # GIT_TAG v0.16 (incompatible with imgui v1.92.5) + GIT_TAG 8a9d793e47ca8de526c401b6bc788e1ff2967a31 + GIT_SHALLOW TRUE + OVERRIDE_FIND_PACKAGE +) +FetchContent_MakeAvailable(implot) +add_library(implot_static STATIC src/implot_impl.cpp) +target_include_directories(implot_static PUBLIC ${implot_SOURCE_DIR}) +target_link_libraries(implot_static PRIVATE imgui_static) +set_property(TARGET implot_static PROPERTY FOLDER "ThirdParty") + +# Fetch ImGuiFileDialog +FetchContent_Declare( + ImGuiFileDialog + GIT_REPOSITORY https://github.com/aiekick/ImGuiFileDialog.git + GIT_TAG v0.6.8 + GIT_SHALLOW TRUE + OVERRIDE_FIND_PACKAGE +) +FetchContent_MakeAvailable(ImGuiFileDialog) +target_link_libraries(ImGuiFileDialog PUBLIC imgui_static) +set_property(TARGET ImGuiFileDialog PROPERTY FOLDER "ThirdParty") + +# Fetch args for command line parsing +FetchContent_Declare( + args + GIT_REPOSITORY https://github.com/Taywee/args.git + GIT_TAG 6.4.7 + GIT_SHALLOW TRUE + OVERRIDE_FIND_PACKAGE +) +set(ARGS_BUILD_EXAMPLE OFF CACHE BOOL "" FORCE) +set(ARGS_BUILD_UNITTESTS OFF CACHE BOOL "" FORCE) +FetchContent_MakeAvailable(args) + +# Find NVToolsExt for profiling +find_package(NVToolsExt QUIET) +if(NVToolsExt_FOUND) + add_definitions(-DNVP_SUPPORTS_NVTOOLSEXT) +endif() -file(RELATIVE_PATH NVPRO_CORE_DIR ${CMAKE_CURRENT_SOURCE_DIR} ${BASE_DIRECTORY}/nvpro_core/) +# Download the bunny as the default mesh to load (optional) +set(DOWNLOAD_TARGET_DIR "${CMAKE_BINARY_DIR}/downloaded_resources") +if(NOT EXISTS "${DOWNLOAD_TARGET_DIR}/bunny_v2.zip") + message(STATUS "Attempting to download bunny_v2.zip (optional default mesh)...") + file(DOWNLOAD + "https://developer.download.nvidia.com/ProGraphics/nvpro-samples/bunny_v2.zip" + "${DOWNLOAD_TARGET_DIR}/bunny_v2.zip" + SHOW_PROGRESS + STATUS DOWNLOAD_STATUS + TIMEOUT 10 + ) + list(GET DOWNLOAD_STATUS 0 DOWNLOAD_RESULT) + if(NOT DOWNLOAD_RESULT EQUAL 0) + message(WARNING "Could not download bunny_v2.zip (offline or timeout).") -# Enable NVTX markers for nsight systems profiling -set(SUPPORT_NVTOOLSEXT ON) + endif() +endif() -# Turn on extra nvpro_core features (the same lib can be referenced with -# multiple configurations). Some _add_package_*() nvpro_core specializations -# alter the implementation, in which case samples are requested to compile extra -# source files rather than compile extra static libraries or an all-in-one -# nvpro_core lib. This is done with COMMON_SOURCE_FILES, PACKAGE_SOURCE_FILES, -# PLATFORM_LIBRARIES, LIBRARIES_DEBUG and LIBRARIES_OPTIMIZED. -_add_package_VulkanSDK() -_add_package_ShaderC() -_add_package_ImGUI() -_add_package_NVToolsExt() -_add_nvpro_core_lib() +if(EXISTS "${DOWNLOAD_TARGET_DIR}/bunny_v2.zip" AND NOT EXISTS "${DOWNLOAD_TARGET_DIR}/bunny_v2") + message(STATUS "Extracting bunny_v2.zip...") + execute_process( + COMMAND ${CMAKE_COMMAND} -E tar xzf "${DOWNLOAD_TARGET_DIR}/bunny_v2.zip" + WORKING_DIRECTORY "${DOWNLOAD_TARGET_DIR}" + RESULT_VARIABLE EXTRACT_RESULT + ) + if(NOT EXTRACT_RESULT EQUAL 0) + message(WARNING "Failed to extract bunny_v2.zip") + endif() +endif() list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake") -set(DLSS_VERSION "310.4.0") find_package(NGX REQUIRED) +find_package(Threads REQUIRED) +set(BUILD_NV_CLUSTER_LOD_BUILDER_TESTING OFF CACHE BOOL "" FORCE) +set(BUILD_NV_CLUSTER_BUILDER_TESTING OFF CACHE BOOL "" FORCE) add_subdirectory(nv_cluster_lod_builder) -add_library(vma_static src/vma_impl.cpp) -target_link_libraries(vma_static PUBLIC vma) # nvpro_core exports header-only 'vma' -set_property(TARGET vma_static PROPERTY FOLDER "ThirdParty") +# Add cgltf implementation if(NOT TARGET cgltf_static) + FetchContent_Declare( + cgltf + GIT_REPOSITORY https://github.com/jkuhlmann/cgltf.git + GIT_TAG v1.13 + GIT_SHALLOW TRUE + OVERRIDE_FIND_PACKAGE + ) + FetchContent_MakeAvailable(cgltf) add_library(cgltf_static src/cgltf_impl.cpp) - target_link_libraries(cgltf_static PUBLIC cgltf) # nvpro_core exports header-only 'cgltf' + target_include_directories(cgltf_static PUBLIC ${cgltf_SOURCE_DIR}) set_property(TARGET cgltf_static PROPERTY FOLDER "ThirdParty") endif() +# Add stb_image implementation +FetchContent_Declare( + stb + GIT_REPOSITORY https://github.com/nothings/stb.git + GIT_TAG f1c79c02822848a9bed4315b12c8c8f3761e1296 + GIT_SHALLOW TRUE + OVERRIDE_FIND_PACKAGE +) +FetchContent_MakeAvailable(stb) add_library(stb_image_static src/stb_image_impl.cpp) -target_link_libraries(stb_image_static PUBLIC stb) # nvpro_core exports header-only 'stb' +target_include_directories(stb_image_static PUBLIC ${stb_SOURCE_DIR}) set_property(TARGET stb_image_static PROPERTY FOLDER "ThirdParty") -# nvpro_core has some configuration dependent source files it expects -# applications to compile. These are built separately as warnings in this -# project are too strict. -add_library(nvpro_core_extra - ${COMMON_SOURCE_FILES} - ${PACKAGE_SOURCE_FILES}) -target_link_libraries(nvpro_core_extra PUBLIC nvpro_core) - -set(CMAKE_CXX_STANDARD 20) +set(CMAKE_CXX_STANDARD 23) set(CMAKE_CXX_STANDARD_REQUIRED ON) add_executable(${SAMPLE_EXECUTABLE} @@ -147,13 +303,20 @@ if(MSVC) /w44355 # warning C4355: 'this': used in base member initializer list /w45246 # warning C5246: '_Elems': the initialization of a subobject should be wrapped in braces - # Ignore nvpro_core header warnings from /W4 + # Ignore external header warnings from /W4 /experimental:external /external:W3 - /external:I${BASE_DIRECTORY}/nvpro_core/ - /external:I${BASE_DIRECTORY}/nvpro_core/nvp - /external:I${BASE_DIRECTORY}/nvpro_core/nvvk - /external:I${BASE_DIRECTORY}/nvpro_core/nvvkhl - #/external:templates- # can't enable due to nvvk::PushComputeDispatcher + + # Mark nvpro_core_legacy as external to suppress its warnings + /external:I ${CMAKE_CURRENT_SOURCE_DIR}/nvpro_core_legacy + + # Mark imgui as external to suppress its warnings + "/external:I$" + + # Don't default to buggy parallel builds... like why is this not just on? + /FS + + # Extra compile error diagnostics + /diagnostics:caret ) target_compile_definitions(${SAMPLE_EXECUTABLE} PRIVATE WIN32_LEAN_AND_MEAN=1 NOMINMAX) set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT ${SAMPLE_EXECUTABLE}) @@ -181,23 +344,23 @@ else() #$<$:_GLIBCXX_DEBUG_BACKTRACE> # DANGER: ABI breaking! ) - # Ignore warnings from nvpro_core headers + # Ignore warnings from external headers target_include_directories(${SAMPLE_EXECUTABLE} SYSTEM PRIVATE - ${NVPRO_CORE_DIR} - ${NVPRO_CORE_DIR}/third_party/glm - ${Vulkan_INCLUDE_DIR}) + ${vulkan_headers_INCLUDE_DIR} + ${imgui_SOURCE_DIR} + ) if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU") # for when you write too much code without building - target_compile_options(${SAMPLE_EXECUTABLE} PRIVATE -fmax-errors=5) + #target_compile_options(${SAMPLE_EXECUTABLE} PRIVATE -fmax-errors=5) # Optional: faster repeat gdb launch at cost of post-build step - if (CMAKE_BUILD_TYPE STREQUAL "Debug") - add_custom_command(TARGET ${SAMPLE_EXECUTABLE} POST_BUILD - COMMAND gdb-add-index $ - COMMENT "gdb-add-index ${SAMPLE_EXECUTABLE}" - ) - endif() + #if (CMAKE_BUILD_TYPE STREQUAL "Debug") + # add_custom_command(TARGET ${SAMPLE_EXECUTABLE} POST_BUILD + # COMMAND gdb-add-index $ + # COMMENT "gdb-add-index ${SAMPLE_EXECUTABLE}" + # ) + #endif() endif() endif() @@ -205,139 +368,188 @@ endif() # FindNGX.cmake list(GET DLSS_DLLS 0 _DLSS_FIRST_DLL) get_filename_component(_DLSS_LIB_DIR "${_DLSS_FIRST_DLL}" DIRECTORY) -file(RELATIVE_PATH DLSS_RELPATH_FROM_SOURCE "${CMAKE_SOURCE_DIR}" "${_DLSS_LIB_DIR}") -# nvpro_core modifies RUNTIME_OUTPUT_DIRECTORY, which includes a generator expression -#file(RELATIVE_PATH DLSS_RELPATH_FROM_BINARY "${CMAKE_BINARY_DIR}" "${_DLSS_LIB_DIR}") -file(RELATIVE_PATH DLSS_RELPATH_FROM_BINARY "${OUTPUT_PATH}/ConfigSubpath" "${_DLSS_LIB_DIR}") +get_filename_component(_DLSS_LIB_PARENT_DIR "${_DLSS_LIB_DIR}" DIRECTORY) +file(RELATIVE_PATH DLSS_PARENT_RELPATH_FROM_SOURCE "${CMAKE_SOURCE_DIR}" "${_DLSS_LIB_PARENT_DIR}") + target_compile_definitions(${SAMPLE_EXECUTABLE} PRIVATE DLSS_RELPATH_FROM_INSTALL="." # Workaround for DLSS_USE_DEVELOP_LIBRARIES. Use dev for Debug builds, rel for others - DLSS_RELPATH_FROM_SOURCE="${DLSS_RELPATH_FROM_SOURCE}/../$,dev,rel>" - DLSS_RELPATH_FROM_BINARY="${DLSS_RELPATH_FROM_BINARY}/../$,dev,rel>" + DLSS_RELPATH_FROM_SOURCE="${DLSS_PARENT_RELPATH_FROM_SOURCE}/$,dev,rel>" + DLSS_RELPATH_FROM_BINARY="$,dev,rel>,$>" + DOWNLOAD_RELPATH_FROM_BINARY="$>" + # Relative paths to shader directories from the binary location (for running from build dir) + SHADER_DIR_RELPATH_FROM_BINARY="$>" + NVPRO_LEGACY_RELPATH_FROM_BINARY="$>" + INSTALL_SUBDIRECTORY="media" ) target_precompile_headers(${SAMPLE_EXECUTABLE} PRIVATE + # Standard library - + - + + + + + - - - - - - + + + + - - - - - - - - - - - - - - - - - - - - - - + + + + - + + - + + + + # Third-party libraries + + + + + + + + + + + + + + + + + + + + + # vko (comment out if editing these frequently) + + + + + + + + + + + + + + + + # + # + ) -set(DECODELESS_SEARCH_DEPENDENCIES OFF) -set(DECODELESS_FETCH_DEPENDENCIES ON) -set(BUILD_DECODELESS_TESTING OFF) -include(FetchContent) +# Fetch decodeless dependencies FetchContent_Declare( decodeless_offset_ptr GIT_REPOSITORY https://github.com/decodeless/offset_ptr.git - GIT_TAG 78693cb545ac155b9514c17caa4be671b791b8e5) + GIT_TAG 78693cb545ac155b9514c17caa4be671b791b8e5 + GIT_SHALLOW TRUE + OVERRIDE_FIND_PACKAGE) FetchContent_MakeAvailable(decodeless_offset_ptr) FetchContent_Declare( decodeless_writer GIT_REPOSITORY https://github.com/decodeless/writer.git - GIT_TAG 6f9b747d7671afe2c7abd1d48c9d084402aec1d8) + GIT_TAG 6f9b747d7671afe2c7abd1d48c9d084402aec1d8 + GIT_SHALLOW TRUE + OVERRIDE_FIND_PACKAGE) FetchContent_MakeAvailable(decodeless_writer) -target_include_directories(${SAMPLE_EXECUTABLE} PRIVATE src) +# Fetch GLM for math +FetchContent_Declare( + glm + GIT_REPOSITORY https://github.com/g-truc/glm.git + GIT_TAG 1.0.2 + GIT_SHALLOW TRUE + OVERRIDE_FIND_PACKAGE +) +FetchContent_MakeAvailable(glm) + +# Download https://github.com/scottt/debugbreak +set(DEBUGBREAK_DIR "${CMAKE_BINARY_DIR}/debugbreak") +set(DEBUGBREAK_HEADER "${DEBUGBREAK_DIR}/debugbreak.h") +file(MAKE_DIRECTORY "${DEBUGBREAK_DIR}") +if(NOT EXISTS "${DEBUGBREAK_HEADER}") + file(DOWNLOAD + "https://raw.githubusercontent.com/scottt/debugbreak/5dcbe41d2bd4712c8014aa7e843723ad7b40fd74/debugbreak.h" + "${DEBUGBREAK_HEADER}" + EXPECTED_HASH SHA256=f691efbd23848c927d9ee98d7b5264a86cf3a36607633b08bd6936f44e2b71c8 + TLS_VERIFY ON + ) +endif() + +target_include_directories(${SAMPLE_EXECUTABLE} PRIVATE src shaders nvpro_core_legacy nvpro_core_legacy/nvtx3 ${DEBUGBREAK_DIR}) target_link_libraries(${SAMPLE_EXECUTABLE} - nvpro_core - nvpro_core_extra + vulkan_objects + vulkan_objects_glfw # contains workaround for native XCB vma_static nv_cluster_lod_builder cgltf_static stb_image_static - ${PLATFORM_LIBRARIES} + nvpro_core_legacy_static + imgui_static + implot_static + ImGuiFileDialog + glfw + glm::glm + args decodeless::writer decodeless::offset_ptr - ngx) -target_link_libraries(${SAMPLE_EXECUTABLE} debug ${LIBRARIES_DEBUG}) -target_link_libraries(${SAMPLE_EXECUTABLE} optimized ${LIBRARIES_OPTIMIZED}) + ngx + Threads::Threads) +if(NVToolsExt_FOUND) + target_link_libraries(${SAMPLE_EXECUTABLE} NVToolsExt::NVToolsExt) +endif() target_compile_definitions(${SAMPLE_EXECUTABLE} PRIVATE - NVPRO_CORE_DIR="${NVPRO_CORE_DIR}" - - # Compile error from nvpro_core/nvp/perproject_globals.cpp without this, - # if _add_project_definitions() is commented out - PROJECT_NAME="${SAMPLE_EXECUTABLE}" - GLM_FORCE_CTOR_INIT # safety + GLM_ENABLE_EXPERIMENTAL ) -# Defines executable install() targets -_finalize_target(${SAMPLE_EXECUTABLE}) - -# Undo the _app suffix added by nvpro_core -set_target_properties(${SAMPLE_EXECUTABLE} PROPERTIES SUFFIX "") - -# Install shaders, including some shared headers from nvpro_core. Unlike some -# samples, these are loaded at runtime and not embedded in the binary -# NOTE: this continues the nvpro_core convention of installing to ./_install -file(GLOB NVPRO_CORE_GLSL_FILES ${BASE_DIRECTORY}/nvpro_core/nvvkhl/shaders/*) -install(FILES ${GLSL_FILES} CONFIGURATIONS Release DESTINATION "bin_${ARCH}/GLSL_${SAMPLE_EXECUTABLE}") -install(FILES ${GLSL_FILES} CONFIGURATIONS Debug DESTINATION "bin_${ARCH}_debug/GLSL_${SAMPLE_EXECUTABLE}") -install(FILES ${NVPRO_CORE_GLSL_FILES} CONFIGURATIONS Release DESTINATION "bin_${ARCH}/GLSL_${SAMPLE_EXECUTABLE}/nvvkhl/shaders") -install(FILES ${NVPRO_CORE_GLSL_FILES} CONFIGURATIONS Debug DESTINATION "bin_${ARCH}_debug/GLSL_${SAMPLE_EXECUTABLE}/nvvkhl/shaders") -install(FILES ${DLSS_DLLS} CONFIGURATIONS Release DESTINATION "bin_${ARCH}") -install(FILES ${DLSS_DLLS} CONFIGURATIONS Debug DESTINATION "bin_${ARCH}_debug") -install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/doc/icon.png CONFIGURATIONS Release DESTINATION "bin_${ARCH}/media") -install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/doc/icon.png CONFIGURATIONS Debug DESTINATION "bin_${ARCH}_debug/media") +# Install shaders. Unlike some samples, these are loaded at runtime and not embedded in the binary +set(CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/_install" CACHE PATH "Install path prefix") +install(FILES ${GLSL_FILES} CONFIGURATIONS Release DESTINATION "bin_${CMAKE_SYSTEM_PROCESSOR}/GLSL_${SAMPLE_EXECUTABLE}") +install(FILES ${GLSL_FILES} CONFIGURATIONS Debug DESTINATION "bin_${CMAKE_SYSTEM_PROCESSOR}_debug/GLSL_${SAMPLE_EXECUTABLE}") +install(FILES ${DLSS_DLLS} CONFIGURATIONS Release DESTINATION "bin_${CMAKE_SYSTEM_PROCESSOR}") +install(FILES ${DLSS_DLLS} CONFIGURATIONS Debug DESTINATION "bin_${CMAKE_SYSTEM_PROCESSOR}_debug") +install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/doc/icon.png CONFIGURATIONS Release DESTINATION "bin_${CMAKE_SYSTEM_PROCESSOR}/media") +install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/doc/icon.png CONFIGURATIONS Debug DESTINATION "bin_${CMAKE_SYSTEM_PROCESSOR}_debug/media") # Debug in the source directory to avoid having a set of relative shader include # paths just for debugging with visual studio @@ -376,16 +588,10 @@ if(UNIX AND CMAKE_BUILD_TYPE STREQUAL "Release") COMMAND ${CMAKE_COMMAND} -E make_directory "${APPDIR}" # Copy executable, shaders, libraries, media - # TODO: if only we could use RUNTIME_DEPENDENCIES or - # GET_RUNTIME_DEPENDENCIES, but the nvpro_core use of CMAKE_INSTALL_PREFIX - # makes this difficult to do at the same time. COMMAND ${CMAKE_COMMAND} -E copy "$" "${APPDIR}/" COMMAND ${CMAKE_COMMAND} -E make_directory "${APPDIR}/GLSL_${SAMPLE_EXECUTABLE}" COMMAND ${CMAKE_COMMAND} -E copy ${GLSL_FILES} "${APPDIR}/GLSL_${SAMPLE_EXECUTABLE}/" - COMMAND ${CMAKE_COMMAND} -E make_directory "${APPDIR}/GLSL_${SAMPLE_EXECUTABLE}/nvvkhl/shaders" - COMMAND ${CMAKE_COMMAND} -E copy ${NVPRO_CORE_GLSL_FILES} "${APPDIR}/GLSL_${SAMPLE_EXECUTABLE}/nvvkhl/shaders/" COMMAND ${CMAKE_COMMAND} -E copy ${DLSS_DLLS} "${APPDIR}/" - COMMAND ${CMAKE_COMMAND} -E copy ${Vulkan_LIBRARY} "${APPDIR}/" COMMAND ${CMAKE_COMMAND} -E make_directory "${APPDIR}/media" COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_SOURCE_DIR}/doc/icon.png" "${APPDIR}/media/" COMMAND ${CMAKE_COMMAND} -E copy_directory "${DOWNLOAD_TARGET_DIR}/bunny_v2" "${APPDIR}/media/bunny_v2" @@ -407,9 +613,7 @@ if(UNIX AND CMAKE_BUILD_TYPE STREQUAL "Release") DEPENDS ${SAMPLE_EXECUTABLE} ${GLSL_FILES} - ${NVPRO_CORE_GLSL_FILES} ${DLSS_DLLS} - ${Vulkan_LIBRARY} "${APPRUN_SCRIPT}" "${CMAKE_SOURCE_DIR}/doc/icon.svg" "${CMAKE_SOURCE_DIR}/doc/icon.png" diff --git a/README.md b/README.md index 942328c..748f4e8 100644 --- a/README.md +++ b/README.md @@ -2,11 +2,11 @@ > [!NOTE] > This demo is now independently maintained by me, the original NVIDIA -> developer, forked from [here](https://github.com/NVIDIA-RTX/VKLOD-Sample). I -> hope you enjoy it or find something useful. Feel free to file issues on -> GitHub. For reference, -> [vk_lod_clusters](https://github.com/nvpro-samples/vk_lod_clusters) is a -> similar Vulkan demo still actively maintained by NVIDIA. +> developer, forked from [here](https://github.com/NVIDIA-RTX/VKLOD-Sample) and +> ported to [vulkan_objects](https://github.com/pknowles/vulkan_objects). I hope +> you enjoy it or find something useful. Feel free to file issues on GitHub. For +> reference, [vk_lod_clusters](https://github.com/nvpro-samples/vk_lod_clusters) +> is a similar Vulkan demo still actively maintained by NVIDIA. ![preview](doc/clusters.jpg) @@ -16,8 +16,8 @@ from disk, like [Nanite's virtual geometry](https://dev.epicgames.com/documentation/en-us/unreal-engine/nanite-virtualized-geometry-in-unreal-engine) but for ray tracing. It is [RAII](https://www.heuristic42.com/blog/66/raii-the-powerful-implication-of-always-initializing/) -leaning and intends to demonstrate Vulkan API usage and object design ideas. -[**Download and run the latest +leaning and intends to demonstrate Vulkan API usage and object design ideas as +well as LOD. [**Download and run the latest release**](https://github.com/pknowles/VKLOD-Sample/releases/latest) or [build](#building-and-dependencies) from source. You'll need an NVIDIA RTX GPU and somewhat recent [drivers](https://www.nvidia.com/drivers/). @@ -249,25 +249,52 @@ Some key parts to focus on: Much of the `src/sample_*` code is boilerplate vulkan and can be ignored. As is setup and rendering in `main.cpp` and `renderer_*`. -This demo leans towards RAII and layered utilities. For readers who prefer more -direct inline Vulkan API calls, you might find some equivalent functionality in -[vk_lod_clusters](https://github.com/nvpro-samples/vk_lod_clusters) more to your -liking. - The path tracing and shading code is illustrative only and not intended as a reference implementation. +## Vulkan and RAII + +This demo uses the [vulkan_objects](https://github.com/pknowles/vulkan_objects) +library, a lightweight +[RAII](https://www.heuristic42.com/blog/66/raii-the-powerful-implication-of-always-initializing/) +vulkan provider and wrapper. At its core is a template handle class that +guarantees vulkan objects are always initialized and valid. It takes a bit more +time to design around this constraint, but it can lead to better designs as it's +harder to tangle object dependencies and lifetimes. This alone can be used, but +there are many more utilities with a similar safety philosophy that may be of +interest. Check out the [quick ref](https://github.com/pknowles/vulkan_objects#quick-reference). + +For readers who prefer more direct inline Vulkan API calls, you might find some +equivalent LOD rendering in +[vk_lod_clusters](https://github.com/nvpro-samples/vk_lod_clusters) more to your +liking. + ## Building and Dependencies +None, in some sense. + An NVIDIA RTX GPU is required to run the demo. The Vulkan implementation (driver) must support [`VK_NV_cluster_acceleration_structure`](https://registry.khronos.org/vulkan/specs/latest/man/html/VK_NV_cluster_acceleration_structure.html). -This demo uses [CMake](https://cmake.org/download/) and requires the [Vulkan -SDK](https://vulkan.lunarg.com/). It is tested on Windows (with [Visual -Studio](https://visualstudio.microsoft.com/vs/) 2022) and Linux (gcc 14). It -uses git submodules and fetch_content for other dependencies. After cloning, -run: +A standard C++ development environment: + +- [CMake](https://cmake.org/download/) +- C++23: `gcc`, `clang` or [visual studio](https://visualstudio.microsoft.com/downloads/) + +Dependencies included: + +- The `vulkan_objects` submodule +- Source code downloaded via CMake's FetchContent +- NVIDIA DLSS pre-built binaries are downloaded from https://github.com/NVIDIA/DLSS by CMake + +The LunarG Vulkan SDK is NOT required. +[vulkan_objects](https://github.com/pknowles/vulkan_objects) has its own loader +and uses function tables rather than loading into global function pointers. +While they are compatible, the application can be built entirely from source +without and in turn does not have to target a specific Vulkan SDK version. + +It is tested with g++ 15.2 and Visual Studio 2022: ```bash git submodule update --init --recursive @@ -277,7 +304,6 @@ cmake -S . -B build cmake --build build --config Release --parallel # Linux -source path/to/vulkan-sdk/setup-env.sh cmake -S . -B build -DCMAKE_BUILD_TYPE=Release cmake --build build --parallel ``` @@ -306,6 +332,8 @@ This demo is licensed under the [Apache License This demo uses third-party dependencies, which have their own: +- [vulkan_objects](https://github.com/pknowles/vulkan_objects), licensed under the + [MIT License](https://github.com/pknowles/vulkan_objects/blob/main/LICENSE) - [nv_cluster_lod_builder](https://github.com/pknowles/nv_cluster_lod_builder), licensed under the [Apache License 2.0](https://github.com/pknowles/nv_cluster_lod_builder/blob/main/LICENSE) @@ -316,10 +344,28 @@ under the [Apache License [MIT License](https://github.com/zeux/meshoptimizer/blob/47aafa533b439a78b53cd2854c177db61be7e666/LICENSE.md) - [decodeless collection](https://github.com/decodeless), licensed under the [MIT License](https://github.com/decodeless/writer/blob/main/LICENSE) -- [nvpro_core](https://github.com/nvpro-samples/nvpro_core), licensed under the - [Apache License - 2.0](https://github.com/nvpro-samples/nvpro_core/blob/master/LICENSE) -- [Vulkan SDK](https://www.lunarg.com/vulkan-sdk/), see https://vulkan.lunarg.com/license/ for the version you installed +- `./nvpro_core_legacy` fragments from [nvpro_core](https://github.com/nvpro-samples/nvpro_core), licensed under the + [Apache License 2.0](https://github.com/nvpro-samples/nvpro_core/blob/master/LICENSE) + - Code fragments: dxh (Microsoft, MIT), nvtx (Nvidia, Apache 2.0) + - [nlohmann/json](https://github.com/nlohmann/json/blob/develop/LICENSE.MIT), MIT + - [Open Iconic font](https://github.com/iconic/open-iconic), MIT + - [Roboto font](https://fonts.google.com/specimen/Roboto/license) +- [GLFW](https://github.com/glfw/glfw), licensed under + [zlib License](https://github.com/glfw/glfw/blob/master/LICENSE.md) +- [Dear ImGui](https://github.com/ocornut/imgui), licensed under + [MIT License](https://github.com/ocornut/imgui/blob/master/LICENSE.txt) +- [ImPlot](https://github.com/epezent/implot), licensed under + [MIT License](https://github.com/epezent/implot/blob/master/LICENSE) +- [ImGuiFileDialog](https://github.com/aiekick/ImGuiFileDialog), licensed under + [MIT License](https://github.com/aiekick/ImGuiFileDialog/blob/master/LICENSE) +- [Taywee/args](https://github.com/Taywee/args), licensed under + [MIT License](https://github.com/Taywee/args/blob/master/LICENSE) +- [cgltf](https://github.com/jkuhlmann/cgltf.git), licensed under + [MIT License](https://github.com/jkuhlmann/cgltf/blob/master/LICENSE) +- [stb_image](https://github.com/nothings/stb), licensed under + [MIT License / Public Domain](https://github.com/nothings/stb/blob/master/LICENSE) +- [glm](https://github.com/g-truc/glm), licensed under + [MIT License](https://github.com/g-truc/glm/blob/master/copying.txt) ## References diff --git a/build_and_test.sh b/build_and_test.sh new file mode 100755 index 0000000..ee05116 --- /dev/null +++ b/build_and_test.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +# Script to build and test vk_unified_memory +# Checks for VULKAN_SDK, configures and builds, then runs screenshot test + +set -e + +# Create build directory if it doesn't exist +if [ ! -d "build" ]; then + mkdir build +fi + +# Configure with CMake (Debug build) +echo "Configuring CMake (Debug)..." +cd build +cmake -DCMAKE_BUILD_TYPE=Debug .. + +# Build +echo "Building..." +cmake --build . -j$(nproc) + +# Go back to project root +cd .. + +# Run screenshot test +echo "Running screenshot test..." +./screenshot.sh "$@" + +echo "Build and test complete!" diff --git a/cmake/DownloadPackage.cmake b/cmake/DownloadPackage.cmake deleted file mode 100644 index 752fbfe..0000000 --- a/cmake/DownloadPackage.cmake +++ /dev/null @@ -1,162 +0,0 @@ -##################################################################################### -# Downloads the URL to FILENAME and extracts its content if EXTRACT option is present -# ZIP files should have a folder of the name of the archive -# - ex. foo.zip -> foo/ -# Arguments: -# FILENAMES : all filenames to download -# URLS : if present, a custom download URL for each FILENAME. -# If only one FILENAME is provided, a list of alternate download locations. -# Defaults to ${NVPRO_CORE2_DOWNLOAD_SITE}${SOURCE_DIR}/${FILENAME}. -# EXTRACT : if present, will extract the content of the file -# NOINSTALL : if present, will not make files part of install -# INSTALL_DIR : folder for the 'install' build, default is 'media' next to the executable -# TARGET_DIR : folder where to download to, default is {DOWNLOAD_TARGET_DIR} -# SOURCE_DIR : folder on server, if not present 'scenes' -# -# Examples: -# download_files(FILENAMES sample1.zip EXTRACT) -# download_files(FILENAMES env.hdr) -# download_files(FILENAMES zlib.zip EXTRACT TARGET_DIR ${BASE_DIRECTORY}/blah SOURCE_DIR /libraries NOINSTALL) -# -function(download_files) - set(options EXTRACT NOINSTALL) - set(oneValueArgs INSTALL_DIR SOURCE_DIR TARGET_DIR) - set(multiValueArgs FILENAMES URLS) - cmake_parse_arguments(DOWNLOAD_FILES "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} ) - - if(NOT DEFINED DOWNLOAD_FILES_INSTALL_DIR) - set(DOWNLOAD_FILES_INSTALL_DIR "resources") - endif() - if(NOT DEFINED DOWNLOAD_FILES_SOURCE_DIR) - set(DOWNLOAD_FILES_SOURCE_DIR "") - endif() - if(NOT DEFINED DOWNLOAD_FILES_TARGET_DIR) - set(DOWNLOAD_FILES_TARGET_DIR ${NVPRO_CORE2_DOWNLOAD_DIR}) - endif() - - # Check each file to download - # In CMake 3.17+, we can change this to _FILENAME_URL IN ZIP_LISTS DOWNLOAD_FILES_FILENAMES DOWNLOAD_FILES_URLS - list(LENGTH DOWNLOAD_FILES_FILENAMES _NUM_DOWNLOADS) - math(EXPR _DOWNLOAD_IDX_MAX "${_NUM_DOWNLOADS}-1") - foreach(_DOWNLOAD_IDX RANGE ${_DOWNLOAD_IDX_MAX}) - list(GET DOWNLOAD_FILES_FILENAMES ${_DOWNLOAD_IDX} FILENAME) - set(_TARGET_FILENAME ${DOWNLOAD_FILES_TARGET_DIR}/${FILENAME}) - - set(_DO_DOWNLOAD ON) - if(EXISTS ${_TARGET_FILENAME}) - file(SIZE ${_TARGET_FILENAME} _FILE_SIZE) - if(${_FILE_SIZE} GREATER 0) - set(_DO_DOWNLOAD OFF) - endif() - endif() - - if(_DO_DOWNLOAD) - if(DOWNLOAD_FILES_URLS AND (_NUM_DOWNLOADS GREATER 1)) # One URL per file - list(GET DOWNLOAD_FILES_URLS ${_DOWNLOAD_IDX} _DOWNLOAD_URLS) - elseif(DOWNLOAD_FILES_URLS) # One file, multiple URLs - set(_DOWNLOAD_URLS ${DOWNLOAD_FILES_URLS}) - else() - set(_DOWNLOAD_URLS ${NVPRO_CORE2_DOWNLOAD_SITE}${DOWNLOAD_FILES_SOURCE_DIR}/${FILENAME}) - endif() - - foreach(_DOWNLOAD_URL ${_DOWNLOAD_URLS}) - message(STATUS "Downloading ${_DOWNLOAD_URL} to ${_TARGET_FILENAME}") - - file(DOWNLOAD ${_DOWNLOAD_URL} ${_TARGET_FILENAME} - SHOW_PROGRESS - STATUS _DOWNLOAD_STATUS) - - # Check whether the download succeeded. _DOWNLOAD_STATUS is a list of - # length 2; element 0 is the return value (0 == no error), element 1 is - # a string value for the error. - list(GET _DOWNLOAD_STATUS 0 _DOWNLOAD_STATUS_CODE) - if(${_DOWNLOAD_STATUS_CODE} EQUAL 0) - break() # Successful download! - else() - list(GET _DOWNLOAD_STATUS 1 _DOWNLOAD_STATUS_MESSAGE) - # CMake usually creates a 0-byte file in this case. Remove it: - file(REMOVE ${_TARGET_FILENAME}) - message(WARNING "Download of ${_DOWNLOAD_URL} to ${_TARGET_FILENAME} failed with code ${_DOWNLOAD_STATUS_CODE}: ${_DOWNLOAD_STATUS_MESSAGE}") - endif() - endforeach() - - if(NOT EXISTS ${_TARGET_FILENAME}) - message(FATAL_ERROR "All possible downloads to ${_TARGET_FILENAME} failed. See above warnings for more info.") - endif() - - # Extracting the ZIP file - if(DOWNLOAD_FILES_EXTRACT) - execute_process(COMMAND ${CMAKE_COMMAND} -E tar -xf ${_TARGET_FILENAME} - WORKING_DIRECTORY ${DOWNLOAD_FILES_TARGET_DIR}) - # We could use ARCHIVE_EXTRACT instead, but it needs CMake 3.18+: - # file(ARCHIVE_EXTRACT INPUT ${_TARGET_FILENAME} - # DESTINATION ${DOWNLOAD_FILES_TARGET_DIR}) - endif() - endif() - - # Installing the files or directory - if (NOT DOWNLOAD_FILES_NOINSTALL) - if(DOWNLOAD_FILES_EXTRACT) - get_filename_component(FILE_DIR ${FILENAME} NAME_WE) - install(DIRECTORY ${DOWNLOAD_FILES_TARGET_DIR}/${FILE_DIR} DESTINATION "${DOWNLOAD_FILES_INSTALL_DIR}") - else() - install(FILES ${_TARGET_FILENAME} DESTINATION "${DOWNLOAD_FILES_INSTALL_DIR}") - endif() - endif() - endforeach() -endfunction() - - -##################################################################################### -# Downloads and extracts a package of source code and places it in -# downloaded_resources, if it doesn't already exist there. By default, downloads -# from the nvpro-samples server. -# Sets the variable in the DIR argument to its location. -# If it doesn't exist and couldn't be found, produces a fatal error. -# This is intended as a sort of lightweight package manager, for packages that -# are used by 2 or fewer samples, can be downloaded without authentication, and -# are not fundamental graphics APIs (like DirectX 12 or OptiX). -# -# Arguments: -# NAME : The name of the package to find. E.g. NVAPI looks for -# a folder named NVAPI or downloads NVAPI.zip. -# URLS : Optional path to an archive to download. By default, this -# downloads from ${NVPRO_CORE2_DOWNLOAD_SITE}/libraries/${NAME}-${VERSION}.zip. -# If more than one URL is specified, tries them in turn until one works. -# VERSION : The package's version number, like "555.0.0" or "1.1.0". -# LOCATION : Will be set to the package's directory. -# -function(download_package) - set(oneValueArgs NAME VERSION LOCATION) - set(multiValueArgs URLS) - cmake_parse_arguments(DOWNLOAD_PACKAGE "" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} ) - - set(_TARGET_DIR ${CMAKE_BINARY_DIR}/_deps/${DOWNLOAD_PACKAGE_NAME}-${DOWNLOAD_PACKAGE_VERSION}) - if(EXISTS ${_TARGET_DIR}) - # An empty directory is not a valid cache entry; that usually indicates - # a failed download. - file(GLOB _TARGET_DIR_FILES "${_TARGET_DIR}/*") - list(LENGTH _TARGET_DIR_FILES _TARGET_DIR_NUM_FILES) - if(_TARGET_DIR_NUM_FILES GREATER 0) - set(${DOWNLOAD_PACKAGE_LOCATION} ${_TARGET_DIR} PARENT_SCOPE) - return() - endif() - endif() - - # Cache couldn't be used. Download the package: - if(DOWNLOAD_PACKAGE_URLS) - set(_URLS ${DOWNLOAD_PACKAGE_URLS}) - else() - set(_URLS ${NVPRO_CORE2_DOWNLOAD_SITE}/libraries/${DOWNLOAD_PACKAGE_NAME}-${DOWNLOAD_PACKAGE_VERSION}.zip) - endif() - download_files(FILENAMES "${DOWNLOAD_PACKAGE_NAME}.zip" - URLS ${_URLS} - EXTRACT - TARGET_DIR ${_TARGET_DIR} - NOINSTALL - ) - # Save some space by cleaning up the archive we extracted from. - file(REMOVE ${_TARGET_DIR}/${DOWNLOAD_PACKAGE_NAME}.zip) - - set(${DOWNLOAD_PACKAGE_LOCATION} ${_TARGET_DIR} PARENT_SCOPE) -endfunction() diff --git a/cmake/FindNGX.cmake b/cmake/FindNGX.cmake index 592130d..9982c51 100644 --- a/cmake/FindNGX.cmake +++ b/cmake/FindNGX.cmake @@ -38,21 +38,44 @@ # If multiple versions of NGX are pulled, first one wins. #------------------------------------------------------------------------------- -# Download the DLSS SDK. -if(NOT DLSS_VERSION) - set(DLSS_VERSION "310.4.0" CACHE STRING "DLSS version to download.") -endif() +# Download the DLSS SDK using standard CMake functions. +set(DLSS_VERSION "310.5.3" CACHE STRING "DLSS version to download from https://github.com/NVIDIA/DLSS") set(_DLSS_URL "https://github.com/NVIDIA/DLSS/archive/refs/tags/v${DLSS_VERSION}.zip") -include(DownloadPackage) -download_package( - NAME DLSSRR - URLS ${_DLSS_URL} - VERSION ${DLSS_VERSION} - LOCATION DLSS_SOURCE_DIR -) +set(_DLSS_TARGET_DIR "${CMAKE_BINARY_DIR}/_deps/DLSSRR-${DLSS_VERSION}") +set(_DLSS_ZIP_FILE "${_DLSS_TARGET_DIR}/DLSS-${DLSS_VERSION}.zip") +set(_DLSS_EXPECTED_ROOT "${_DLSS_TARGET_DIR}/DLSS-${DLSS_VERSION}") + +# Check if we already have the package downloaded and extracted +# Use absolute path to avoid any resolution issues +set(_DLSS_INCLUDE_CHECK "${_DLSS_EXPECTED_ROOT}/include") +if(EXISTS "${_DLSS_INCLUDE_CHECK}") + message(STATUS "Found existing DLSS-RR (v${DLSS_VERSION}) at '${_DLSS_EXPECTED_ROOT}'") +else() + # Path doesn't exist - need to download + if(NOT EXISTS "${_DLSS_ZIP_FILE}") + message(STATUS "Downloading DLSS-RR (v${DLSS_VERSION}) from ${_DLSS_URL}") + file(DOWNLOAD ${_DLSS_URL} "${_DLSS_ZIP_FILE}" + SHOW_PROGRESS + STATUS _DOWNLOAD_STATUS) + list(GET _DOWNLOAD_STATUS 0 _DOWNLOAD_STATUS_CODE) + list(GET _DOWNLOAD_STATUS 1 _DOWNLOAD_STATUS_MESSAGE) + if(NOT _DOWNLOAD_STATUS_CODE EQUAL 0) + file(REMOVE "${_DLSS_ZIP_FILE}") + message(FATAL_ERROR "Failed to download DLSS: ${_DOWNLOAD_STATUS_MESSAGE}") + endif() + endif() + + # Extract the zip file + message(STATUS "Extracting DLSS-RR (v${DLSS_VERSION}) from ${_DLSS_ZIP_FILE}") + file(ARCHIVE_EXTRACT + INPUT "${_DLSS_ZIP_FILE}" + DESTINATION ${_DLSS_TARGET_DIR}) + + message(STATUS "Using downloaded DLSS-RR (v${DLSS_VERSION}) at '${_DLSS_EXPECTED_ROOT}'") +endif() -set(DLSS_ROOT ${DLSS_SOURCE_DIR}/DLSS-${DLSS_VERSION}) -message(STATUS "--> using DLSS-RR under: ${DLSS_ROOT}") +set(DLSS_ROOT ${_DLSS_EXPECTED_ROOT}) +set(DLSS_SOURCE_DIR ${_DLSS_TARGET_DIR}) # Collect DLSS DLLs that need to be copied. if (WIN32) diff --git a/nvpro_core b/nvpro_core deleted file mode 160000 index ba24b73..0000000 --- a/nvpro_core +++ /dev/null @@ -1 +0,0 @@ -Subproject commit ba24b73e3a918adfe6ca932a6bf749a1d874d9b0 diff --git a/nvpro_core_legacy/README.md b/nvpro_core_legacy/README.md new file mode 100644 index 0000000..3f7ce3a --- /dev/null +++ b/nvpro_core_legacy/README.md @@ -0,0 +1,13 @@ +# Legacy nvpro_core Components + +This directory contains a small selection of components copied from the +deprecated [`nvpro_core`](https://github.com/nvpro-samples/nvpro_core) library +and partially ported to use +[`vulkan_objects`](https://github.com/pknowles/vulkan_objects). Many objects are +still not move-safe, require delayed initialization and explicit destruction. + +- `fileformats` and `third_party/dxh` for texture loading +- `imgui` for an icon font +- `nvh` and `nvtx3` for NVTX marker definitions (should prob be using upstream) +- `nvvkhl` for the embedded roboto font, tonemapper and shader fragments +- `third_party/tinygltf/json.hpp` for a json parser diff --git a/nvpro_core_legacy/fileformats/README.md b/nvpro_core_legacy/fileformats/README.md new file mode 100644 index 0000000..f69c747 --- /dev/null +++ b/nvpro_core_legacy/fileformats/README.md @@ -0,0 +1,362 @@ +## Table of Contents +- [khr_df.h](#khr_dfh) +- [nv_dds.h](#nv_ddsh) +- [nv_ktx.h](#nv_ktxh) +- [texture_formats.h](#texture_formatsh) +- [tinygltf_utils.hpp](#tinygltf_utilshpp) +- [tiny_converter.hpp](#tiny_converterhpp) + +## khr_df.h + +> The Khronos Data Format header, from https://registry.khronos.org/DataFormat/. + +This header defines a structure that can describe the layout of image +formats in memory. This means that the data format is transparent to +the application, and the expectation is that this should be used when +the layout is defined external to the API. Many Khronos APIs deliberately +keep the internal layout of images opaque, to allow proprietary layouts +and optimisations. This structure is not appropriate for describing +opaque layouts. + + +## nv_dds.h +### nv_dds 2.1.0 + +> A small yet complete library for reading and writing DDS files. + +Other than the C++ standard library, nv_dds only requires five files: +dxgiformat.h, nv_dds.h, nv_dds.cpp, texture_formats.h, and texture_formats.cpp. + +To load a DDS file, use `Image::readFromFile()`: + +```cpp +nv_dds::Image image; +nv_dds::ErrorWithText maybeError = image.readFromFile("data/image.dds", {}); +if(maybeError.has_value()) +{ + // Do something with the error message, maybeError.value() +} +else +{ + // Access subresources using image.subresource(...), and upload them + // to the GPU using your graphics API of choice. +} +``` + +`Image`'s format field is a DXGI format. If you need to use this data with +another API, you can use the functions in texture_formats.h to look up +the corresponding API format. + +To write a DDS file, use `Image::writeToFile()`: + +```cpp +nv_dds::ErrorWithText maybe_error = image.writeToFile("output.dds", {}); +if(maybe_error.has_value()) +{ + LOGE("Failed to write to output.dds! The DDS writer reported: %s\n", + maybe_error.value().c_str()); +} +``` + +`Image` also provides functions to read and write streams. Each of these +read and write functions supports various settings; see `ReadSettings` +and `WriteSettings`. + +Images can also be created from raw data: +```cpp +nv_dds::Image image; +image.allocate(1, // _numMips + 1, // _numLayers + 1); // _numFaces +image.subresource(0, 0, 0) // mip, layer, face + .create(512, 512, 1, subresource_data); // width, height, depth, data + = nv_dds::Subresource(512, 512, 1, subresource_data); // width, height, depth, data +``` + +#### Limitations + +Not currently supported: +* Multi-plane YUV textures with chroma subsampling + (e.g. `DXGI_FORMAT_R8G8_B8G8_UNORM`) +* Paletted textures +* DirectDraw Surface versions before DX9 + +#### Changes from nv_dds 1.0 + +nv_dds adds support for many more formats, fixes many issues, and now aims +to be secure against untrusted input, so it's worth updating. However, the API +has almost entirely changed, and now looks much more like nv_ktx's API: + +* `CSurface` is now `nv_dds::Subresource` +* `CDDSImage` is now `nv_dds::Image` +* `CTexture` (representing a mip chain) has been moved to part of `Image`. +* Images can no longer be flipped. It turns out the code for this only worked +for mips whose height was a multiple of the block size; in all other cases, +flipping a block-compressed image across the y axis requires decompressing +and recompressing it, which is outside the scope of nv_dds. (We recommend +flipping your sampling y axis instead; if flipping compressed image data is +absolutely necessary, consider using a library such as NVTT.) + + +## nv_ktx.h + +> A mostly self-contained reader and writer for KTX2 files and reader for KTX1 +> files. + +Relies on Vulkan (for KTX2), GL (for KTX1), and the Khronos Data Format. + +Sample usage for reading files: + +```cpp +KTXImage image; +ErrorWithText maybe_error = image.readFromFile("data/image.ktx2", {}); +if(maybe_error.has_value()) +{ + // Do something with the error message, maybe_error.value() +} +else +{ + // Access subresources using image.subresource(...), and upload them + // to the GPU using your graphics API of choice. +} +``` + +Define `NVP_SUPPORTS_ZSTD`, `NVP_SUPPORTS_GZLIB`, and `NVP_SUPPORTS_BASISU` to +include the Zstd, Zlib, and Basis Universal headers respectively, and to +enable reading these formats. This will also enable writing Zstd and +Basis Universal-compressed formats. +If you're using this inside the nvpro-samples framework, you can add all +three quickly by adding `_add_package_KTX()` to your dependencies +in CMakeLists.txt. + + +## texture_formats.h + +Provides: +* Methods for translating texture format names between DirectX, Vulkan, and +OpenGL. +* A method for getting the size of a Vulkan subresource using linear tiling. +* The extended ASTC values for DXGI_FORMAT. + + +## tinygltf_utils.hpp +### namespace `tinygltf::utils` +> Utility functions for extracting structs from tinygltf's representation of glTF. +#### Function `getValue` +> Gets the value of type T for the attribute `name`. + +This function retrieves the value of the specified attribute from a tinygltf::Value +and stores it in the provided result variable. + +Parameters: +- value: The `tinygltf::Value` from which to retrieve the attribute. +- name: The name of the attribute to retrieve. +- result: The variable to store the retrieved value in. +#### Function `getValue(..., float& result)` +> Specialization of `getValue()` for float type. + +Retrieves the value of the specified attribute as a float and stores it in the result variable. +#### Function `getValue(..., tinygltf::TextureInfo& result)` +> Specialization of `getValue()` for `nvvkhl::Gltf::Texture` type. + +Retrieves the texture attribute values and stores them in the result variable. +#### Function `setValue` +> Sets attribute `key` to value `val`. +#### Function `setValue(... tinygltf::TextureInfo)` +> Sets attribute `key` to a JSON object with an `index` and `texCoord` set from +> the members of `textureInfo`. +#### Function `getArrayValue` +> Gets the value of type T for the attribute `name`. + +This function retrieves the array value of the specified attribute from a `tinygltf::Value` +and stores it in the provided result variable. It is used for types such as `glm::vec3`, `glm::vec4`, `glm::mat4`, etc. + +Parameters: +- value: The `tinygltf::Value` from which to retrieve the attribute. +- name: The name of the attribute to retrieve. +- result: The variable to store the retrieved array value in. +#### Function `setArrayValue` +> Sets attribute `name` of the given `value` to an array with the first +> `numElements` elements from the `array` pointer. +#### Function `convertToTinygltfValue` +> Converts a vector of elements to a `tinygltf::Value`. + +This function converts a given array of float elements into a `tinygltf::Value::Array`, +suitable for use within the tinygltf library. + +Parameters: +- numElements: The number of elements in the array. +- elements: A pointer to the array of float elements. + +Returns: +- A `tinygltf::Value` representing the array of elements. +#### Function `getNodeTRS` +> Retrieves the translation, rotation, and scale of a GLTF node. + +This function extracts the translation, rotation, and scale (TRS) properties +from the given GLTF node. If the node has a matrix defined, it decomposes +the matrix to obtain these properties. Otherwise, it directly retrieves +the TRS values from the node's properties. + +Parameters: +- node: The GLTF node from which to extract the TRS properties. +- translation: Output parameter for the translation vector. +- rotation: Output parameter for the rotation quaternion. +- scale: Output parameter for the scale vector. +* ## Function `setNodeTRS` +> Sets the translation, rotation, and scale of a GLTF node. + +This function sets the translation, rotation, and scale (TRS) properties of +the given GLTF node using the provided values. + +Parameters: +- node: The GLTF node to modify. +- translation: The translation vector to set. +- rotation: The rotation quaternion to set. +- scale: The scale vector to set. +* ## Function `getNodeMatrix` +> Retrieves the transformation matrix of a GLTF node. + +This function computes the transformation matrix for the given GLTF node. +If the node has a direct matrix defined, it returns that matrix as defined in +the specification. Otherwise, it computes the matrix from the node's translation, +rotation, and scale (TRS) properties. + +Parameters: +- node: The GLTF node for which to retrieve the transformation matrix. + +Returns: +- The transformation matrix of the node. +#### Function `generatePrimitiveKey` +> Generates a unique key for a GLTF primitive based on its attributes. + +This function creates a unique string key for the given GLTF primitive by +concatenating its attribute keys and values. This is useful for caching +the primitive data, thereby avoiding redundancy. + +Parameters: +- primitive: The GLTF primitive for which to generate the key. + +Returns: +- A unique string key representing the primitive's attributes. +#### Function `traverseSceneGraph` +> Traverses the scene graph and calls the provided functions for each element. + +This utility function recursively traverses the scene graph starting from the +specified node ID. It calls the provided functions for cameras, lights, and +meshes when encountered. The traversal can be stopped early if any function +returns `true`. + +Parameters: +- model: The GLTF model containing the scene graph. +- nodeID: The ID of the node to start traversal from. +- parentMat: The transformation matrix of the parent node. +- fctCam: Function to call when a camera is encountered. Can be `nullptr`. +- fctLight: Function to call when a light is encountered. Can be `nullptr`. +- fctMesh: Function to call when a mesh is encountered. Can be `nullptr`. +#### Function `getVertexCount` +> Returns the number of vertices in a primitive. + +This function retrieves the number of vertices for the given GLTF primitive +by accessing the "POSITION" attribute in the model's accessors. + +Parameters: +- model: The GLTF model containing the primitive data. +- primitive: The GLTF primitive for which to retrieve the vertex count. + +Returns: +- The number of vertices in the primitive. +#### Function `getIndexCount` +> Returns the number of indices in a primitive. + +This function retrieves the number of indices for the given GLTF primitive +by accessing the indices in the model's accessors. If no indices are present, +it returns the number of vertices instead. + +Parameters: +- model: The GLTF model containing the primitive data. +- primitive: The GLTF primitive for which to retrieve the index count. + +Returns: +- The number of indices in the primitive, or the number of vertices if no indices are present. +#### Function `hasElementName` +> Check if the map has the specified element. + +Can be used for extensions, extras, or any other map. +Returns `true` if the map has the specified element, `false` otherwise. +#### Function `getElementValue` +> Get the value of the specified element from the map. + +Can be `extensions`, `extras`, or any other map. +Returns the value of the element. +#### Function `getBufferDataSpan` +> Retrieves the buffer data for the specified accessor from the GLTF model +> and returns it as a span of type `T`. + +The function assumes that the buffer data is of type `T`. +It also performs assertions to ensure that the accessor and buffer data are compatible; these will be ignored +if assertions are off. + +Example usage: + +```cpp +int accessorIndex = primitive.attributes.at("POSITION"); +std::span positions = tinygltf::utils::getBufferDataSpan(model, accessorIndex); +``` +#### Function `forEachSparseValue` +> Calls a function (such as a lambda function) for each `(index, value)` pair in +> a sparse accessor. + +It's only potentially called for indices from +`accessorFirstElement` through `accessorFirstElement + numElementsToProcess - 1`. +#### Function `copyAccessorData` +> Copies accessor elements `accessorFirstElement` through +> `accessorFirstElement + numElementsToCopy - 1` to `outData` elements +> `outFirstElement` through `outFirstElement + numElementsToCopy - 1`. + +This handles sparse accessors correctly! It's intended as a replacement for +what would be `memcpy(..., &buffer.data[...], ...)` calls. + +However, it performs no conversion: it assumes (but does not check) that +accessor's elements are of type `T`. For instance, `T` should be a struct of two +floats for a `VEC2` float accessor. + +This is range-checked, so elements that would be out-of-bounds are not +copied. We assume `size_t` overflow does not occur. + +Note that `outDataSizeInT` is the number of elements in the `outDataBuffer`, +while `numElementsToCopy` is the number of elements to copy, not the number +of elements in `accessor`. +#### Function `copyAccessorData(std::vector& outData, ...)` +> Same as `copyAccessorData(T*, ...)`, but taking a vector. +#### Function `getAccessorData` +> Appends all the values of `accessor` to `attribVec`. + +Returns `false` if the accessor is invalid. +`T` must be `glm::vec2`, `glm::vec3`, or `glm::vec4`. +#### Function `getAttribute` +> Appends all the values of `attribName` to `attribVec`. + +Returns `false` if the attribute is missing or invalid. +`T` must be `glm::vec2`, `glm::vec3`, or `glm::vec4`. +#### Function `appendData` +> Appends data from `inData` to the binary buffer `buffer` and returns the number +> of bytes of data added. + +`T` should be a type like `std::vector`. +#### Function `getTextureImageIndex` +> Retrieves the image index of a texture, accounting for extensions such as +> `MSFT_texture_dds` and `KHR_texture_basisu`. +> Retrieves the visibility of a node using `KHR_node_visibility`. + +Does not search up the node hierarchy, so e.g. if node A points to node B and +node A is set to invisible and node B is set to visible, then +`getNodeVisibility(B)` will return `KHR_node_visibility{true}` even though +node B would not be visible due to node A. + +## tiny_converter.hpp + +Class TinyConverter + +> This class is used to convert a tinyobj::ObjReader to a tinygltf::Model. + diff --git a/nvpro_core_legacy/fileformats/khr_df.h b/nvpro_core_legacy/fileformats/khr_df.h new file mode 100644 index 0000000..8307a26 --- /dev/null +++ b/nvpro_core_legacy/fileformats/khr_df.h @@ -0,0 +1,633 @@ +/* The Khronos Data Format Specification (version 1.3) */ +/* +** Copyright (c) 2015-19 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are furnished to do so, subject to +** the following conditions: +** +** The above copyright notice and this permission notice shall be included +** in all copies or substantial portions of the Materials. +** +** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +*/ + +/* @DOC_START + +> The Khronos Data Format header, from https://registry.khronos.org/DataFormat/. + +This header defines a structure that can describe the layout of image +formats in memory. This means that the data format is transparent to +the application, and the expectation is that this should be used when +the layout is defined external to the API. Many Khronos APIs deliberately +keep the internal layout of images opaque, to allow proprietary layouts +and optimisations. This structure is not appropriate for describing +opaque layouts. + +@DOC_END */ + +/* We stick to standard C89 constructs for simplicity and portability. */ + +#ifndef _KHR_DATA_FORMAT_H_ +#define _KHR_DATA_FORMAT_H_ + +/* Accessors */ +typedef enum _khr_word_e { + KHR_DF_WORD_VENDORID = 0U, + KHR_DF_WORD_DESCRIPTORTYPE = 0U, + KHR_DF_WORD_VERSIONNUMBER = 1U, + KHR_DF_WORD_DESCRIPTORBLOCKSIZE = 1U, + KHR_DF_WORD_MODEL = 2U, + KHR_DF_WORD_PRIMARIES = 2U, + KHR_DF_WORD_TRANSFER = 2U, + KHR_DF_WORD_FLAGS = 2U, + KHR_DF_WORD_TEXELBLOCKDIMENSION0 = 3U, + KHR_DF_WORD_TEXELBLOCKDIMENSION1 = 3U, + KHR_DF_WORD_TEXELBLOCKDIMENSION2 = 3U, + KHR_DF_WORD_TEXELBLOCKDIMENSION3 = 3U, + KHR_DF_WORD_BYTESPLANE0 = 4U, + KHR_DF_WORD_BYTESPLANE1 = 4U, + KHR_DF_WORD_BYTESPLANE2 = 4U, + KHR_DF_WORD_BYTESPLANE3 = 4U, + KHR_DF_WORD_BYTESPLANE4 = 5U, + KHR_DF_WORD_BYTESPLANE5 = 5U, + KHR_DF_WORD_BYTESPLANE6 = 5U, + KHR_DF_WORD_BYTESPLANE7 = 5U, + KHR_DF_WORD_SAMPLESTART = 6U, + KHR_DF_WORD_SAMPLEWORDS = 4U +} khr_df_word_e; + +typedef enum _khr_df_shift_e { + KHR_DF_SHIFT_VENDORID = 0U, + KHR_DF_SHIFT_DESCRIPTORTYPE = 17U, + KHR_DF_SHIFT_VERSIONNUMBER = 0U, + KHR_DF_SHIFT_DESCRIPTORBLOCKSIZE = 16U, + KHR_DF_SHIFT_MODEL = 0U, + KHR_DF_SHIFT_PRIMARIES = 8U, + KHR_DF_SHIFT_TRANSFER = 16U, + KHR_DF_SHIFT_FLAGS = 24U, + KHR_DF_SHIFT_TEXELBLOCKDIMENSION0 = 0U, + KHR_DF_SHIFT_TEXELBLOCKDIMENSION1 = 8U, + KHR_DF_SHIFT_TEXELBLOCKDIMENSION2 = 16U, + KHR_DF_SHIFT_TEXELBLOCKDIMENSION3 = 24U, + KHR_DF_SHIFT_BYTESPLANE0 = 0U, + KHR_DF_SHIFT_BYTESPLANE1 = 8U, + KHR_DF_SHIFT_BYTESPLANE2 = 16U, + KHR_DF_SHIFT_BYTESPLANE3 = 24U, + KHR_DF_SHIFT_BYTESPLANE4 = 0U, + KHR_DF_SHIFT_BYTESPLANE5 = 8U, + KHR_DF_SHIFT_BYTESPLANE6 = 16U, + KHR_DF_SHIFT_BYTESPLANE7 = 24U +} khr_df_shift_e; + +typedef enum _khr_df_mask_e { + KHR_DF_MASK_VENDORID = 0x1FFFFU, + KHR_DF_MASK_DESCRIPTORTYPE = 0x7FFFU, + KHR_DF_MASK_VERSIONNUMBER = 0xFFFFU, + KHR_DF_MASK_DESCRIPTORBLOCKSIZE = 0xFFFFU, + KHR_DF_MASK_MODEL = 0xFFU, + KHR_DF_MASK_PRIMARIES = 0xFFU, + KHR_DF_MASK_TRANSFER = 0xFFU, + KHR_DF_MASK_FLAGS = 0xFFU, + KHR_DF_MASK_TEXELBLOCKDIMENSION0 = 0xFFU, + KHR_DF_MASK_TEXELBLOCKDIMENSION1 = 0xFFU, + KHR_DF_MASK_TEXELBLOCKDIMENSION2 = 0xFFU, + KHR_DF_MASK_TEXELBLOCKDIMENSION3 = 0xFFU, + KHR_DF_MASK_BYTESPLANE0 = 0xFFU, + KHR_DF_MASK_BYTESPLANE1 = 0xFFU, + KHR_DF_MASK_BYTESPLANE2 = 0xFFU, + KHR_DF_MASK_BYTESPLANE3 = 0xFFU, + KHR_DF_MASK_BYTESPLANE4 = 0xFFU, + KHR_DF_MASK_BYTESPLANE5 = 0xFFU, + KHR_DF_MASK_BYTESPLANE6 = 0xFFU, + KHR_DF_MASK_BYTESPLANE7 = 0xFFU +} khr_df_mask_e; + +/* Helper macro: + Extract field X from basic descriptor block BDB */ +#define KHR_DFDVAL(BDB, X) \ + (((BDB)[KHR_DF_WORD_ ## X] >> (KHR_DF_SHIFT_ ## X)) \ + & (KHR_DF_MASK_ ## X)) + +/* Helper macro: + Set field X of basic descriptor block BDB */ +#define KHR_DFDSETVAL(BDB, X, val) \ + ((BDB)[KHR_DF_WORD_ ## X] = \ + ((BDB)[KHR_DF_WORD_ ## X] & \ + ~((KHR_DF_MASK_ ## X) << (KHR_DF_SHIFT_ ## X))) | \ + (((val) & (KHR_DF_MASK_ ## X)) << (KHR_DF_SHIFT_ ## X))) + +/* Offsets relative to the start of a sample */ +typedef enum _khr_df_sampleword_e { + KHR_DF_SAMPLEWORD_BITOFFSET = 0U, + KHR_DF_SAMPLEWORD_BITLENGTH = 0U, + KHR_DF_SAMPLEWORD_CHANNELID = 0U, + KHR_DF_SAMPLEWORD_QUALIFIERS = 0U, + KHR_DF_SAMPLEWORD_SAMPLEPOSITION0 = 1U, + KHR_DF_SAMPLEWORD_SAMPLEPOSITION1 = 1U, + KHR_DF_SAMPLEWORD_SAMPLEPOSITION2 = 1U, + KHR_DF_SAMPLEWORD_SAMPLEPOSITION3 = 1U, + KHR_DF_SAMPLEWORD_SAMPLEPOSITION_ALL = 1U, + KHR_DF_SAMPLEWORD_SAMPLELOWER = 2U, + KHR_DF_SAMPLEWORD_SAMPLEUPPER = 3U +} khr_df_sampleword_e; + +typedef enum _khr_df_sampleshift_e { + KHR_DF_SAMPLESHIFT_BITOFFSET = 0U, + KHR_DF_SAMPLESHIFT_BITLENGTH = 16U, + KHR_DF_SAMPLESHIFT_CHANNELID = 24U, + /* N.B. Qualifiers are defined as an offset into a byte */ + KHR_DF_SAMPLESHIFT_QUALIFIERS = 24U, + KHR_DF_SAMPLESHIFT_SAMPLEPOSITION0 = 0U, + KHR_DF_SAMPLESHIFT_SAMPLEPOSITION1 = 8U, + KHR_DF_SAMPLESHIFT_SAMPLEPOSITION2 = 16U, + KHR_DF_SAMPLESHIFT_SAMPLEPOSITION3 = 24U, + KHR_DF_SAMPLESHIFT_SAMPLEPOSITION_ALL = 0U, + KHR_DF_SAMPLESHIFT_SAMPLELOWER = 0U, + KHR_DF_SAMPLESHIFT_SAMPLEUPPER = 0U +} khr_df_sampleshift_e; + +typedef enum _khr_df_samplemask_e { + KHR_DF_SAMPLEMASK_BITOFFSET = 0xFFFFU, + KHR_DF_SAMPLEMASK_BITLENGTH = 0xFF, + KHR_DF_SAMPLEMASK_CHANNELID = 0xF, + /* N.B. Qualifiers are defined as an offset into a byte */ + KHR_DF_SAMPLEMASK_QUALIFIERS = 0xF0, + KHR_DF_SAMPLEMASK_SAMPLEPOSITION0 = 0xFF, + KHR_DF_SAMPLEMASK_SAMPLEPOSITION1 = 0xFF, + KHR_DF_SAMPLEMASK_SAMPLEPOSITION2 = 0xFF, + KHR_DF_SAMPLEMASK_SAMPLEPOSITION3 = 0xFF, + /* ISO C restricts enum values to range of int hence the + cast. We do it verbosely instead of using -1 to ensure + it is a 32-bit value even if int is 64 bits. */ + KHR_DF_SAMPLEMASK_SAMPLEPOSITION_ALL = (int) 0xFFFFFFFFU, + KHR_DF_SAMPLEMASK_SAMPLELOWER = (int) 0xFFFFFFFFU, + KHR_DF_SAMPLEMASK_SAMPLEUPPER = (int) 0xFFFFFFFFU +} khr_df_samplemask_e; + +/* Helper macro: + Extract field X of sample S from basic descriptor block BDB */ +#define KHR_DFDSVAL(BDB, S, X) \ + (((BDB)[KHR_DF_WORD_SAMPLESTART + \ + ((S) * KHR_DF_WORD_SAMPLEWORDS) + \ + KHR_DF_SAMPLEWORD_ ## X] >> (KHR_DF_SAMPLESHIFT_ ## X)) \ + & (KHR_DF_SAMPLEMASK_ ## X)) + +/* Helper macro: + Set field X of sample S of basic descriptor block BDB */ +#define KHR_DFDSETSVAL(BDB, S, X, val) \ + ((BDB)[KHR_DF_WORD_SAMPLESTART + \ + ((S) * KHR_DF_WORD_SAMPLEWORDS) + \ + KHR_DF_SAMPLEWORD_ ## X] = \ + ((BDB)[KHR_DF_WORD_SAMPLESTART + \ + ((S) * KHR_DF_WORD_SAMPLEWORDS) + \ + KHR_DF_SAMPLEWORD_ ## X] & \ + ~((uint32_t)(KHR_DF_SAMPLEMASK_ ## X) << (KHR_DF_SAMPLESHIFT_ ## X))) | \ + (((val) & (uint32_t)(KHR_DF_SAMPLEMASK_ ## X)) << (KHR_DF_SAMPLESHIFT_ ## X))) + +/* Helper macro: + Number of samples in basic descriptor block BDB */ +#define KHR_DFDSAMPLECOUNT(BDB) \ + (((KHR_DFDVAL(BDB, DESCRIPTORBLOCKSIZE) >> 2) - \ + KHR_DF_WORD_SAMPLESTART) \ + / KHR_DF_WORD_SAMPLEWORDS) + +/* Helper macro: + Size in words of basic descriptor block for S samples */ +#define KHR_DFDSIZEWORDS(S) \ + (KHR_DF_WORD_SAMPLESTART + \ + (S) * KHR_DF_WORD_SAMPLEWORDS) + +/* Vendor ids */ +typedef enum _khr_df_vendorid_e { + /* Standard Khronos descriptor */ + KHR_DF_VENDORID_KHRONOS = 0U, + KHR_DF_VENDORID_MAX = 0x1FFFFU +} khr_df_vendorid_e; + +/* Descriptor types */ +typedef enum _khr_df_khr_descriptortype_e { + /* Default Khronos basic descriptor block */ + KHR_DF_KHR_DESCRIPTORTYPE_BASICFORMAT = 0U, + /* Extension descriptor block for additional planes */ + KHR_DF_KHR_DESCRIPTORTYPE_ADDITIONAL_PLANES = 0x6001U, + /* Extension descriptor block for additional dimensions */ + KHR_DF_KHR_DESCRIPTORTYPE_ADDITIONAL_DIMENSIONS = 0x6002U, + /* Bit indicates modifying requires understanding this extension */ + KHR_DF_KHR_DESCRIPTORTYPE_NEEDED_FOR_WRITE_BIT = 0x2000U, + /* Bit indicates processing requires understanding this extension */ + KHR_DF_KHR_DESCRIPTORTYPE_NEEDED_FOR_DECODE_BIT = 0x4000U, + KHR_DF_KHR_DESCRIPTORTYPE_MAX = 0x7FFFU +} khr_df_khr_descriptortype_e; + +/* Descriptor block version */ +typedef enum _khr_df_versionnumber_e { + /* Standard Khronos descriptor */ + KHR_DF_VERSIONNUMBER_1_0 = 0U, /* Version 1.0 of the specification */ + KHR_DF_VERSIONNUMBER_1_1 = 0U, /* Version 1.1 did not bump the version number */ + KHR_DF_VERSIONNUMBER_1_2 = 1U, /* Version 1.2 increased the version number */ + KHR_DF_VERSIONNUMBER_1_3 = 2U, /* Version 1.3 increased the version number */ + KHR_DF_VERSIONNUMBER_LATEST = KHR_DF_VERSIONNUMBER_1_3, + KHR_DF_VERSIONNUMBER_MAX = 0xFFFFU +} khr_df_versionnumber_e; + +/* Model in which the color coordinate space is defined. + There is no requirement that a color format use all the + channel types that are defined in the color model. */ +typedef enum _khr_df_model_e { + /* No interpretation of color channels defined */ + KHR_DF_MODEL_UNSPECIFIED = 0U, + /* Color primaries (red, green, blue) + alpha, depth and stencil */ + KHR_DF_MODEL_RGBSDA = 1U, + /* Color differences (Y', Cb, Cr) + alpha, depth and stencil */ + KHR_DF_MODEL_YUVSDA = 2U, + /* Color differences (Y', I, Q) + alpha, depth and stencil */ + KHR_DF_MODEL_YIQSDA = 3U, + /* Perceptual color (CIE L*a*b*) + alpha, depth and stencil */ + KHR_DF_MODEL_LABSDA = 4U, + /* Subtractive colors (cyan, magenta, yellow, black) + alpha */ + KHR_DF_MODEL_CMYKA = 5U, + /* Non-color coordinate data (X, Y, Z, W) */ + KHR_DF_MODEL_XYZW = 6U, + /* Hue, saturation, value, hue angle on color circle, plus alpha */ + KHR_DF_MODEL_HSVA_ANG = 7U, + /* Hue, saturation, lightness, hue angle on color circle, plus alpha */ + KHR_DF_MODEL_HSLA_ANG = 8U, + /* Hue, saturation, value, hue on color hexagon, plus alpha */ + KHR_DF_MODEL_HSVA_HEX = 9U, + /* Hue, saturation, lightness, hue on color hexagon, plus alpha */ + KHR_DF_MODEL_HSLA_HEX = 10U, + /* Lightweight approximate color difference (luma, orange, green) */ + KHR_DF_MODEL_YCGCOA = 11U, + /* ITU BT.2020 constant luminance YcCbcCrc */ + KHR_DF_MODEL_YCCBCCRC = 12U, + /* ITU BT.2100 constant intensity ICtCp */ + KHR_DF_MODEL_ICTCP = 13U, + /* CIE 1931 XYZ color coordinates (X, Y, Z) */ + KHR_DF_MODEL_CIEXYZ = 14U, + /* CIE 1931 xyY color coordinates (X, Y, Y) */ + KHR_DF_MODEL_CIEXYY = 15U, + + /* Compressed formats start at 128. */ + /* These compressed formats should generally have a single sample, + sited at the 0,0 position of the texel block. Where multiple + channels are used to distinguish formats, these should be cosited. */ + /* Direct3D (and S3) compressed formats */ + /* Note that premultiplied status is recorded separately */ + /* DXT1 "channels" are RGB (0), Alpha (1) */ + /* DXT1/BC1 with one channel is opaque */ + /* DXT1/BC1 with a cosited alpha sample is transparent */ + KHR_DF_MODEL_DXT1A = 128U, + KHR_DF_MODEL_BC1A = 128U, + /* DXT2/DXT3/BC2, with explicit 4-bit alpha */ + KHR_DF_MODEL_DXT2 = 129U, + KHR_DF_MODEL_DXT3 = 129U, + KHR_DF_MODEL_BC2 = 129U, + /* DXT4/DXT5/BC3, with interpolated alpha */ + KHR_DF_MODEL_DXT4 = 130U, + KHR_DF_MODEL_DXT5 = 130U, + KHR_DF_MODEL_BC3 = 130U, + /* BC4 - single channel interpolated 8-bit data */ + /* (The UNORM/SNORM variation is recorded in the channel data) */ + KHR_DF_MODEL_BC4 = 131U, + /* BC5 - two channel interpolated 8-bit data */ + /* (The UNORM/SNORM variation is recorded in the channel data) */ + KHR_DF_MODEL_BC5 = 132U, + /* BC6H - DX11 format for 16-bit float channels */ + KHR_DF_MODEL_BC6H = 133U, + /* BC7 - DX11 format */ + KHR_DF_MODEL_BC7 = 134U, + /* Gap left for future desktop expansion */ + + /* Mobile compressed formats follow */ + /* A format of ETC1 indicates that the format shall be decodable + by an ETC1-compliant decoder and not rely on ETC2 features */ + KHR_DF_MODEL_ETC1 = 160U, + /* A format of ETC2 is permitted to use ETC2 encodings on top of + the baseline ETC1 specification */ + /* The ETC2 format has channels "red", "green", "RGB" and "alpha", + which should be cosited samples */ + /* Punch-through alpha can be distinguished from full alpha by + the plane size in bytes required for the texel block */ + KHR_DF_MODEL_ETC2 = 161U, + /* Adaptive Scalable Texture Compression */ + /* ASTC HDR vs LDR is determined by the float flag in the channel */ + /* ASTC block size can be distinguished by texel block size */ + KHR_DF_MODEL_ASTC = 162U, + /* ETC1S is a simplified subset of ETC1 */ + KHR_DF_MODEL_ETC1S = 163U, + /* PowerVR Texture Compression */ + KHR_DF_MODEL_PVRTC = 164U, + KHR_DF_MODEL_PVRTC2 = 165U, + /* Proprietary formats (ATITC, etc.) should follow */ + KHR_DF_MODEL_MAX = 0xFFU +} khr_df_model_e; + +/* Definition of channel names for each color model */ +typedef enum _khr_df_model_channels_e { + /* Unspecified format with nominal channel numbering */ + KHR_DF_CHANNEL_UNSPECIFIED_0 = 0U, + KHR_DF_CHANNEL_UNSPECIFIED_1 = 1U, + KHR_DF_CHANNEL_UNSPECIFIED_2 = 2U, + KHR_DF_CHANNEL_UNSPECIFIED_3 = 3U, + KHR_DF_CHANNEL_UNSPECIFIED_4 = 4U, + KHR_DF_CHANNEL_UNSPECIFIED_5 = 5U, + KHR_DF_CHANNEL_UNSPECIFIED_6 = 6U, + KHR_DF_CHANNEL_UNSPECIFIED_7 = 7U, + KHR_DF_CHANNEL_UNSPECIFIED_8 = 8U, + KHR_DF_CHANNEL_UNSPECIFIED_9 = 9U, + KHR_DF_CHANNEL_UNSPECIFIED_10 = 10U, + KHR_DF_CHANNEL_UNSPECIFIED_11 = 11U, + KHR_DF_CHANNEL_UNSPECIFIED_12 = 12U, + KHR_DF_CHANNEL_UNSPECIFIED_13 = 13U, + KHR_DF_CHANNEL_UNSPECIFIED_14 = 14U, + KHR_DF_CHANNEL_UNSPECIFIED_15 = 15U, + /* MODEL_RGBSDA - red, green, blue, stencil, depth, alpha */ + KHR_DF_CHANNEL_RGBSDA_RED = 0U, + KHR_DF_CHANNEL_RGBSDA_R = 0U, + KHR_DF_CHANNEL_RGBSDA_GREEN = 1U, + KHR_DF_CHANNEL_RGBSDA_G = 1U, + KHR_DF_CHANNEL_RGBSDA_BLUE = 2U, + KHR_DF_CHANNEL_RGBSDA_B = 2U, + KHR_DF_CHANNEL_RGBSDA_STENCIL = 13U, + KHR_DF_CHANNEL_RGBSDA_S = 13U, + KHR_DF_CHANNEL_RGBSDA_DEPTH = 14U, + KHR_DF_CHANNEL_RGBSDA_D = 14U, + KHR_DF_CHANNEL_RGBSDA_ALPHA = 15U, + KHR_DF_CHANNEL_RGBSDA_A = 15U, + /* MODEL_YUVSDA - luma, Cb, Cr, stencil, depth, alpha */ + KHR_DF_CHANNEL_YUVSDA_Y = 0U, + KHR_DF_CHANNEL_YUVSDA_CB = 1U, + KHR_DF_CHANNEL_YUVSDA_U = 1U, + KHR_DF_CHANNEL_YUVSDA_CR = 2U, + KHR_DF_CHANNEL_YUVSDA_V = 2U, + KHR_DF_CHANNEL_YUVSDA_STENCIL = 13U, + KHR_DF_CHANNEL_YUVSDA_S = 13U, + KHR_DF_CHANNEL_YUVSDA_DEPTH = 14U, + KHR_DF_CHANNEL_YUVSDA_D = 14U, + KHR_DF_CHANNEL_YUVSDA_ALPHA = 15U, + KHR_DF_CHANNEL_YUVSDA_A = 15U, + /* MODEL_YIQSDA - luma, in-phase, quadrature, stencil, depth, alpha */ + KHR_DF_CHANNEL_YIQSDA_Y = 0U, + KHR_DF_CHANNEL_YIQSDA_I = 1U, + KHR_DF_CHANNEL_YIQSDA_Q = 2U, + KHR_DF_CHANNEL_YIQSDA_STENCIL = 13U, + KHR_DF_CHANNEL_YIQSDA_S = 13U, + KHR_DF_CHANNEL_YIQSDA_DEPTH = 14U, + KHR_DF_CHANNEL_YIQSDA_D = 14U, + KHR_DF_CHANNEL_YIQSDA_ALPHA = 15U, + KHR_DF_CHANNEL_YIQSDA_A = 15U, + /* MODEL_LABSDA - CIELAB/L*a*b* luma, red-green, blue-yellow, stencil, depth, alpha */ + KHR_DF_CHANNEL_LABSDA_L = 0U, + KHR_DF_CHANNEL_LABSDA_A = 1U, + KHR_DF_CHANNEL_LABSDA_B = 2U, + KHR_DF_CHANNEL_LABSDA_STENCIL = 13U, + KHR_DF_CHANNEL_LABSDA_S = 13U, + KHR_DF_CHANNEL_LABSDA_DEPTH = 14U, + KHR_DF_CHANNEL_LABSDA_D = 14U, + KHR_DF_CHANNEL_LABSDA_ALPHA = 15U, + /* NOTE: KHR_DF_CHANNEL_LABSDA_A is not a synonym for alpha! */ + /* MODEL_CMYKA - cyan, magenta, yellow, key/blacK, alpha */ + KHR_DF_CHANNEL_CMYKSDA_CYAN = 0U, + KHR_DF_CHANNEL_CMYKSDA_C = 0U, + KHR_DF_CHANNEL_CMYKSDA_MAGENTA = 1U, + KHR_DF_CHANNEL_CMYKSDA_M = 1U, + KHR_DF_CHANNEL_CMYKSDA_YELLOW = 2U, + KHR_DF_CHANNEL_CMYKSDA_Y = 2U, + KHR_DF_CHANNEL_CMYKSDA_KEY = 3U, + KHR_DF_CHANNEL_CMYKSDA_BLACK = 3U, + KHR_DF_CHANNEL_CMYKSDA_K = 3U, + KHR_DF_CHANNEL_CMYKSDA_ALPHA = 15U, + KHR_DF_CHANNEL_CMYKSDA_A = 15U, + /* MODEL_XYZW - coordinates x, y, z, w */ + KHR_DF_CHANNEL_XYZW_X = 0U, + KHR_DF_CHANNEL_XYZW_Y = 1U, + KHR_DF_CHANNEL_XYZW_Z = 2U, + KHR_DF_CHANNEL_XYZW_W = 3U, + /* MODEL_HSVA_ANG - value (luma), saturation, hue, alpha, angular projection, conical space */ + KHR_DF_CHANNEL_HSVA_ANG_VALUE = 0U, + KHR_DF_CHANNEL_HSVA_ANG_V = 0U, + KHR_DF_CHANNEL_HSVA_ANG_SATURATION = 1U, + KHR_DF_CHANNEL_HSVA_ANG_S = 1U, + KHR_DF_CHANNEL_HSVA_ANG_HUE = 2U, + KHR_DF_CHANNEL_HSVA_ANG_H = 2U, + KHR_DF_CHANNEL_HSVA_ANG_ALPHA = 15U, + KHR_DF_CHANNEL_HSVA_ANG_A = 15U, + /* MODEL_HSLA_ANG - lightness (luma), saturation, hue, alpha, angular projection, double conical space */ + KHR_DF_CHANNEL_HSLA_ANG_LIGHTNESS = 0U, + KHR_DF_CHANNEL_HSLA_ANG_L = 0U, + KHR_DF_CHANNEL_HSLA_ANG_SATURATION = 1U, + KHR_DF_CHANNEL_HSLA_ANG_S = 1U, + KHR_DF_CHANNEL_HSLA_ANG_HUE = 2U, + KHR_DF_CHANNEL_HSLA_ANG_H = 2U, + KHR_DF_CHANNEL_HSLA_ANG_ALPHA = 15U, + KHR_DF_CHANNEL_HSLA_ANG_A = 15U, + /* MODEL_HSVA_HEX - value (luma), saturation, hue, alpha, hexagonal projection, conical space */ + KHR_DF_CHANNEL_HSVA_HEX_VALUE = 0U, + KHR_DF_CHANNEL_HSVA_HEX_V = 0U, + KHR_DF_CHANNEL_HSVA_HEX_SATURATION = 1U, + KHR_DF_CHANNEL_HSVA_HEX_S = 1U, + KHR_DF_CHANNEL_HSVA_HEX_HUE = 2U, + KHR_DF_CHANNEL_HSVA_HEX_H = 2U, + KHR_DF_CHANNEL_HSVA_HEX_ALPHA = 15U, + KHR_DF_CHANNEL_HSVA_HEX_A = 15U, + /* MODEL_HSLA_HEX - lightness (luma), saturation, hue, alpha, hexagonal projection, double conical space */ + KHR_DF_CHANNEL_HSLA_HEX_LIGHTNESS = 0U, + KHR_DF_CHANNEL_HSLA_HEX_L = 0U, + KHR_DF_CHANNEL_HSLA_HEX_SATURATION = 1U, + KHR_DF_CHANNEL_HSLA_HEX_S = 1U, + KHR_DF_CHANNEL_HSLA_HEX_HUE = 2U, + KHR_DF_CHANNEL_HSLA_HEX_H = 2U, + KHR_DF_CHANNEL_HSLA_HEX_ALPHA = 15U, + KHR_DF_CHANNEL_HSLA_HEX_A = 15U, + /* MODEL_YCGCOA - luma, green delta, orange delta, alpha */ + KHR_DF_CHANNEL_YCGCOA_Y = 0U, + KHR_DF_CHANNEL_YCGCOA_CG = 1U, + KHR_DF_CHANNEL_YCGCOA_CO = 2U, + KHR_DF_CHANNEL_YCGCOA_ALPHA = 15U, + KHR_DF_CHANNEL_YCGCOA_A = 15U, + /* MODEL_CIEXYZ - CIE 1931 X, Y, Z */ + KHR_DF_CHANNEL_CIEXYZ_X = 0U, + KHR_DF_CHANNEL_CIEXYZ_Y = 1U, + KHR_DF_CHANNEL_CIEXYZ_Z = 2U, + /* MODEL_CIEXYY - CIE 1931 x, y, Y */ + KHR_DF_CHANNEL_CIEXYY_X = 0U, + KHR_DF_CHANNEL_CIEXYY_YCHROMA = 1U, + KHR_DF_CHANNEL_CIEXYY_YLUMA = 2U, + + /* Compressed formats */ + /* MODEL_DXT1A/MODEL_BC1A */ + KHR_DF_CHANNEL_DXT1A_COLOR = 0U, + KHR_DF_CHANNEL_BC1A_COLOR = 0U, + KHR_DF_CHANNEL_DXT1A_ALPHAPRESENT = 1U, + KHR_DF_CHANNEL_DXT1A_ALPHA = 1U, + KHR_DF_CHANNEL_BC1A_ALPHAPRESENT = 1U, + KHR_DF_CHANNEL_BC1A_ALPHA = 1U, + /* MODEL_DXT2/3/MODEL_BC2 */ + KHR_DF_CHANNEL_DXT2_COLOR = 0U, + KHR_DF_CHANNEL_DXT3_COLOR = 0U, + KHR_DF_CHANNEL_BC2_COLOR = 0U, + KHR_DF_CHANNEL_DXT2_ALPHA = 15U, + KHR_DF_CHANNEL_DXT3_ALPHA = 15U, + KHR_DF_CHANNEL_BC2_ALPHA = 15U, + /* MODEL_DXT4/5/MODEL_BC3 */ + KHR_DF_CHANNEL_DXT4_COLOR = 0U, + KHR_DF_CHANNEL_DXT5_COLOR = 0U, + KHR_DF_CHANNEL_BC3_COLOR = 0U, + KHR_DF_CHANNEL_DXT4_ALPHA = 15U, + KHR_DF_CHANNEL_DXT5_ALPHA = 15U, + KHR_DF_CHANNEL_BC3_ALPHA = 15U, + /* MODEL_BC4 */ + KHR_DF_CHANNEL_BC4_DATA = 0U, + /* MODEL_BC5 */ + KHR_DF_CHANNEL_BC5_RED = 0U, + KHR_DF_CHANNEL_BC5_R = 0U, + KHR_DF_CHANNEL_BC5_GREEN = 1U, + KHR_DF_CHANNEL_BC5_G = 1U, + /* MODEL_BC6H */ + KHR_DF_CHANNEL_BC6H_COLOR = 0U, + KHR_DF_CHANNEL_BC6H_DATA = 0U, + /* MODEL_BC7 */ + KHR_DF_CHANNEL_BC7_DATA = 0U, + KHR_DF_CHANNEL_BC7_COLOR = 0U, + /* MODEL_ETC1 */ + KHR_DF_CHANNEL_ETC1_DATA = 0U, + KHR_DF_CHANNEL_ETC1_COLOR = 0U, + /* MODEL_ETC2 */ + KHR_DF_CHANNEL_ETC2_RED = 0U, + KHR_DF_CHANNEL_ETC2_R = 0U, + KHR_DF_CHANNEL_ETC2_GREEN = 1U, + KHR_DF_CHANNEL_ETC2_G = 1U, + KHR_DF_CHANNEL_ETC2_COLOR = 2U, + KHR_DF_CHANNEL_ETC2_ALPHA = 15U, + KHR_DF_CHANNEL_ETC2_A = 15U, + /* MODEL_ASTC */ + KHR_DF_CHANNEL_ASTC_DATA = 0U, + /* MODEL_ETC1S */ + KHR_DF_CHANNEL_ETC1S_DATA = 0U, + KHR_DF_CHANNEL_ETC1S_COLOR = 0U, + /* MODEL_PVRTC */ + KHR_DF_CHANNEL_PVRTC_DATA = 0U, + KHR_DF_CHANNEL_PVRTC_COLOR = 0U, + /* MODEL_PVRTC2 */ + KHR_DF_CHANNEL_PVRTC2_DATA = 0U, + KHR_DF_CHANNEL_PVRTC2_COLOR = 0U, + + /* Common channel names shared by multiple formats */ + KHR_DF_CHANNEL_COMMON_LUMA = 0U, + KHR_DF_CHANNEL_COMMON_L = 0U, + KHR_DF_CHANNEL_COMMON_STENCIL = 13U, + KHR_DF_CHANNEL_COMMON_S = 13U, + KHR_DF_CHANNEL_COMMON_DEPTH = 14U, + KHR_DF_CHANNEL_COMMON_D = 14U, + KHR_DF_CHANNEL_COMMON_ALPHA = 15U, + KHR_DF_CHANNEL_COMMON_A = 15U +} khr_df_model_channels_e; + +/* Definition of the primary colors in color coordinates. + This is implicitly responsible for defining the conversion + between RGB an YUV color spaces. + LAB and related absolute color models should use + KHR_DF_PRIMARIES_CIEXYZ. */ +typedef enum _khr_df_primaries_e { + /* No color primaries defined */ + KHR_DF_PRIMARIES_UNSPECIFIED = 0U, + /* Color primaries of ITU-R BT.709 and sRGB */ + KHR_DF_PRIMARIES_BT709 = 1U, + /* Synonym for KHR_DF_PRIMARIES_BT709 */ + KHR_DF_PRIMARIES_SRGB = 1U, + /* Color primaries of ITU-R BT.601 (625-line EBU variant) */ + KHR_DF_PRIMARIES_BT601_EBU = 2U, + /* Color primaries of ITU-R BT.601 (525-line SMPTE C variant) */ + KHR_DF_PRIMARIES_BT601_SMPTE = 3U, + /* Color primaries of ITU-R BT.2020 */ + KHR_DF_PRIMARIES_BT2020 = 4U, + /* CIE theoretical color coordinate space */ + KHR_DF_PRIMARIES_CIEXYZ = 5U, + /* Academy Color Encoding System primaries */ + KHR_DF_PRIMARIES_ACES = 6U, + /* Color primaries of ACEScc */ + KHR_DF_PRIMARIES_ACESCC = 7U, + /* Legacy NTSC 1953 primaries */ + KHR_DF_PRIMARIES_NTSC1953 = 8U, + /* Legacy PAL 525-line primaries */ + KHR_DF_PRIMARIES_PAL525 = 9U, + /* Color primaries of Display P3 */ + KHR_DF_PRIMARIES_DISPLAYP3 = 10U, + /* Color primaries of Adobe RGB (1998) */ + KHR_DF_PRIMARIES_ADOBERGB = 11U, + KHR_DF_PRIMARIES_MAX = 0xFFU +} khr_df_primaries_e; + +/* Definition of the optical to digital transfer function + ("gamma correction"). Most transfer functions are not a pure + power function and also include a linear element. + LAB and related absolute color representations should use + KHR_DF_TRANSFER_UNSPECIFIED. */ +typedef enum _khr_df_transfer_e { + /* No transfer function defined */ + KHR_DF_TRANSFER_UNSPECIFIED = 0U, + /* Linear transfer function (value proportional to intensity) */ + KHR_DF_TRANSFER_LINEAR = 1U, + /* Perceptually-linear transfer function of sRGH (~2.4) */ + KHR_DF_TRANSFER_SRGB = 2U, + /* Perceptually-linear transfer function of ITU non-HDR specifications (~1/.45) */ + KHR_DF_TRANSFER_ITU = 3U, + /* SMTPE170M (digital NTSC) defines an alias for the ITU transfer function (~1/.45) */ + KHR_DF_TRANSFER_SMTPE170M = 3U, + /* Perceptually-linear gamma function of original NTSC (simple 2.2 gamma) */ + KHR_DF_TRANSFER_NTSC = 4U, + /* Sony S-log used by Sony video cameras */ + KHR_DF_TRANSFER_SLOG = 5U, + /* Sony S-log 2 used by Sony video cameras */ + KHR_DF_TRANSFER_SLOG2 = 6U, + /* ITU BT.1886 EOTF */ + KHR_DF_TRANSFER_BT1886 = 7U, + /* ITU BT.2100 HLG OETF */ + KHR_DF_TRANSFER_HLG_OETF = 8U, + /* ITU BT.2100 HLG EOTF */ + KHR_DF_TRANSFER_HLG_EOTF = 9U, + /* ITU BT.2100 PQ EOTF */ + KHR_DF_TRANSFER_PQ_EOTF = 10U, + /* ITU BT.2100 PQ OETF */ + KHR_DF_TRANSFER_PQ_OETF = 11U, + /* DCI P3 transfer function */ + KHR_DF_TRANSFER_DCIP3 = 12U, + /* Legacy PAL OETF */ + KHR_DF_TRANSFER_PAL_OETF = 13U, + /* Legacy PAL 625-line EOTF */ + KHR_DF_TRANSFER_PAL625_EOTF = 14U, + /* Legacy ST240 transfer function */ + KHR_DF_TRANSFER_ST240 = 15U, + /* ACEScc transfer function */ + KHR_DF_TRANSFER_ACESCC = 16U, + /* ACEScct transfer function */ + KHR_DF_TRANSFER_ACESCCT = 17U, + /* Adobe RGB (1998) transfer function */ + KHR_DF_TRANSFER_ADOBERGB = 18U, + KHR_DF_TRANSFER_MAX = 0xFFU +} khr_df_transfer_e; + +typedef enum _khr_df_flags_e { + KHR_DF_FLAG_ALPHA_STRAIGHT = 0U, + KHR_DF_FLAG_ALPHA_PREMULTIPLIED = 1U +} khr_df_flags_e; + +typedef enum _khr_df_sample_datatype_qualifiers_e { + KHR_DF_SAMPLE_DATATYPE_LINEAR = 1U << 4U, + KHR_DF_SAMPLE_DATATYPE_EXPONENT = 1U << 5U, + KHR_DF_SAMPLE_DATATYPE_SIGNED = 1U << 6U, + KHR_DF_SAMPLE_DATATYPE_FLOAT = 1U << 7U +} khr_df_sample_datatype_qualifiers_e; + +#endif diff --git a/nvpro_core_legacy/fileformats/nv_dds.cpp b/nvpro_core_legacy/fileformats/nv_dds.cpp new file mode 100644 index 0000000..34de890 --- /dev/null +++ b/nvpro_core_legacy/fileformats/nv_dds.cpp @@ -0,0 +1,2309 @@ +/* + * Copyright (c) 2016-2025, NVIDIA CORPORATION. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-FileCopyrightText: Copyright (c) 2016-2025 NVIDIA CORPORATION + * SPDX-License-Identifier: Apache-2.0 + */ + +#define NV_DDS_UTILITY_VALUES +#include "nv_dds.h" + +#include "dxgiformat.h" // Included in third_party's dxh subproject +#include "texture_formats.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef _MSC_VER +#include // For BitScanReverse +#endif + +namespace nv_dds { + +/////////////////////////////////////////////////////////////////////////////// +// Private types and functions +/////////////////////////////////////////////////////////////////////////////// + +namespace { +// Resizing a vector can produce an exception if the allocation fails, but +// there's no real way to validate this ahead of time. So we use +// a try/catch block. +template +ErrorWithText resizeVectorOrError(std::vector& vec, size_t newSize) noexcept +{ + try + { + vec.resize(newSize, T{}); + } + catch(...) + { + return "Allocating " + std::to_string(newSize) + " bytes of data failed."; + } + return {}; +} + +// Returns the index of the highest set bit of a mask, or 0 if mask == 0. +uint32_t highestSetBit(uint32_t mask) +{ + if(mask == 0) + return 0; +#ifdef _MSC_VER + unsigned long bit = 0; + _BitScanReverse(&bit, mask); + return bit; +#else + return static_cast(31 - __builtin_clz(mask)); +#endif +} + +// Returns the index of the lowest set bit of a mask, or 0 if mask == 0. +uint32_t lowestSetBit(uint32_t mask) +{ + if(mask == 0) + return 0; +#ifdef _MSC_VER + unsigned long bit = 0; + _BitScanForward(&bit, mask); + return bit; +#else + return static_cast(__builtin_ctz(mask)); +#endif +} + +// Returns the bit width (number of bits between and including the highest and +// lowest set bit) of a mask. +// Examples: 00000000 00000011 10000000 00000000 -> 3 +// 00000000 10000000 00000001 00000000 -> 16 +uint32_t maskBitWidth(uint32_t mask) +{ + if(mask == 0) + return 0; + return highestSetBit(mask) - lowestSetBit(mask) + 1; +} + +uint32_t popcnt(uint32_t mask) +{ +#ifdef _MSC_VER + return static_cast(__popcnt(mask)); +#else + return static_cast(__builtin_popcount(mask)); +#endif +} + +struct BitmaskMultiplier +{ + uint32_t mask = 0; + float multiplier = 0.0F; + uint32_t leftshift = 0; +}; + +// This function returns the constants needed to convert a bit representation +// to a UNORM or SNORM value. +// The DDS file format doesn't specify how many bits each channel takes, +// so we estimate it from the channel mask. We assume all bits in the mask +// are contiguous: i.e. channel masks like 00011100 are OK, but channel +// masks like 01000110 are not OK. (In other words, it's possible to get +// the channel value for UNORM using a single mask and multiply). +BitmaskMultiplier getMultiplierFromChannelMask(uint32_t mask, bool snorm) +{ + BitmaskMultiplier multiplier; + if(mask == 0) + { + return multiplier; + } + + // These values are the ones that make bitsToUnorm and bitsToSnorm come out correctly: + multiplier.mask = mask; + if(snorm) + { + const uint32_t hibit = highestSetBit(mask); + // Shift so that hibit is in position 31: + multiplier.leftshift = 31 - hibit; + // Once you've done that, the multiplier should make the largest positive + // value go to 1. + const uint32_t largestPositiveValue = (mask << multiplier.leftshift) & 0x7FFFFFFF; + if(largestPositiveValue == 0) + { + // This means that `mask` consisted of only 1 bit. 1-bit SNORM is + // impossible; https://learn.microsoft.com/en-us/windows/win32/direct3d10/d3d10-graphics-programming-guide-resources-data-conversion + // requires that there's two representations for -1.0f, + // one representation for 0.0f, and one representation for 1.0f. + // Since this case is undefined (though the fuzzer finds a way to + // reach it), we return a multiplier of 0. + return multiplier; + } + multiplier.multiplier = 1.0F / static_cast(largestPositiveValue); + // This means that 0x7FFF... will go to 1, 0x80...1 will go to -1, and + // 0x80...0 will go to a value slightly less than -1, which matches the + // spec for SNORM. + return multiplier; + } + else + { + // UNORM: + multiplier.multiplier = 1.0F / static_cast(mask); + return multiplier; + } +} + +float bitsToUnorm(uint32_t value, const BitmaskMultiplier& mult) +{ + return static_cast(value & mult.mask) * mult.multiplier; +} + +float bitsToSnorm(uint32_t value, const BitmaskMultiplier& mult) +{ + // Shift the value so that its leftmost bit is at bit 31: + uint32_t shifted = (value & mult.mask) << mult.leftshift; + // Strictly speaking, static_cast(shifted) is implementation-defined. + // So until we have bit_cast, use a memcpy and hope the compiler + // determines that this is a reinterpretation of the underlying data (i.e. free): + int32_t asint{}; + memcpy(&asint, &shifted, sizeof(uint32_t)); + const float v = static_cast(asint) * mult.multiplier; + return std::max(-1.0F, v); +} + +// Macro for "read this variable from the istream; if it fails, return an error message" +#define READ_OR_ERROR(input, variable, error_message) \ + if(!(input).read(reinterpret_cast(&(variable)), sizeof(variable))) \ + { \ + return (error_message); \ + } + +// Macro for "write this variable to the ostream; if it fails, return an error message" +#define WRITE_OR_ERROR(output, variable, error_message) \ + if(!(output).write(reinterpret_cast(&(variable)), sizeof(variable))) \ + { \ + return (error_message); \ + } + +// Macro for "If this returned an error, propagate that error" +#define UNWRAP_ERROR(expr_returning_error_with_text) \ + if(ErrorWithText unwrap_error_tmp = (expr_returning_error_with_text)) \ + { \ + return unwrap_error_tmp; \ + } + +bool arrayIsAllPrintableChars(const char* arr, const size_t arrayLength) +{ + for(int i = 0; i < arrayLength; i++) + { + if(arr[i] < '!' || arr[i] > '~') + { + return false; + } + } + return true; +} + +// Returns a human-readable version of a Four-character code that can be +// printed to a terminal. +// In general, concatenating all four char values as-is is can produce issues: +// the FourCC code could contain a null character, which would cause issues +// mixing an std::string with C string functions. (For instance, +// FOURCC_BC70 does this). Or it could contain an ANSI terminal escape code. +std::string makeFourCCPrintable(const std::array& fourCC) +{ + if(arrayIsAllPrintableChars(fourCC.data(), fourCC.size())) + { + return std::string(fourCC.data(), fourCC.size()); + } + + std::string s = "("; + for(int b = 0; b < 4; b++) + { + s += std::to_string(static_cast(fourCC[b])); + if(b != 3) + { + s += ", "; + } + } + s += ")"; + return s; +} + +std::string makeFourCCPrintable(uint32_t fourCC) +{ + std::array fourCCBytes{}; + for(int b = 0; b < 4; b++) + { + fourCCBytes[b] = static_cast(fourCC >> (8 * b)); + } + return makeFourCCPrintable(fourCCBytes); +} + +// Suports an std::istream interface that operates on an in-memory array. +class MemoryStreamBuffer : public std::basic_streambuf +{ + char* m_data = nullptr; + std::streamoff m_nextIndex = 0; // Always in [0, m_sizeInBytes]. + std::streamsize m_sizeInBytes = 0; + +public: + MemoryStreamBuffer(char* data, std::streamsize sizeInBytes) + : m_data(data) + , m_sizeInBytes(sizeInBytes) + { + } + pos_type seekoff(off_type off, std::ios_base::seekdir dir, std::ios_base::openmode which = std::ios_base::in | std::ios_base::out) override + { + const pos_type indicatesError = pos_type(static_cast(-1)); + switch(dir) + { + case std::ios_base::beg: + if(off < 0 || off > m_sizeInBytes) + return indicatesError; + m_nextIndex = off; + break; + case std::ios_base::cur: + if(((off < 0) && m_nextIndex + off < 0) || (off >= 0 && off > m_sizeInBytes - m_nextIndex)) + return indicatesError; + m_nextIndex += off; + break; + case std::ios_base::end: + if(off > 0 || off < -m_sizeInBytes) + return indicatesError; + m_nextIndex = m_sizeInBytes + off; + break; + default: + return indicatesError; + } + return m_nextIndex; + } + pos_type seekpos(pos_type pos, std::ios_base::openmode which = std::ios_base::in | std::ios_base::out) override + { + return seekoff(static_cast(pos), std::ios_base::beg, which); + } + // Gets the number of characters certainly available. + std::streamsize showmanyc() override { return m_sizeInBytes - m_nextIndex; } + // Gets the next character advancing the read pointer; EOF on error. + int_type uflow() override + { + if(m_nextIndex < m_sizeInBytes) + { + return traits_type::to_int_type(m_data[m_nextIndex++]); + } + return traits_type::eof(); + } + // Gets the next character without advancing the read pointer; EOF on error. + int_type underflow() override + { + if(m_nextIndex < m_sizeInBytes) + { + return traits_type::to_int_type(m_data[m_nextIndex]); + } + return traits_type::eof(); + } + // Reads a given number of characters and stores them into s' character array. + // Returns the number of characters successfully read. + std::streamsize xsgetn(char_type* s, std::streamsize count) override + { + if(count < 0 || s == nullptr || m_nextIndex >= m_sizeInBytes) + { + return 0; + } + const std::streamsize readableChars = std::min(count, m_sizeInBytes - m_nextIndex); + memcpy(s, m_data + m_nextIndex, readableChars); + m_nextIndex += readableChars; + return readableChars; + } +}; + +// An std::istream interface for a constant, in-memory array. +class MemoryStream : public std::istream +{ +public: + MemoryStream(const char* data, std::streamsize sizeInBytes) + : m_buffer(const_cast(data), sizeInBytes) + , std::istream(&m_buffer) + { + rdbuf(&m_buffer); + } + +private: + MemoryStreamBuffer m_buffer; +}; + +// Computes the size of a subresource of size `width` x `height` x `depth`, encoded +// using ASTC blocks of size `blockWidth` x `blockHeight` x `blockDepth`. Returns false +// if the calculation would overflow, and returns true and stores the result in +// `out` otherwise. +bool astcSize(size_t blockWidth, size_t blockHeight, size_t blockDepth, size_t width, size_t height, size_t depth, size_t& out) +{ + return checked_math::mul4(((width + blockWidth - 1) / blockWidth), // # of ASTC blocks along the x axis + ((height + blockHeight - 1) / blockHeight), // # of ASTC blocks along the y axis + ((depth + blockDepth - 1) / blockDepth), // # of ASTC blocks along the z axis + 16, // Each ASTC block size is 128 bits = 16 bytes + out); +} + +// Computes the size on disk of a width x height x depth texture with the given +// format. +bool dxgiExportSize(size_t width, size_t height, size_t depth, uint32_t format, size_t& outSize) +{ + // You might be asking: Why not use the texture_format conversion functions + // and merge this with nv_ktx.h's vulkanExportSize? + // The reason is that nv_dds can't rely on Vulkan being present, since it's + // always compiled into nvpro_core, so we can't use dxgiToVulkan. At the + // same time, Vulkan formats are close enough to a superset of DXGI formats, + // but not vice versa - in particular, Vulkan includes VK_FORMAT_R8G8B8_*. + using namespace texture_formats; + switch(format) + { + case DXGI_FORMAT_R1_UNORM: + // 1 bit per pixel, rounded up to a byte + if(!checked_math::mul3(width, height, depth, outSize)) + return false; + outSize = (outSize + 7) / 8; + return true; + case DXGI_FORMAT_R8_TYPELESS: + case DXGI_FORMAT_R8_UNORM: + case DXGI_FORMAT_R8_UINT: + case DXGI_FORMAT_R8_SNORM: + case DXGI_FORMAT_R8_SINT: + case DXGI_FORMAT_A8_UNORM: + return checked_math::mul4(width, height, depth, 8 / 8, outSize); // 8 bits per pixel + case DXGI_FORMAT_R8G8_TYPELESS: + case DXGI_FORMAT_R8G8_UNORM: + case DXGI_FORMAT_R8G8_UINT: + case DXGI_FORMAT_R8G8_SNORM: + case DXGI_FORMAT_R8G8_SINT: + case DXGI_FORMAT_R16_TYPELESS: + case DXGI_FORMAT_R16_FLOAT: + case DXGI_FORMAT_D16_UNORM: + case DXGI_FORMAT_R16_UNORM: + case DXGI_FORMAT_R16_UINT: + case DXGI_FORMAT_R16_SNORM: + case DXGI_FORMAT_R16_SINT: + case DXGI_FORMAT_B5G6R5_UNORM: + case DXGI_FORMAT_B5G5R5A1_UNORM: + case DXGI_FORMAT_B4G4R4A4_UNORM: + return checked_math::mul4(width, height, depth, 16 / 8, outSize); // 16 bits per pixel + case DXGI_FORMAT_R10G10B10A2_TYPELESS: + case DXGI_FORMAT_R10G10B10A2_UNORM: + case DXGI_FORMAT_R10G10B10A2_UINT: + case DXGI_FORMAT_R11G11B10_FLOAT: + case DXGI_FORMAT_R8G8B8A8_TYPELESS: + case DXGI_FORMAT_R8G8B8A8_UNORM: + case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB: + case DXGI_FORMAT_R8G8B8A8_UINT: + case DXGI_FORMAT_R8G8B8A8_SNORM: + case DXGI_FORMAT_R8G8B8A8_SINT: + case DXGI_FORMAT_R16G16_TYPELESS: + case DXGI_FORMAT_R16G16_FLOAT: + case DXGI_FORMAT_R16G16_UNORM: + case DXGI_FORMAT_R16G16_UINT: + case DXGI_FORMAT_R16G16_SNORM: + case DXGI_FORMAT_R16G16_SINT: + case DXGI_FORMAT_R32_TYPELESS: + case DXGI_FORMAT_D32_FLOAT: + case DXGI_FORMAT_R32_FLOAT: + case DXGI_FORMAT_R32_UINT: + case DXGI_FORMAT_R32_SINT: + case DXGI_FORMAT_R24G8_TYPELESS: + case DXGI_FORMAT_D24_UNORM_S8_UINT: + case DXGI_FORMAT_R24_UNORM_X8_TYPELESS: + case DXGI_FORMAT_X24_TYPELESS_G8_UINT: + case DXGI_FORMAT_R9G9B9E5_SHAREDEXP: + case DXGI_FORMAT_B8G8R8A8_UNORM: + case DXGI_FORMAT_B8G8R8X8_UNORM: + case DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM: + case DXGI_FORMAT_B8G8R8A8_TYPELESS: + case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB: + case DXGI_FORMAT_B8G8R8X8_TYPELESS: + case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB: + return checked_math::mul4(width, height, depth, 32 / 8, outSize); // 32 bits per pixel + case DXGI_FORMAT_R16G16B16A16_TYPELESS: + case DXGI_FORMAT_R16G16B16A16_FLOAT: + case DXGI_FORMAT_R16G16B16A16_UNORM: + case DXGI_FORMAT_R16G16B16A16_UINT: + case DXGI_FORMAT_R16G16B16A16_SNORM: + case DXGI_FORMAT_R16G16B16A16_SINT: + case DXGI_FORMAT_R32G32_TYPELESS: + case DXGI_FORMAT_R32G32_FLOAT: + case DXGI_FORMAT_R32G32_UINT: + case DXGI_FORMAT_R32G32_SINT: + case DXGI_FORMAT_R32G8X24_TYPELESS: + case DXGI_FORMAT_D32_FLOAT_S8X24_UINT: + case DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS: + case DXGI_FORMAT_X32_TYPELESS_G8X24_UINT: + return checked_math::mul4(width, height, depth, 64 / 8, outSize); // 64 bits per pixel + case DXGI_FORMAT_R32G32B32_TYPELESS: + case DXGI_FORMAT_R32G32B32_FLOAT: + case DXGI_FORMAT_R32G32B32_UINT: + case DXGI_FORMAT_R32G32B32_SINT: + return checked_math::mul4(width, height, depth, 96 / 8, outSize); // 96 bits per pixel + case DXGI_FORMAT_R32G32B32A32_TYPELESS: + case DXGI_FORMAT_R32G32B32A32_FLOAT: + case DXGI_FORMAT_R32G32B32A32_UINT: + case DXGI_FORMAT_R32G32B32A32_SINT: + return checked_math::mul4(width, height, depth, 128 / 8, outSize); // 128 bits per pixel + case DXGI_FORMAT_BC1_TYPELESS: + case DXGI_FORMAT_BC1_UNORM: + case DXGI_FORMAT_BC1_UNORM_SRGB: + case DXGI_FORMAT_BC4_TYPELESS: + case DXGI_FORMAT_BC4_UNORM: + case DXGI_FORMAT_BC4_SNORM: + return checked_math::mul4((width + 3) / 4, (height + 3) / 4, depth, 8, outSize); // 8 bytes per block + case DXGI_FORMAT_BC2_TYPELESS: + case DXGI_FORMAT_BC2_UNORM: + case DXGI_FORMAT_BC2_UNORM_SRGB: + case DXGI_FORMAT_BC3_TYPELESS: + case DXGI_FORMAT_BC3_UNORM: + case DXGI_FORMAT_BC3_UNORM_SRGB: + case DXGI_FORMAT_BC5_TYPELESS: + case DXGI_FORMAT_BC5_UNORM: + case DXGI_FORMAT_BC5_SNORM: + case DXGI_FORMAT_BC6H_TYPELESS: + case DXGI_FORMAT_BC6H_UF16: + case DXGI_FORMAT_BC6H_SF16: + case DXGI_FORMAT_BC7_TYPELESS: + case DXGI_FORMAT_BC7_UNORM: + case DXGI_FORMAT_BC7_UNORM_SRGB: + return checked_math::mul4((width + 3) / 4, (height + 3) / 4, depth, 16, outSize); // 16 bytes per block + case DXGI_FORMAT_ASTC_4X4_TYPELESS: + case DXGI_FORMAT_ASTC_4X4_UNORM: + case DXGI_FORMAT_ASTC_4X4_UNORM_SRGB: + return astcSize(4, 4, 1, width, height, depth, outSize); + case DXGI_FORMAT_ASTC_5X4_TYPELESS: + case DXGI_FORMAT_ASTC_5X4_UNORM: + case DXGI_FORMAT_ASTC_5X4_UNORM_SRGB: + return astcSize(5, 4, 1, width, height, depth, outSize); + case DXGI_FORMAT_ASTC_5X5_TYPELESS: + case DXGI_FORMAT_ASTC_5X5_UNORM: + case DXGI_FORMAT_ASTC_5X5_UNORM_SRGB: + return astcSize(5, 5, 1, width, height, depth, outSize); + case DXGI_FORMAT_ASTC_6X5_TYPELESS: + case DXGI_FORMAT_ASTC_6X5_UNORM: + case DXGI_FORMAT_ASTC_6X5_UNORM_SRGB: + return astcSize(6, 5, 1, width, height, depth, outSize); + case DXGI_FORMAT_ASTC_6X6_TYPELESS: + case DXGI_FORMAT_ASTC_6X6_UNORM: + case DXGI_FORMAT_ASTC_6X6_UNORM_SRGB: + return astcSize(6, 6, 1, width, height, depth, outSize); + case DXGI_FORMAT_ASTC_8X5_TYPELESS: + case DXGI_FORMAT_ASTC_8X5_UNORM: + case DXGI_FORMAT_ASTC_8X5_UNORM_SRGB: + return astcSize(8, 5, 1, width, height, depth, outSize); + case DXGI_FORMAT_ASTC_8X6_TYPELESS: + case DXGI_FORMAT_ASTC_8X6_UNORM: + case DXGI_FORMAT_ASTC_8X6_UNORM_SRGB: + return astcSize(8, 6, 1, width, height, depth, outSize); + case DXGI_FORMAT_ASTC_8X8_TYPELESS: + case DXGI_FORMAT_ASTC_8X8_UNORM: + case DXGI_FORMAT_ASTC_8X8_UNORM_SRGB: + return astcSize(8, 8, 1, width, height, depth, outSize); + case DXGI_FORMAT_ASTC_10X5_TYPELESS: + case DXGI_FORMAT_ASTC_10X5_UNORM: + case DXGI_FORMAT_ASTC_10X5_UNORM_SRGB: + return astcSize(10, 5, 1, width, height, depth, outSize); + case DXGI_FORMAT_ASTC_10X6_TYPELESS: + case DXGI_FORMAT_ASTC_10X6_UNORM: + case DXGI_FORMAT_ASTC_10X6_UNORM_SRGB: + return astcSize(10, 6, 1, width, height, depth, outSize); + case DXGI_FORMAT_ASTC_10X8_TYPELESS: + case DXGI_FORMAT_ASTC_10X8_UNORM: + case DXGI_FORMAT_ASTC_10X8_UNORM_SRGB: + return astcSize(10, 8, 1, width, height, depth, outSize); + case DXGI_FORMAT_ASTC_10X10_TYPELESS: + case DXGI_FORMAT_ASTC_10X10_UNORM: + case DXGI_FORMAT_ASTC_10X10_UNORM_SRGB: + return astcSize(10, 10, 1, width, height, depth, outSize); + case DXGI_FORMAT_ASTC_12X10_TYPELESS: + case DXGI_FORMAT_ASTC_12X10_UNORM: + case DXGI_FORMAT_ASTC_12X10_UNORM_SRGB: + return astcSize(12, 10, 1, width, height, depth, outSize); + case DXGI_FORMAT_ASTC_12X12_TYPELESS: + case DXGI_FORMAT_ASTC_12X12_UNORM: + case DXGI_FORMAT_ASTC_12X12_UNORM_SRGB: + return astcSize(12, 12, 1, width, height, depth, outSize); + // TODO + case DXGI_FORMAT_R8G8_B8G8_UNORM: + case DXGI_FORMAT_G8R8_G8B8_UNORM: + case DXGI_FORMAT_AYUV: + case DXGI_FORMAT_Y410: + case DXGI_FORMAT_Y416: + case DXGI_FORMAT_NV12: + case DXGI_FORMAT_P010: + case DXGI_FORMAT_P016: + case DXGI_FORMAT_420_OPAQUE: + case DXGI_FORMAT_YUY2: + case DXGI_FORMAT_Y210: + case DXGI_FORMAT_Y216: + case DXGI_FORMAT_NV11: + case DXGI_FORMAT_AI44: + case DXGI_FORMAT_IA44: + case DXGI_FORMAT_P8: + case DXGI_FORMAT_A8P8: + case DXGI_FORMAT_P208: + case DXGI_FORMAT_V208: + case DXGI_FORMAT_V408: + default: + return false; + } +} + +bool isDXGIFormatCompressed(const uint32_t dxgiFormat) +{ + return (dxgiFormat >= DXGI_FORMAT_BC1_TYPELESS && dxgiFormat <= DXGI_FORMAT_BC5_SNORM) + || (dxgiFormat >= DXGI_FORMAT_BC6H_TYPELESS && dxgiFormat <= DXGI_FORMAT_BC7_UNORM_SRGB) + || (dxgiFormat >= texture_formats::DXGI_FORMAT_ASTC_4X4_TYPELESS + && dxgiFormat <= texture_formats::DXGI_FORMAT_ASTC_12X12_UNORM_SRGB); +} + +bool dx9HeaderSupported(const uint32_t dxgiFormat, bool allowD3DFormatInFourCC) +{ + switch(dxgiFormat) + { + // We strictly only support DX9 headers for formats we're sure + // readers can read - uncompressed formats, plus BC1-BC3, without sRGB + // format conversion - and where the writer knows how to write the header. + case DXGI_FORMAT_BC3_TYPELESS: + case DXGI_FORMAT_BC3_UNORM: + case DXGI_FORMAT_BC2_TYPELESS: + case DXGI_FORMAT_BC2_UNORM: + case DXGI_FORMAT_BC1_TYPELESS: + case DXGI_FORMAT_BC1_UNORM: + case DXGI_FORMAT_A8_UNORM: + case DXGI_FORMAT_R8_UNORM: + case DXGI_FORMAT_R8G8_UNORM: + case DXGI_FORMAT_B8G8R8A8_TYPELESS: + case DXGI_FORMAT_B8G8R8A8_UNORM: + case DXGI_FORMAT_B8G8R8X8_TYPELESS: + case DXGI_FORMAT_B8G8R8X8_UNORM: + return true; + case DXGI_FORMAT_R16_FLOAT: + case DXGI_FORMAT_R16G16_FLOAT: + case DXGI_FORMAT_R16G16B16A16_FLOAT: + case DXGI_FORMAT_R32_FLOAT: + case DXGI_FORMAT_R32G32_FLOAT: + case DXGI_FORMAT_R32G32B32A32_FLOAT: + return allowD3DFormatInFourCC; + default: + return false; + } +} + +// For a format that can be written as a DX9 header, writes the pixel format +// settings into pf. Will assert failure in debug mode if the format is not +// supported, and write nothing except for pf.dwSize if so. +// isLuminance should be set in dwFlags separately. +// Writes color transform only for BC3n and OrthographicNormal. +void setDX9PixelFormat(const uint32_t format, ColorTransform colorTransform, const WriteSettings& writeSettings, DDSPixelFormat& pf) +{ + pf.dwSize = sizeof(DDSPixelFormat); + static_assert((sizeof(DDSPixelFormat)) == 32, "DDS spec states that DDS_PIXELFORMAT size must be 32!"); + + if(writeSettings.useCustomBitmask) + { + pf.dwRBitMask = writeSettings.bitmaskR; + pf.dwGBitMask = writeSettings.bitmaskG; + pf.dwBBitMask = writeSettings.bitmaskB; + pf.dwABitMask = writeSettings.bitmaskA; + + const uint32_t rgbCombined = pf.dwRBitMask | pf.dwGBitMask | pf.dwBBitMask; + if(rgbCombined != 0) + { + pf.dwFlags |= DDPF_RGB; + } + + if(pf.dwABitMask != 0) + { + pf.dwFlags |= DDPF_ALPHAPIXELS; + } + + pf.dwRGBBitCount = maskBitWidth(rgbCombined | pf.dwABitMask); + } + else + { + // Note that the DDS pixelformat starts at 0x4C and ends at 0x6B. + switch(format) + { + case DXGI_FORMAT_BC3_TYPELESS: + case DXGI_FORMAT_BC3_UNORM: + if(colorTransform == ColorTransform::eAGBR) + { + pf.dwFlags = DDPF_FOURCC; + pf.dwFourCC = FOURCC_RXGB; + } + else + { + pf.dwFlags = DDPF_FOURCC; + pf.dwFourCC = FOURCC_DXT5; + } + break; + case DXGI_FORMAT_BC2_TYPELESS: + case DXGI_FORMAT_BC2_UNORM: + pf.dwFlags = DDPF_FOURCC; + pf.dwFourCC = FOURCC_DXT3; + break; + case DXGI_FORMAT_BC1_TYPELESS: + case DXGI_FORMAT_BC1_UNORM: + pf.dwFlags = DDPF_FOURCC; + pf.dwFourCC = FOURCC_DXT1; + break; + case DXGI_FORMAT_A8_UNORM: + pf.dwFlags = DDPF_ALPHA; + pf.dwRGBBitCount = 8; + pf.dwRBitMask = 0; + pf.dwGBitMask = 0; + pf.dwBBitMask = 0; + pf.dwABitMask = 0xFF; + break; + case DXGI_FORMAT_R8_UNORM: + pf.dwFlags = DDPF_RGB; + pf.dwRGBBitCount = 8; + pf.dwRBitMask = 0xFF; + pf.dwGBitMask = 0; + pf.dwBBitMask = 0; + pf.dwABitMask = 0; + break; + case DXGI_FORMAT_R8G8_UNORM: + if(colorTransform == ColorTransform::eOrthographicNormal && writeSettings.legacyNvtteStyleFloatCodes) + { + pf.dwFlags = DDPF_FOURCC; + pf.dwFourCC = D3DFMT_CxV8U8; + } + else + { + pf.dwFlags = DDPF_RGB; + pf.dwRGBBitCount = 16; + pf.dwRBitMask = 0x00FF; + pf.dwGBitMask = 0xFF00; + pf.dwBBitMask = 0; + pf.dwABitMask = 0; + } + break; + case DXGI_FORMAT_B8G8R8A8_TYPELESS: + case DXGI_FORMAT_B8G8R8A8_UNORM: + pf.dwFlags = DDPF_RGBA; + pf.dwRGBBitCount = 32; + pf.dwRBitMask = 0x00FF0000U; + pf.dwGBitMask = 0x0000FF00U; + pf.dwBBitMask = 0x000000FFU; + pf.dwABitMask = 0xFF000000U; + break; + case DXGI_FORMAT_B8G8R8X8_TYPELESS: + case DXGI_FORMAT_B8G8R8X8_UNORM: + pf.dwFlags = DDPF_RGB; + pf.dwRGBBitCount = 32; + pf.dwRBitMask = 0x00FF0000U; + pf.dwGBitMask = 0x0000FF00U; + pf.dwBBitMask = 0x000000FFU; + pf.dwABitMask = 0; + break; + case DXGI_FORMAT_R16_FLOAT: + pf.dwFlags = DDPF_FOURCC; + pf.dwFourCC = D3DFMT_R16F; + break; + case DXGI_FORMAT_R16G16_FLOAT: + pf.dwFlags = DDPF_FOURCC; + pf.dwFourCC = D3DFMT_G16R16F; + break; + case DXGI_FORMAT_R16G16B16A16_FLOAT: + pf.dwFlags = DDPF_FOURCC; + pf.dwFourCC = D3DFMT_A16B16G16R16F; + break; + case DXGI_FORMAT_R32_FLOAT: + pf.dwFlags = DDPF_FOURCC; + pf.dwFourCC = D3DFMT_R32F; + break; + case DXGI_FORMAT_R32G32_FLOAT: + pf.dwFlags = DDPF_FOURCC; + pf.dwFourCC = D3DFMT_G32R32F; + break; + case DXGI_FORMAT_R32G32B32A32_FLOAT: + pf.dwFlags = DDPF_FOURCC; + pf.dwFourCC = D3DFMT_A32B32G32R32F; + break; + default: + assert(!"SetDX9PixelFormat was called for an unsupported format! " + "Please make sure that DX9HeaderSupported returns true for this " + "format and that SetDX9PixelFormat is implemented for this format."); + } + } +} + +void parse3ByteLibraryVersion(const uint32_t version, uint16_t& v0, uint8_t& v1, uint8_t& v2) +{ + v0 = static_cast(version >> 16); + v1 = static_cast(version >> 8); + v2 = static_cast(version); +} + +} // namespace + +/////////////////////////////////////////////////////////////////////////////// +// Public functions +/////////////////////////////////////////////////////////////////////////////// + +const char* getColorTransformString(ColorTransform colorTransform) +{ + switch(colorTransform) + { + case ColorTransform::eNone: + return "None"; + case ColorTransform::eLuminance: + return "Luminance"; + case ColorTransform::eAGBR: + return "AGBR (aka RXGB)"; + case ColorTransform::eYUV: + return "YUV"; + case ColorTransform::eYCoCg: + return "YCoCg"; + case ColorTransform::eYCoCgScaled: + return "YCoCg Scaled"; + case ColorTransform::eAEXP: + return "AEXP"; + case ColorTransform::eSwapRG: + return "SwapRG"; + case ColorTransform::eOrthographicNormal: + return "OrthographicNormal"; + default: + return "?"; + } +} + +const char* getAlphaModeString(uint32_t alphaMode) +{ + switch(alphaMode) + { + case DDS_ALPHA_MODE_UNKNOWN: + return "DDS_ALPHA_MODE_UNKNOWN"; + case DDS_ALPHA_MODE_STRAIGHT: + return "DDS_ALPHA_MODE_STRAIGHT"; + case DDS_ALPHA_MODE_PREMULTIPLIED: + return "DDS_ALPHA_MODE_PREMULTIPLIED"; + case DDS_ALPHA_MODE_OPAQUE: + return "DDS_ALPHA_MODE_OPAQUE"; + case DDS_ALPHA_MODE_CUSTOM: + return "DDS_ALPHA_MODE_CUSTOM"; + default: + return "?"; + } +} + +const char* getWriterLibraryString(WriterLibrary writerLibrary) +{ + switch(writerLibrary) + { + case WriterLibrary::eNVTT: + return "NVIDIA Texture Tools"; + case WriterLibrary::eNVTTExporter: + return "NVIDIA Texture Tools Exporter"; + case WriterLibrary::eNVPS: + return "NVIDIA DesignWorks Samples DDS Library"; + case WriterLibrary::eGIMP: + return "GNU Image Manipulation Program"; + case WriterLibrary::eUnknown: + default: + return "Unknown"; + } +} + +/////////////////////////////////////////////////////////////////////////////// +// Subresource implementation +/////////////////////////////////////////////////////////////////////////////// + +ErrorWithText Subresource::create(size_t imageSizeBytes, const void* pixels) +{ + if(imageSizeBytes == 0) + return "imageSizeBytes must be nonzero."; + + try + { + if(pixels != nullptr) + { + const char* pixelsBytes = reinterpret_cast(pixels); + data.assign(pixelsBytes, pixelsBytes + imageSizeBytes); + } + else + { + data.resize(imageSizeBytes, 0); + } + } + catch(...) + { + return "Allocating " + std::to_string(imageSizeBytes) + " bytes of data failed."; + } + return {}; +} + +void Subresource::clear() +{ + *this = Subresource(); +} + +// Double-check some properties of Subresource. +static_assert(std::is_move_assignable_v); +static_assert(std::is_move_constructible_v); +static_assert(std::is_copy_assignable_v); +static_assert(std::is_copy_constructible_v); + +/////////////////////////////////////////////////////////////////////////////// +// Image implementation +/////////////////////////////////////////////////////////////////////////////// + +ErrorWithText Image::allocate(uint32_t _numMips, uint32_t _numLayers, uint32_t _numFaces) +{ + if(_numMips == 0) + return "_numMips must be nonzero."; + if(_numMips >= 32) + return "_numMips must be less than 32."; + if(_numLayers == 0) + return "_numLayers must be nonzero."; + if(_numFaces == 0) + return "_numFaces must be nonzero."; + + m_numMips = _numMips; + m_numLayers = _numLayers; + m_numFaces = _numFaces; + + size_t totalSubresources = 0; + if(!checked_math::mul3(m_numMips, m_numLayers, m_numFaces, totalSubresources)) + { + return "The total number of subresources was too large to fit in a size_t."; + } + + return resizeVectorOrError(m_data, totalSubresources); +} + +void Image::clear() +{ + m_data.clear(); +} + +ResourceDimension Image::inferResourceDimension() const +{ + if(ResourceDimension::eUnknown != resourceDimension) + { + return resourceDimension; // We know what it is! + } + // Otherwise, try to guess it from the dimensions of the base mip: + if(!m_data.empty()) + { + return ResourceDimension::eUnknown; // We don't know the dimensions. + } + if(mip0Depth > 1) + { + return ResourceDimension::eTexture3D; + } + if(mip0Height > 1) + { + return ResourceDimension::eTexture2D; + } + return ResourceDimension::eTexture1D; +} + +const Subresource& Image::subresource(uint32_t mip, uint32_t layer, uint32_t face) const +{ + if(mip >= m_numMips || layer >= m_numLayers || face >= m_numFaces) + { + throw std::out_of_range("subresource() values were out of range"); + } + + // Here's the [mip, layer, face] layout for subresources we use. + return m_data[(static_cast(mip) * static_cast(m_numLayers) + static_cast(layer)) * static_cast(m_numFaces) + + static_cast(face)]; +} + +Subresource& Image::subresource(uint32_t mip, uint32_t layer, uint32_t face) +{ + return const_cast(const_cast(this)->subresource(mip, layer, face)); +} + +ErrorWithText Image::readHeaderFromStream(std::istream& input, const ReadSettings& readSettings) +{ + // Read the file marker to ensure we have a DDS file. + uint32_t fileCode{}; + READ_OR_ERROR(input, fileCode, "Reached the end of the input while trying to read the first four characters of the input. Is the input truncated?"); + if(fileCode != FOURCC_DDS) + { + return "The DDS file's first four characters were incorrect (expected \"DDS \", but the first four characters were " + + makeFourCCPrintable(fileCode) + "."; + } + + // Create a short alias for m_fileInfo, and clear it. + m_fileInfo = FileInfo{}; + FileInfo& i = m_fileInfo; + + // Read the raw header. + READ_OR_ERROR(input, i.ddsh, "Reached the end of the input while trying to read the core portion of the DDS header. Is the input truncated?"); + + // Determine the number of faces in the image. + // Some DDS files don't have DDSCAPS2_CUBEMAP specified, but still have a + // nonzero number of cubemap faces. So don't check for the + // DDSCAPS2_CUBEMAP flag. + cubemapFaceFlags = (i.ddsh.dwCaps2 & DDSCAPS2_CUBEMAP_ALL_FACES); + + // Get the number of mips in the image. + // There's at least one DDS file that doesn't have DDSD_MIPMAPCOUNT set, + // but still has mipmaps. + // Also, some DDS files have a dwMipMapCount of 0, but actually have + // at least one mip. (They disagree on whether 0 means 'a full mip chain' or + // 'one mip, no mips outside the base layer'). We work around this by + // requiring there to be at least one mip. + m_numMips = std::max(1U, i.ddsh.dwMipMapCount); + if(m_numMips >= 32) + { + return "The number of mips in the DDS file must be less than 32. Otherwise, the base mip would need to have a dimension of 2^32 or larger, which isn't possible"; + } + + // Determine which library wrote this file. + if(i.ddsh.dwReserved1[9] == FOURCC_LIBRARY_EXPORTER) + { + i.writerLibrary = WriterLibrary::eNVTTExporter; + i.writerLibraryVersion = i.ddsh.dwReserved1[10]; + } + else if(i.ddsh.dwReserved1[9] == FOURCC_LIBRARY_NVTT) + { + i.writerLibrary = WriterLibrary::eNVTT; + i.writerLibraryVersion = i.ddsh.dwReserved1[10]; + } + else if(i.ddsh.dwReserved1[9] == FOURCC_LIBRARY_NVPS) + { + i.writerLibrary = WriterLibrary::eNVPS; + i.writerLibraryVersion = i.ddsh.dwReserved1[10]; + } + else if(i.ddsh.dwReserved1[0] == FOURCC_LIBRARY_GIMP_WORD0 && i.ddsh.dwReserved1[1] == FOURCC_LIBRARY_GIMP_WORD1) + { + i.writerLibrary = WriterLibrary::eGIMP; + i.writerLibraryVersion = i.ddsh.dwReserved1[2]; + } + + // GIMP will also sometimes store custom format flags in dwReserved1[3]. + // Detect these, assuming that no other writers use dwReserved1[3] for a + // different purpose and can write these values exactly: + switch(i.ddsh.dwReserved1[3]) + { + case FOURCC_AEXP: + colorTransform = ColorTransform::eAEXP; + break; + case FOURCC_YCOCG: + colorTransform = ColorTransform::eYCoCg; + break; + case FOURCC_YCOCG_SCALED: + colorTransform = ColorTransform::eYCoCgScaled; + break; + } + + if(i.ddsh.dwReserved1[7] == FOURCC_UVER) + { + hasUserVersion = true; + userVersion = i.ddsh.dwReserved1[8]; + } + + // Handle DPPF_ALPHAPREMULT, in case it's there for compatibility. + if((i.ddsh.ddspf.dwFlags & DDPF_ALPHAPREMULT) != 0) + { + alphaMode = DDS_ALPHA_MODE_PREMULTIPLIED; + } + + // We won't know the number of layers in the image until we look at the DX10 + // header, if it exists. So let's examine that FourCC code now! + const bool hasFourCC = ((i.ddsh.ddspf.dwFlags & DDPF_FOURCC) != 0); + + if(hasFourCC && (i.ddsh.ddspf.dwFourCC == FOURCC_DX10)) + { + i.hadDx10Extension = true; + // Read the DX10 header. + READ_OR_ERROR(input, i.ddsh10, "DDS file header specifies a DX10 header, but the DDS reader reached the end of the input when trying to read it; is the input truncated?"); + + dxgiFormat = i.ddsh10.dxgiFormat; + + // If DDS10_RESOURCE_MISC_TEXTURECUBE is set, then we have a full cubemap, + // despite what dwCaps2 said. + if((i.ddsh10.miscFlag & DDS_RESOURCE_MISC_TEXTURECUBE) != 0) + { + cubemapFaceFlags = DDSCAPS2_CUBEMAP_ALL_FACES; + } + + m_numLayers = i.ddsh10.arraySize; + + // Look at lower 3 bits of miscFlags2 to determine alpha mode + alphaMode = i.ddsh10.miscFlags2 & 0x7; + } + else + { + // No DX10 header. + if(hasFourCC) + { + // Detect the swizzle code, which is stored in dwRGBBitCount. + // There's no standard for this, so we just check for what old versions + // of NVTT could output. + switch(i.ddsh.ddspf.dwRGBBitCount) + { + case FOURCC_A2XY: + colorTransform = ColorTransform::eSwapRG; + break; + case FOURCC_A2D5: + colorTransform = ColorTransform::eAGBR; + break; + } + + // Detect the format based on the format code: + switch(i.ddsh.ddspf.dwFourCC) + { + case FOURCC_DXT1: + dxgiFormat = DXGI_FORMAT_BC1_UNORM; + break; + case FOURCC_DXT2: + case FOURCC_DXT3: + dxgiFormat = DXGI_FORMAT_BC2_UNORM; + break; + case FOURCC_DXT4: + case FOURCC_DXT5: + dxgiFormat = DXGI_FORMAT_BC3_UNORM; + break; + // Less standard FOURCC codes + case FOURCC_BC4U: + case FOURCC_ATI1: + dxgiFormat = DXGI_FORMAT_BC4_UNORM; + break; + case FOURCC_BC4S: + dxgiFormat = DXGI_FORMAT_BC4_SNORM; + break; + case FOURCC_BC5U: + dxgiFormat = DXGI_FORMAT_BC5_UNORM; + break; + case FOURCC_ATI2: + // ATI2 is BC5 but with the red and green channels swapped. + // So we remove ColorTransform::eSwapRG if we have it, or add it if + // it's missing. + // Throw an error if the color transform is something else. + if(colorTransform == ColorTransform::eNone) + { + colorTransform = ColorTransform::eSwapRG; + } + else if(colorTransform == ColorTransform::eSwapRG) + { + colorTransform = ColorTransform::eNone; + } + else + { + return "This file specified both ColorTransform " + std::to_string(static_cast(colorTransform)) + + " and a format of ATI2 (which swaps the red and green channels). nv_dds doesn't know how to combine the RG swap with the ColorTransform to get a single color transform."; + } + dxgiFormat = DXGI_FORMAT_BC5_UNORM; + break; + case FOURCC_BC5S: + dxgiFormat = DXGI_FORMAT_BC5_SNORM; + break; + case FOURCC_BC6H: + // That's right - this is UF16, not SF16. + // These FourCC codes are highly nonstandard. + dxgiFormat = DXGI_FORMAT_BC6H_UF16; + break; + case FOURCC_BC7L: + case FOURCC_BC70: + case FOURCC_ZOLA: + // That's right - both 'BC7L' and 'BC7\0' + // are BC7. It's unknown which tools + // produce this + // See https://github.com/microsoft/DirectXTex/pull/165. + // Old versions of NVTT can produce 'ZOLA'. + dxgiFormat = DXGI_FORMAT_BC7_UNORM; + break; + // : There's no corresponding bitmasks or DXGI format for CTX1; + // apps have to detect and decompress this themselves. + case FOURCC_RGBG: + dxgiFormat = DXGI_FORMAT_R8G8_B8G8_UNORM; + break; + case FOURCC_GRGB: + dxgiFormat = DXGI_FORMAT_G8R8_G8B8_UNORM; + break; + case FOURCC_YUY2: + dxgiFormat = DXGI_FORMAT_YUY2; + break; + case FOURCC_UYVY: + dxgiFormat = DXGI_FORMAT_R8G8_B8G8_UNORM; + break; + case FOURCC_RXGB: + dxgiFormat = DXGI_FORMAT_BC3_UNORM; + colorTransform = ColorTransform::eAGBR; + break; + // GLI and DirectXTex will write some DXGI formats without a DX10 + // header and using Direct3D format numbers by default, so we have + // to account for that here. + // Note that most of these are untested - R and B swaps are likely! + case D3DFMT_R8G8B8: + dxgiFormat = DXGI_FORMAT_R8G8B8A8_UNORM; + break; + case D3DFMT_A8R8G8B8: + dxgiFormat = DXGI_FORMAT_B8G8R8A8_UNORM; // I think? + break; + case D3DFMT_X8R8G8B8: + dxgiFormat = DXGI_FORMAT_B8G8R8X8_UNORM; + break; + case D3DFMT_R5G6B5: + dxgiFormat = DXGI_FORMAT_B5G6R5_UNORM; + break; + case D3DFMT_X1R5G5B5: // For now + case D3DFMT_A1R5G5B5: + dxgiFormat = DXGI_FORMAT_B5G5R5A1_UNORM; + break; + case D3DFMT_A4R4G4B4: + dxgiFormat = DXGI_FORMAT_B4G4R4A4_UNORM; + break; + case D3DFMT_R3G3B2: + // NOTE: We overwrite the header itself here to propagate information + // to the bitmasking code! + dxgiFormat = DXGI_FORMAT_UNKNOWN; + i.ddsh.ddspf.dwRGBBitCount = 8; + i.ddsh.ddspf.dwABitMask = 0; + i.ddsh.ddspf.dwRBitMask = 0b11100000; + i.ddsh.ddspf.dwGBitMask = 0b00011100; + i.ddsh.ddspf.dwBBitMask = 0b00000011; + i.bitmaskHasAlpha = true; + i.bitmaskHasRgb = true; + i.wasBitmasked = true; + break; + case D3DFMT_A8: + dxgiFormat = DXGI_FORMAT_A8_UNORM; + break; + case D3DFMT_A8R3G3B2: + dxgiFormat = DXGI_FORMAT_UNKNOWN; + i.ddsh.ddspf.dwRGBBitCount = 16; + i.ddsh.ddspf.dwABitMask = 0xff00; + i.ddsh.ddspf.dwRBitMask = 0b11100000; + i.ddsh.ddspf.dwGBitMask = 0b00011100; + i.ddsh.ddspf.dwBBitMask = 0b00000011; + i.bitmaskHasAlpha = true; + i.bitmaskHasRgb = true; + i.wasBitmasked = true; + break; + case D3DFMT_X4R4G4B4: + dxgiFormat = DXGI_FORMAT_UNKNOWN; + i.ddsh.ddspf.dwRGBBitCount = 16; + i.ddsh.ddspf.dwABitMask = 0x0000; + i.ddsh.ddspf.dwRBitMask = 0x0f00; + i.ddsh.ddspf.dwGBitMask = 0x00f0; + i.ddsh.ddspf.dwBBitMask = 0x000f; + i.bitmaskHasRgb = true; + i.wasBitmasked = true; + break; + case D3DFMT_A2B10G10R10: + dxgiFormat = DXGI_FORMAT_R10G10B10A2_UNORM; + break; + case D3DFMT_A8B8G8R8: + case D3DFMT_X8B8G8R8: + dxgiFormat = DXGI_FORMAT_R8G8B8A8_UNORM; + break; + case D3DFMT_G16R16: + dxgiFormat = DXGI_FORMAT_R16G16_UNORM; + break; + case D3DFMT_A2R10G10B10: + dxgiFormat = DXGI_FORMAT_R10G10B10A2_UNORM; + break; + case D3DFMT_A16B16G16R16: + dxgiFormat = DXGI_FORMAT_R16G16B16A16_UNORM; + break; + // TODO: + // case D3DFMT_A8P8: + // case D3DFMT_P8: + case D3DFMT_L8: + dxgiFormat = DXGI_FORMAT_UNKNOWN; + i.ddsh.ddspf.dwRGBBitCount = 8; + i.ddsh.ddspf.dwRBitMask = 0xff; + i.ddsh.ddspf.dwGBitMask = 0xff; + i.ddsh.ddspf.dwBBitMask = 0xff; + i.bitmaskHasRgb = true; + i.wasBitmasked = true; + colorTransform = ColorTransform::eLuminance; + break; + case D3DFMT_A8L8: + dxgiFormat = DXGI_FORMAT_UNKNOWN; + i.ddsh.ddspf.dwRGBBitCount = 16; + i.ddsh.ddspf.dwABitMask = 0xff00; + i.ddsh.ddspf.dwRBitMask = 0x00ff; + i.ddsh.ddspf.dwGBitMask = 0x00ff; + i.ddsh.ddspf.dwBBitMask = 0x00ff; + i.bitmaskHasAlpha = true; + i.bitmaskHasRgb = true; + i.wasBitmasked = true; + colorTransform = ColorTransform::eLuminance; + break; + case D3DFMT_A4L4: + dxgiFormat = DXGI_FORMAT_UNKNOWN; + i.ddsh.ddspf.dwRGBBitCount = 8; + i.ddsh.ddspf.dwABitMask = 0xf0; + i.ddsh.ddspf.dwRBitMask = 0x0f; + i.ddsh.ddspf.dwGBitMask = 0x0f; + i.ddsh.ddspf.dwBBitMask = 0x0f; + i.bitmaskHasAlpha = true; + i.bitmaskHasRgb = true; + i.wasBitmasked = true; + colorTransform = ColorTransform::eLuminance; + break; + case D3DFMT_V8U8: + dxgiFormat = DXGI_FORMAT_R8G8_SNORM; + break; + // TODO: + // case D3DFMT_L6V5U5: + // case D3DFMT_X8L8V8U8: + case D3DFMT_Q8W8V8U8: + dxgiFormat = DXGI_FORMAT_R8G8B8A8_SNORM; + break; + case D3DFMT_V16U16: + dxgiFormat = DXGI_FORMAT_R16G16_SNORM; + break; + case D3DFMT_A2W10V10U10: + dxgiFormat = DXGI_FORMAT_R10G10B10A2_UINT; + break; + case D3DFMT_D16: + case D3DFMT_D16_LOCKABLE: + dxgiFormat = DXGI_FORMAT_D16_UNORM; + break; + case D3DFMT_D32: + case D3DFMT_D32F_LOCKABLE: + dxgiFormat = DXGI_FORMAT_D32_FLOAT; + break; + case D3DFMT_D24S8: + case D3DFMT_D24X8: + case D3DFMT_D24X4S4: + dxgiFormat = DXGI_FORMAT_D24_UNORM_S8_UINT; + break; + // TODO: case D3DFMT_D15S1: + // TODO: case D3DFMT_D32: + // TODO: case D3DFMT_D32_LOCKABLE: + // TODO: case D3DFMT_D24FS8: + case D3DFMT_S8_LOCKABLE: + dxgiFormat = DXGI_FORMAT_R8_UINT; + break; + // TODO: D3DFMT_VERTEXDATA, D3DFMT_INDEX16, D3DFMT_INDEX32 + case D3DFMT_L16: + dxgiFormat = DXGI_FORMAT_R16_UNORM; + colorTransform = ColorTransform::eLuminance; + break; + case D3DFMT_Q16W16V16U16: + dxgiFormat = DXGI_FORMAT_R16G16B16A16_SNORM; + break; + case D3DFMT_R16F: + dxgiFormat = DXGI_FORMAT_R16_FLOAT; + break; + case D3DFMT_G16R16F: + dxgiFormat = DXGI_FORMAT_R16G16_FLOAT; + break; + case D3DFMT_A16B16G16R16F: + dxgiFormat = DXGI_FORMAT_R16G16B16A16_FLOAT; + break; + case D3DFMT_R32F: + dxgiFormat = DXGI_FORMAT_R32_FLOAT; + break; + case D3DFMT_G32R32F: + dxgiFormat = DXGI_FORMAT_R32G32_FLOAT; + break; + case D3DFMT_A32B32G32R32F: + dxgiFormat = DXGI_FORMAT_R32G32B32A32_FLOAT; + break; + case D3DFMT_CxV8U8: + colorTransform = ColorTransform::eOrthographicNormal; + dxgiFormat = DXGI_FORMAT_R8G8_SNORM; + break; + // TODO: D3DFMT_A1, D3DFMT_BINARYBUFFER + case D3DFMT_A2B10G10R10_XR_BIAS: + dxgiFormat = DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM; + break; + default: { + // Undocumented or unsupported FourCC code. + return "DDS file had FourCC code " + makeFourCCPrintable(i.ddsh.ddspf.dwFourCC) + ", which the DDS reader does not support."; + } + } + } + else + { + // Otherwise, the DDS_PIXELFORMAT structure gives us all the data + // we need to read from an sRGB image. + // DDPF_ALPHAPIXELS: Texture contains alpha data, dwRGBAlphaBitMask is valid. + // DDPF_ALPHA: dwRGBBitCount = alpha channel bitcount, dwABitMask contains valid data. + // DDPF_RGB: RGB channels exist; dwRGBBitCount and RGB masks contain valid data. + // DDPF_YUV: Interpret RGB as YUV data + // DDPF_LUMINANCE: Grayscale; dwRGBBitCount contains bitcount and dwRBitMask contains luminance channel mask. + // DDPF_BUMPDUDV: All channels contain SNORM instead of UNORM data. + if((i.ddsh.ddspf.dwFlags & DDPF_BUMPDUDV) != 0) + { + i.bitmaskWasBumpDuDv = true; + i.bitmaskHasRgb = true; + } + i.bitmaskHasAlpha = ((i.ddsh.ddspf.dwFlags & (DDPF_ALPHA | DDPF_ALPHAPIXELS)) != 0); + i.bitmaskHasRgb |= ((i.ddsh.ddspf.dwFlags & (DDPF_YUV | DDPF_LUMINANCE | DDPF_RGB)) != 0); + i.wasBitmasked = true; + } + + // Read additional color transform info from dwFlags whether we're in DX9 + // or DX10 mode. + if((i.ddsh.ddspf.dwFlags & DDPF_YUV) != 0) + { + colorTransform = ColorTransform::eYUV; + } + if((i.ddsh.ddspf.dwFlags & DDPF_LUMINANCE) != 0) + { + colorTransform = ColorTransform::eLuminance; + } + } + + // Were any of the cubemap fields set? + const bool isCubemap = (cubemapFaceFlags != 0); + // Count the number of faces; this might be a value other than 1 or 6 if we + // have an incomplete cubemap. + m_numFaces = popcnt(cubemapFaceFlags); + // If no cubemap face flags were specified, then this is a 2D texture, and so + // has 1 face. + m_numFaces = std::max(m_numFaces, 1U); + + // Recognize and fix an issue in cubemaps created by the Texture Tools + // Exporter that was fixed in 2023.1.1. + // The Microsoft DDS spec and official DDS reader say arraySize is the number + // of elements. But while the spec's cube map example sets arraySize to 6 for + // a cube map, this is wrong, and RenderDoc will show the extra (blank) + // elements if the reader or writer do this. + // See NVTTE-97 and https://forums.developer.nvidia.com/t/texture-tools-exporter-cubemap-has-incorrect-arraysize/244753 + if(isCubemap && i.writerLibrary == WriterLibrary::eNVTTExporter && i.writerLibraryVersion == LIBRARY_EXPORTER_VERSION_START_THROUGH_2023_1_0) + { + m_numLayers = std::max(1U, m_numLayers / 6); + } + + // Get the size of the base mip. + mip0Width = std::max(1U, i.ddsh.dwWidth); + mip0Height = std::max(1U, i.ddsh.dwHeight); + mip0Depth = std::max(1U, i.ddsh.dwDepth); + + // If we'll read from a bitmasked format, determine what DXGI format we'll + // decompress to. The gold standard is to decompress everything to + // RGBA32SFLOAT, but that uses a lot of memory. Decompressing to RGBA8UNORM + // is OK (no information loss) as long as each component's bitmask is at + // most 8 bits wide and positive. + if(i.wasBitmasked) + { + if(readSettings.bitmaskForceRgbaF32 || i.bitmaskWasBumpDuDv) + { + dxgiFormat = DXGI_FORMAT_R32G32B32A32_FLOAT; + } + else + { + dxgiFormat = DXGI_FORMAT_R8G8B8A8_UNORM; + const bool alphaTooBig = i.bitmaskHasAlpha && maskBitWidth(i.ddsh.ddspf.dwABitMask) > 8; + const bool luminanceTooBig = (colorTransform == ColorTransform::eLuminance) && maskBitWidth(i.ddsh.ddspf.dwRBitMask) > 8; + const bool rgbTooBig = i.bitmaskHasRgb + && (maskBitWidth(i.ddsh.ddspf.dwRBitMask) > 8 || maskBitWidth(i.ddsh.ddspf.dwGBitMask) > 8 + || maskBitWidth(i.ddsh.ddspf.dwBBitMask) > 8); + if(alphaTooBig || luminanceTooBig || rgbTooBig) + { + dxgiFormat = DXGI_FORMAT_R32G32B32A32_FLOAT; + } + } + } + + return {}; +} + +ErrorWithText Image::readHeaderFromFile(const char* filename, const ReadSettings& readSettings) +{ + try + { + std::ifstream file(filename, std::ios::binary | std::ios::in); + return readHeaderFromStream(file, readSettings); + } + catch(const std::exception& e) + { + return "I/O error opening " + std::string(filename) + ": " + std::string(e.what()); + } +} + +ErrorWithText Image::readHeaderFromMemory(const char* buffer, size_t bufferSize, const ReadSettings& readSettings) +{ + if(bufferSize > static_cast(std::numeric_limits::max())) + { + return "The `bufferSize` parameter was too large to be stored in an std::streamsize."; + } + MemoryStream stream(buffer, static_cast(bufferSize)); + return readHeaderFromStream(stream, readSettings); +} + +ErrorWithText Image::readFromStream(std::istream& input, const ReadSettings& readSettings) +{ + UNWRAP_ERROR(readHeaderFromStream(input, readSettings)); + + size_t validationInputSize = 0; + if(readSettings.validateInputSize) + { + const std::streampos initialPos = input.tellg(); + input.seekg(0, std::ios_base::end); + const std::streampos endPos = input.tellg(); + validationInputSize = endPos - initialPos; + input.seekg(initialPos, std::ios_base::beg); + } + + // Create a short alias for m_fileInfo + const FileInfo& i = m_fileInfo; + + // Crop the output to fewer mips if readSettings.mips was specified + const uint32_t mipsInFile = m_numMips; + if(!readSettings.mips) + { + m_numMips = 1; + } + + // Allocate space + { + size_t totalSubresources = 0; + if(!checked_math::mul3(m_numFaces, m_numMips, m_numLayers, totalSubresources) + || totalSubresources > readSettings.maxSubresourceSizeBytes / sizeof(Subresource)) + { + return "This DDS file is too large: it had " + std::to_string(m_numFaces) + " faces, " + std::to_string(m_numMips) + + " requested mips to read, and " + std::to_string(m_numLayers) + + " elements. Their product, the number of subresources in the table of subresources, would require more than the reader's byte limit (" + + std::to_string(readSettings.maxSubresourceSizeBytes) + " bytes) to store."; + } + if(readSettings.validateInputSize && (totalSubresources + 7) / 8 > validationInputSize) + { + return "This DDS file had an impossible header: it listed " + std::to_string(totalSubresources) + + " subresources, but the input was only " + std::to_string(validationInputSize) + + " bytes long. This would not be possible even if the input was an array of 1x1 DXGI_FORMAT_A1 textures."; + } + } + UNWRAP_ERROR(allocate(m_numMips, m_numLayers, m_numFaces)); + + // Precompute bitmasking weights, in case we use bitmasking. + std::array bitmaskMults; + bitmaskMults[0] = getMultiplierFromChannelMask(i.ddsh.ddspf.dwRBitMask, i.bitmaskWasBumpDuDv); + bitmaskMults[1] = getMultiplierFromChannelMask(i.ddsh.ddspf.dwGBitMask, i.bitmaskWasBumpDuDv); + bitmaskMults[2] = getMultiplierFromChannelMask(i.ddsh.ddspf.dwBBitMask, i.bitmaskWasBumpDuDv); + bitmaskMults[3] = getMultiplierFromChannelMask(i.ddsh.ddspf.dwABitMask, i.bitmaskWasBumpDuDv); + + // Iterate over images in the DDS file. Read those images we want to + // read and skip over the rest. + for(uint32_t layer = 0; layer < m_numLayers; layer++) + { + for(uint32_t face = 0; face < m_numFaces; face++) + { + for(uint32_t inputMip = 0; inputMip < mipsInFile; inputMip++) + { + // Compute the size of this image + const uint32_t mipWidth = getWidth(inputMip); + const uint32_t mipHeight = getHeight(inputMip); + const uint32_t mipDepth = getDepth(inputMip); + // Compute size from DDS header. + // The DDS situation here is a bit of a mess. We prefer inferring this + // directly from the format and size; it's hard for writers to get + // that wrong. If there is no format, we use dwRGBBitCount here if it + // is nonzero. If it's not there, use dwPitchOrLinearSize. + size_t fileTexSize = 0; + uint32_t bitmaskedBitsPerPixel = 0; + if(!i.wasBitmasked && dxgiFormat != 0) + { + if(!dxgiExportSize(mipWidth, mipHeight, mipDepth, dxgiFormat, fileTexSize)) + { + return "Could not determine the number of bytes used by a subresource with size " + std::to_string(mipWidth) + + " x " + std::to_string(mipHeight) + " x " + std::to_string(mipDepth) + " and DXGI format " + + std::to_string(dxgiFormat) + "."; + } + } + else if(i.ddsh.ddspf.dwRGBBitCount != 0) + { + bitmaskedBitsPerPixel = i.ddsh.ddspf.dwRGBBitCount; + size_t fileTexSizeBits = 0; + if(!checked_math::mul4(i.ddsh.ddspf.dwRGBBitCount, mipWidth, mipHeight, mipDepth, fileTexSizeBits) + || fileTexSizeBits > std::numeric_limits::max() - 7) + { + return "This file is probably not valid: mip " + std::to_string(inputMip) + " (" + std::to_string(mipWidth) + + " x " + std::to_string(mipHeight) + " x " + std::to_string(mipDepth) + ", dwRGBBitCount == " + + std::to_string(i.ddsh.ddspf.dwRGBBitCount) + ") had more bits than would fit in a size_t."; + } + fileTexSize = (fileTexSizeBits + 7) / 8; + } + else + { + // Since this branch is uncompressed, dwPitchOrLinearSize is + // the number of bytes per scanline in the base mip. + // Try to get the number of bits per pixel, assuming images are + // densely packed. + if((i.ddsh.dwPitchOrLinearSize % mip0Width) != 0) + { + return "This file is probably not valid: it didn't seem to contain DXGI format information, and its dwRGBBitCount was 0. In this situation, dwPitchOrLinearSize should be the number of bits in each scanline of mip 0 - but it wasn't evenly divisible by mip 0's width."; + } + bitmaskedBitsPerPixel = i.ddsh.dwPitchOrLinearSize / mip0Width; + const uint32_t pitch = bitmaskedBitsPerPixel * mipWidth; + if(!checked_math::mul3(pitch, mipHeight, mipDepth, fileTexSize)) + { + return "This file is probably not valid: mip " + std::to_string(inputMip) + " (" + std::to_string(mipWidth) + + " x " + std::to_string(mipHeight) + " x " + std::to_string(mipDepth) + + ", pitch == " + std::to_string(pitch) + " had more bytes than would fit in a size_t."; + } + } + + // Regardless of what we wind up with, a texture size of 0 is bad. + // See https://github.com/nvpro-samples/nvtt_samples/issues/2 + // for how this can crash. + if(fileTexSize == 0) + { + return "This file is probably not valid: mip " + std::to_string(inputMip) + " (" + std::to_string(mipWidth) + + " x " + std::to_string(mipHeight) + " x " + std::to_string(mipDepth) + + ") contained 0 bytes of data. Is a DDS format missing from the header of this file?"; + } + // Also, make sure this isn't impossibly large. + if(((fileTexSize / mipWidth) / mipHeight) / mipDepth > 16) + { + return "This file is probably not valid: mip " + std::to_string(inputMip) + " declared it contained " + + std::to_string(fileTexSize) + " bytes of data. However, that's larger than the number of bytes that a mip of size " + + std::to_string(mipWidth) + " x " + std::to_string(mipHeight) + " x " + std::to_string(mipDepth) + + " would contain using the largest DDS format, RGBA32F (which uses 16 bytes per pixel). Is a DDS format missing from the header of this file?"; + } + // Or impermissibly large. + if(fileTexSize > readSettings.maxSubresourceSizeBytes) + { + return "Mip " + std::to_string(inputMip) + " (" + std::to_string(mipWidth) + " x " + std::to_string(mipHeight) + + " x " + std::to_string(mipDepth) + ") had more bytes (" + std::to_string(fileTexSize) + + ") than the maximum allowed in the DDS reader's parameters (" + + std::to_string(readSettings.maxSubresourceSizeBytes) + ")."; + } + // Additionally, if we're reading mip 0, double-check that the file can + // reasonably contain at least mip 0's data. + if(readSettings.validateInputSize && fileTexSize > validationInputSize / (static_cast(m_numLayers) * m_numFaces)) + { + return "This file is probably not valid: each mip 0 subresource should contain " + std::to_string(fileTexSize) + + " bytes of data, and there are " + std::to_string(m_numLayers) + " layers and " + std::to_string(m_numFaces) + + " faces, but the input is only " + std::to_string(validationInputSize) + " bytes long."; + } + + const bool readData = (inputMip < m_numMips); + if(!readData) + { + // Just go to the next image. + if(!input.seekg(static_cast(fileTexSize), std::ios::cur)) + { + return "Seeking to an image in a DDS input failed. Is the input truncated?"; + } + continue; + } + + Subresource& resource = subresource(inputMip, layer, face); + if(i.wasBitmasked) + { + // Read old-style DDS format from bitmasks. + // Note that we support bitcounts (i.e. differences in bits between + // addresses of consecutive pixels) that are not divisible by 8! + + // Start by reading the raw data into a buffer. We always add 7 bytes + // of padding so we don't need to perform bounds checks when reading + // across boundaries. (This is because if we read at a bit offset of + // 1, we'll read 31 bits from bytes 0-3, and load in 1 bit from bytes + // 4-7.) + if(fileTexSize > std::numeric_limits::max() - 7) + { + return "This file is probably not valid: mip " + std::to_string(inputMip) + + " declared it contained so much data that if 7 more bytes were added, its size would overflow a size_t."; + } + std::vector fileData; + UNWRAP_ERROR(resizeVectorOrError(fileData, fileTexSize + 7)); + if(!input.read(reinterpret_cast(fileData.data()), static_cast(fileTexSize))) + { + return "Reading bitmasked data for an image in a DDS input failed. Is the input truncated?"; + } + + // Before we allocate data for the output, make sure it's also not + // too large. + assert(dxgiFormat == DXGI_FORMAT_R8G8B8A8_UNORM || dxgiFormat == DXGI_FORMAT_R32G32B32A32_FLOAT); + size_t outputTexSize = 0; + if(!dxgiExportSize(mipWidth, mipHeight, mipDepth, dxgiFormat, outputTexSize) || outputTexSize > readSettings.maxSubresourceSizeBytes) + { + return "Mip " + std::to_string(inputMip) + " (" + std::to_string(mipWidth) + " x " + std::to_string(mipHeight) + + " x " + std::to_string(mipDepth) + ") was bitmasked and would have been decompressed to DXGI format " + + std::to_string(dxgiFormat) + "; that would have used more bytes than the maximum allowed in the DDS reader's parameters (" + + std::to_string(readSettings.maxSubresourceSizeBytes) + ")."; + } + + // Allocate the output: + UNWRAP_ERROR(resource.create(outputTexSize, nullptr)); + char* outputData = resource.data.data(); + + // Now iterate over pixels: + size_t bitPosition = 0; + size_t pixelIdx = 0; + const uint32_t* fileDataBuf32 = reinterpret_cast(fileData.data()); + + std::array pixel = {0.0F, 0.0F, 0.0F, 1.0F}; + + for(size_t z = 0; z < mipDepth; ++z) + { + for(size_t y = 0; y < mipHeight; ++y) + { + for(size_t x = 0; x < mipWidth; ++x) + { + // Set dataBuf to 32 bits starting at bitPosition: + const size_t wordIndex = bitPosition % 32; + uint32_t dataBuf = fileDataBuf32[bitPosition / 32] >> wordIndex; + if(wordIndex != 0) + { + dataBuf |= ((fileDataBuf32[bitPosition / 32 + 1]) << (32 - wordIndex)); + } + + // Decompress the pixel: + if(colorTransform == ColorTransform::eLuminance) + { + const float v = + (i.bitmaskWasBumpDuDv ? bitsToSnorm(dataBuf, bitmaskMults[0]) : bitsToUnorm(dataBuf, bitmaskMults[0])); + pixel[0] = pixel[1] = pixel[2] = v; + } + else if(i.bitmaskHasRgb) + { + for(int c = 0; c < 3; c++) + { + pixel[c] = (i.bitmaskWasBumpDuDv ? bitsToSnorm(dataBuf, bitmaskMults[c]) : + bitsToUnorm(dataBuf, bitmaskMults[c])); + } + } + + if(i.bitmaskHasAlpha) + { + pixel[3] = + (i.bitmaskWasBumpDuDv ? bitsToSnorm(dataBuf, bitmaskMults[3]) : bitsToUnorm(dataBuf, bitmaskMults[3])); + } + + // Transform it to our output format: + if(dxgiFormat == DXGI_FORMAT_R8G8B8A8_UNORM) + { + // RGBA8 + uint8_t* outputPixelData = reinterpret_cast(outputData) + 4 * pixelIdx; + for(int c = 0; c < 4; c++) + { + // We use centered quantization here: + outputPixelData[c] = static_cast(std::roundf(pixel[c] * 255.0F)); + } + } + else + { + // RGBAF32 + float* outputPixelData = reinterpret_cast(outputData) + 4 * pixelIdx; + for(int c = 0; c < 4; c++) + { + outputPixelData[c] = pixel[c]; + } + } + + bitPosition += bitmaskedBitsPerPixel; + pixelIdx++; + } + } + } + } + else + { + // Fast path: not bitmasked; read it directly from the input into + // the subresource. + UNWRAP_ERROR(resource.create(fileTexSize, nullptr)); + if(!input.read(resource.data.data(), static_cast(fileTexSize))) + { + return "Copying data for an image in a DDS input failed. Is the input truncated?"; + } + } + } + } + } + return {}; // Success! +} + +ErrorWithText Image::readFromFile(const char* filename, const ReadSettings& readSettings) +{ + try + { + std::ifstream file(filename, std::ios::binary | std::ios::in); + return readFromStream(file, readSettings); + } + catch(const std::exception& e) + { + return "I/O error opening " + std::string(filename) + ": " + std::string(e.what()); + } +} + +ErrorWithText Image::readFromMemory(const char* buffer, size_t bufferSize, const ReadSettings& readSettings) +{ + if(bufferSize > static_cast(std::numeric_limits::max())) + { + return "The `bufferSize` parameter was too large to be stored in an std::streamsize."; + } + MemoryStream stream(buffer, bufferSize); + return readFromStream(stream, readSettings); +} + +ErrorWithText Image::writeToStream(std::ostream& output, const WriteSettings& writeSettings) +{ + //--------------------------------------------------------------------------- + // Image write: Define DDS Header and Pixel Format + DDSHeader header = {0}; + static_assert(sizeof(DDSHeader) == 124, "DDS header size must be 124 by specification!"); + header.dwSize = sizeof(DDSHeader); + + // Specify which members contain valid data + // Required components + header.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT; + if(mip0Depth > 1) + { + // NVTTE-112: DDS has two flags for volumes. + // The DX10 documentation confirms that DDSD_DEPTH indicates a volume + // texture, since this used to be DDS_HEADER_FLAGS_VOLUME. + header.dwFlags |= DDSD_DEPTH; + header.dwCaps2 |= DDSCAPS2_VOLUME; + } + + header.dwHeight = mip0Height; + header.dwWidth = mip0Width; + header.dwDepth = mip0Depth; + + // Double-check that this Image has been created correctly + { + size_t requiredSubresources = 0; + if(!checked_math::mul3(m_numMips, m_numLayers, m_numFaces, requiredSubresources)) + { + return "The number of mips, layers, and faces in this image is too large; the number of subresources they would require is greater than what would fit in a size_t."; + } + if(requiredSubresources != m_data.size()) + { + return "This Image should have " + std::to_string(requiredSubresources) + " subresources, but m_data contained " + + std::to_string(m_data.size()) + " subresources. Was this Image created correctly?"; + } + } + + // Pitch or linear size + if(isDXGIFormatCompressed(dxgiFormat)) + { + // Linear size, the total number of bytes in the top level texture + header.dwFlags |= DDSD_LINEARSIZE; + const size_t mip0Size = getSize(); + if(mip0Size > std::numeric_limits::max()) + { + return "The number of bytes in the base mip of this texture was was greater than 2^32-1, and so wouldn't fit in the dwPitchOrLinearSize field of the DDS header."; + } + header.dwPitchOrLinearSize = static_cast(mip0Size); + } + else + { + // Pitch, the number of bytes per scanline in an uncompressed texture + // (we do this the simplest way possible, since currently every + // uncompressed format has the same number of bytes per scanline) + header.dwFlags |= DDSD_PITCH; + const size_t mip0Pitch = getSize() / (static_cast(mip0Height) * mip0Depth); + if(mip0Pitch > std::numeric_limits::max()) + { + return "The pitch of the base mip of this texture was greater than 2^32-1, and so wouldn't fit in the dwPitchOrLinearSize field of the DDS header."; + } + header.dwPitchOrLinearSize = static_cast(mip0Pitch); + } + + header.dwMipMapCount = getNumMips(); + + // Before we specify the pixel format, specify the complexity: + header.dwCaps1 = DDSCAPS_TEXTURE; + if(m_numMips > 1) + { + header.dwFlags |= DDSD_MIPMAPCOUNT; + header.dwCaps1 |= DDSCAPS_COMPLEX | DDSCAPS_MIPMAP; + } + if(m_numFaces > 1) + { + header.dwCaps1 |= DDSCAPS_COMPLEX; + header.dwCaps2 |= DDSCAPS2_CUBEMAP | cubemapFaceFlags; + } + + if(hasUserVersion) + { + header.dwReserved1[7] = FOURCC_UVER; + header.dwReserved1[8] = userVersion; + } + + // Add a code to the reserved part of the header so that other readers + // can tell that they're reading files written with the newest version of + // NVDDS. + header.dwReserved1[9] = FOURCC_LIBRARY_NVPS; + header.dwReserved1[10] = (2 << 16) | (1 << 8) | 1; + + //--------------------------------------------------------------------------- + // DDS Pixel Format + // Specification: https://docs.microsoft.com/en-us/windows/win32/direct3ddds/dds-pixelformat + DDSPixelFormat& pixelformat = header.ddspf; + static_assert(sizeof(pixelformat) == 32, "DDS_PIXELFORMAT size must be 32, per specification!"); + pixelformat.dwSize = sizeof(pixelformat); + + // Note: I think DDPF_ALPHAPIXELS technically specifies that the texture + // contains uncompressed alpha data, since the alpha bitmask (note that + // this is really dwABitMask, not dwRGBAlphaBitMask) must then contain + // valid data. + + // Note: We used to almost always write the DX10 header. However, it turns + // out a lot of old readers -- which are still commonly used -- will crash + // if given a file with this header. So now we have much finer conditions on + // when we need to use one. + // Specifically, we use the following set of rules, in order of precedence: + // 1. Some formats are only specified in terms of bitmasks, so must use the + // old spec. + // 2. BC3n can only be specified using the DX9 header. + // 3. Array textures must use the DX10 header. + // 4. If useDX10HeaderIfPossible, use the DX10 header. + // 5. Otherwise, use the DX10 hader only if dx9HeaderSupported returns false. + bool usesDXT10Header = false; + const bool isBC3N = (dxgiFormat == DXGI_FORMAT_BC3_UNORM || dxgiFormat == DXGI_FORMAT_BC3_TYPELESS) + && (colorTransform == ColorTransform::eAGBR); + if(writeSettings.useCustomBitmask || isBC3N) + { + usesDXT10Header = false; + } + else if(m_numLayers > 1 || writeSettings.useDx10HeaderIfPossible) + { + usesDXT10Header = true; + } + else + { + usesDXT10Header = !dx9HeaderSupported(dxgiFormat, writeSettings.legacyNvtteStyleFloatCodes); + } + + if(usesDXT10Header) + { + pixelformat.dwFlags |= DDPF_FOURCC; + pixelformat.dwFourCC = FOURCC_DX10; + } + else + { + setDX9PixelFormat(dxgiFormat, colorTransform, writeSettings, pixelformat); + } + + + if(isNormal) + { + pixelformat.dwFlags |= DDPF_NORMAL; + } + + // If our data is premultiplied, also set DPPF_ALPHAPREMULT for compatibility: + if(alphaMode == DDS_ALPHA_MODE_PREMULTIPLIED) + { + pixelformat.dwFlags |= DDPF_ALPHAPREMULT; + } + + // Encode the color transform. + switch(colorTransform) + { + case ColorTransform::eNone: + break; + case ColorTransform::eLuminance: + pixelformat.dwFlags |= DDPF_LUMINANCE; + break; + case ColorTransform::eAGBR: + // We can set this in dwRGBBitCount, but only if FourCC is nonzero (so + // that there's no ambiguity). + if(pixelformat.dwFourCC != 0) + { + pixelformat.dwRGBBitCount = FOURCC_A2D5; + } + // We always write DDPF_NORMAL when the data is in AGBR, so that + // GIMP knows it needs to swap channels. + pixelformat.dwFlags |= DDPF_NORMAL; + break; + case ColorTransform::eYUV: + pixelformat.dwFlags |= DDPF_YUV; + break; + case ColorTransform::eYCoCg: + header.dwReserved1[3] = FOURCC_YCOCG; + break; + case ColorTransform::eYCoCgScaled: + header.dwReserved1[3] = FOURCC_YCOCG_SCALED; + break; + case ColorTransform::eAEXP: + header.dwReserved1[3] = FOURCC_AEXP; + break; + case ColorTransform::eSwapRG: + if(pixelformat.dwFourCC != 0) + { + pixelformat.dwRGBBitCount = FOURCC_A2XY; + } + break; + case ColorTransform::eOrthographicNormal: + // This can only be handled by SetDX9PixelFormat(). + break; + } + + //--------------------------------------------------------------------------- + // Write the DDS magic number + WRITE_OR_ERROR(output, FOURCC_DDS, "Could not write DDS magic number. Is writing to this file allowed?"); + + // Write the DDS header + WRITE_OR_ERROR(output, header, "Could not write DDS header."); + + //--------------------------------------------------------------------------- + // DX10 DDS extension + // Specification: https://docs.microsoft.com/en-us/windows/win32/direct3ddds/dds-header-dxt10 + if(usesDXT10Header) + { + DDSHeaderDX10 ddsh10 = {}; + ddsh10.dxgiFormat = dxgiFormat; + ddsh10.resourceDimension = resourceDimension; + + // If we have a complete cube map, it's appropriate to set this. + // In the case of an incomplete cubemap, it's unclear. @nbickford believes + // the spec says that if it's set, then there are 6 faces, so it would be + // inconsistent to set it for an incomplete cubemap. + if(m_numFaces == 6) + { + ddsh10.miscFlag = DDS_RESOURCE_MISC_TEXTURECUBE; + } + + // Note: The Microsoft DDS spec and official DDS reader says arraySize is + // the number of elements. Its cube map example sets arraySize to 6 for + // a cubemap, but this is wrong, and RenderDoc will show the extra (blank) + // elements if the reader or writer do this. + // See NVTTE-97 and https://forums.developer.nvidia.com/t/texture-tools-exporter-cubemap-has-incorrect-arraysize/244753 + ddsh10.arraySize = m_numLayers; + + // Specify the transparency mode of the images. + ddsh10.miscFlags2 = alphaMode; + + // Write DDS10 header + static_assert(sizeof(ddsh10) == 20, + "DDSHeaderDX10 must be 20 bytes long (see " + "https://docs.microsoft.com/en-us/windows/win32/direct3ddds/dds-file-layout-for-textures)!"); + WRITE_OR_ERROR(output, ddsh10, "Could not write DX10 extension."); + } + + // Write all of the compressed data here. + // Order: + // for each array layer: + // for each cubemap face: + // for each mip: + // for each z slice: + for(uint32_t layer = 0; layer < m_numLayers; layer++) + { + for(uint32_t face = 0; face < m_numFaces; face++) + { + for(uint32_t mip = 0; mip < m_numMips; mip++) + { + const std::vector& data = subresource(mip, layer, face).data; + if(!output.write(data.data(), static_cast(data.size()))) + { + return "Could not write data for mip " + std::to_string(mip) + ", face " + std::to_string(face) + ", layer " + + std::to_string(layer) + "."; + } + } + } + } + + return {}; +} + +ErrorWithText Image::writeToFile(const char* filename, const WriteSettings& writeSettings) +{ + try + { + std::ofstream file(filename, std::ios::binary | std::ios::out); + return writeToStream(file, writeSettings); + } + catch(const std::exception& e) + { + return "I/O error opening " + std::string(filename) + ": " + std::string(e.what()); + } +} + +std::string Image::formatInfo() const +{ + // This initial implementation is based on NVTT 3.2.6's DDS implementation. + const DDSHeader& header = m_fileInfo.ddsh; // Short alias + + std::stringstream s; + s << std::setfill('0') << std::uppercase; + s << "Flags: 0x" << std::hex << std::setw(8) << header.dwFlags << std::dec << "\n"; + if((header.dwFlags & DDSD_CAPS) != 0) + s << "\tDDSD_CAPS\n"; + if((header.dwFlags & DDSD_PIXELFORMAT) != 0) + s << "\tDDSD_PIXELFORMAT\n"; + if((header.dwFlags & DDSD_WIDTH) != 0) + s << "\tDDSD_WIDTH\n"; + if((header.dwFlags & DDSD_HEIGHT) != 0) + s << "\tDDSD_HEIGHT\n"; + if((header.dwFlags & DDSD_DEPTH) != 0) + s << "\tDDSD_DEPTH\n"; + if((header.dwFlags & DDSD_PITCH) != 0) + s << "\tDDSD_PITCH\n"; + if((header.dwFlags & DDSD_LINEARSIZE) != 0) + s << "\tDDSD_LINEARSIZE\n"; + if((header.dwFlags & DDSD_MIPMAPCOUNT) != 0) + s << "\tDDSD_MIPMAPCOUNT\n"; + + s << "Height: " << header.dwHeight << "\n"; + s << "Width: " << header.dwWidth << "\n"; + s << "Depth: " << header.dwDepth << "\n"; + if((header.dwFlags & DDSD_PITCH) != 0) + s << "Pitch: " << header.dwPitchOrLinearSize << "\n"; + else if((header.dwFlags & DDSD_LINEARSIZE) != 0) + s << "Linear size: " << header.dwPitchOrLinearSize << "\n"; + s << "Mipmap count: " << header.dwMipMapCount << "\n"; + + s << "Pixel format:\n"; + s << "\tFlags: 0x" << std::hex << std::setw(8) << header.ddspf.dwFlags << std::dec << "\n"; + if((header.ddspf.dwFlags & DDPF_ALPHAPIXELS) != 0) + s << "\t\tDDPF_ALPHAPIXELS\n"; + if((header.ddspf.dwFlags & DDPF_ALPHA) != 0) + s << "\t\tDDPF_ALPHA\n"; + if((header.ddspf.dwFlags & DDPF_FOURCC) != 0) + s << "\t\tDDPF_FOURCC\n"; + if((header.ddspf.dwFlags & DDPF_PALETTEINDEXED4) != 0) + s << "\t\tDDPF_PALETTEINDEXED4\n"; + if((header.ddspf.dwFlags & DDPF_PALETTEINDEXEDTO8) != 0) + s << "\t\tDDPF_PALETTEINDEXEDTO8\n"; + if((header.ddspf.dwFlags & DDPF_PALETTEINDEXED8) != 0) + s << "\t\tDDPF_PALETTEINDEXED8\n"; + if((header.ddspf.dwFlags & DDPF_RGB) != 0) + s << "\t\tDDPF_RGB\n"; + if((header.ddspf.dwFlags & DDPF_COMPRESSED) != 0) + s << "\t\tDDPF_COMPRESSED\n"; + if((header.ddspf.dwFlags & DDPF_RGBTOYUV) != 0) + s << "\t\tDDPF_RGBTOYUV\n"; + if((header.ddspf.dwFlags & DDPF_YUV) != 0) + s << "\t\tDDPF_YUV\n"; + if((header.ddspf.dwFlags & DDPF_ZBUFFER) != 0) + s << "\t\tDDPF_ZBUFFER\n"; + if((header.ddspf.dwFlags & DDPF_PALETTEINDEXED1) != 0) + s << "\t\tDDPF_PALETTEINDEXED1\n"; + if((header.ddspf.dwFlags & DDPF_PALETTEINDEXED2) != 0) + s << "\t\tDDPF_PALETTEINDEXED2\n"; + if((header.ddspf.dwFlags & DDPF_ZPIXELS) != 0) + s << "\t\tDDPF_ZPIXELS\n"; + if((header.ddspf.dwFlags & DDPF_STENCILBUFFER) != 0) + s << "\t\tDDPF_STENCILBUFFER\n"; + if((header.ddspf.dwFlags & DDPF_ALPHAPREMULT) != 0) + s << "\t\tDDPF_ALPHAPREMULT\n"; + if((header.ddspf.dwFlags & DDPF_LUMINANCE) != 0) + s << "\t\tDDPF_LUMINANCE\n"; + if((header.ddspf.dwFlags & DDPF_BUMPLUMINANCE) != 0) + s << "\t\tDDPF_BUMPLUMINANCE\n"; + if((header.ddspf.dwFlags & DDPF_BUMPDUDV) != 0) + s << "\t\tDDPF_BUMPDUDV\n"; + if((header.ddspf.dwFlags & DDPF_SRGB) != 0) + s << "\t\tDDPF_SRGB\n"; + if((header.ddspf.dwFlags & DDPF_NORMAL) != 0) + s << "\t\tDDPF_NORMAL\n"; + + // Display fourcc code even when DDPF_FOURCC flag not set. + if(header.ddspf.dwFourCC != 0) + { + s << "\tFourCC: " << makeFourCCPrintable(header.ddspf.dwFourCC); + s << " (0x" << std::hex << std::setw(8) << header.ddspf.dwFourCC << std::dec << ")\n"; + } + + // If the pixel format uses a FourCC code, normally bitmasks aren't used. So + // sometimes the dwRGBBitCount field is used to encode a 'swizzle code', like + // 'A2D5' or 'A2XY'. NVTT sometimes does this; @nbickford isn't aware of + // any other libraries that do. + if(((header.ddspf.dwFlags & DDPF_FOURCC) != 0) && (header.ddspf.dwRGBBitCount != 0)) + { + s << "\tSwizzle: " << makeFourCCPrintable(header.ddspf.dwRGBBitCount); + s << " (0x" << std::hex << std::setw(8) << header.ddspf.dwRGBBitCount << std::dec << ")\n"; + } + else + { + s << "\tBit count: " << header.ddspf.dwRGBBitCount << "\n"; + } + + s << std::hex; + + s << "\tRed mask: 0x" << std::setw(8) << header.ddspf.dwRBitMask << "\n"; + s << "\tGreen mask: 0x" << std::setw(8) << header.ddspf.dwGBitMask << "\n"; + s << "\tBlue mask: 0x" << std::setw(8) << header.ddspf.dwBBitMask << "\n"; + s << "\tAlpha mask: 0x" << std::setw(8) << header.ddspf.dwABitMask << "\n"; + + s << "Caps:\n"; + s << "\tCaps 1: 0x" << std::setw(8) << header.dwCaps1 << "\n"; + if((header.dwCaps1 & DDSCAPS_COMPLEX) != 0) + s << "\t\tDDSCAPS_COMPLEX\n"; + if((header.dwCaps1 & DDSCAPS_TEXTURE) != 0) + s << "\t\tDDSCAPS_TEXTURE\n"; + if((header.dwCaps1 & DDSCAPS_MIPMAP) != 0) + s << "\t\tDDSCAPS_MIPMAP\n"; + + s << "\tCaps 2: 0x" << std::setw(8) << header.dwCaps2 << "\n"; + if((header.dwCaps2 & DDSCAPS2_CUBEMAP) != 0) + s << "\t\tDDSCAPS2_CUBEMAP\n"; + if((header.dwCaps2 & DDSCAPS2_CUBEMAP_ALL_FACES) == DDSCAPS2_CUBEMAP_ALL_FACES) + { + s << "\t\tDDSCAPS2_CUBEMAP_ALL_FACES\n"; + } + else + { + if((header.dwCaps2 & DDSCAPS2_CUBEMAP_POSITIVEX) != 0) + s << "\t\tDDSCAPS2_CUBEMAP_POSITIVEX\n"; + if((header.dwCaps2 & DDSCAPS2_CUBEMAP_NEGATIVEX) != 0) + s << "\t\tDDSCAPS2_CUBEMAP_NEGATIVEX\n"; + if((header.dwCaps2 & DDSCAPS2_CUBEMAP_POSITIVEY) != 0) + s << "\t\tDDSCAPS2_CUBEMAP_POSITIVEY\n"; + if((header.dwCaps2 & DDSCAPS2_CUBEMAP_NEGATIVEY) != 0) + s << "\t\tDDSCAPS2_CUBEMAP_NEGATIVEY\n"; + if((header.dwCaps2 & DDSCAPS2_CUBEMAP_POSITIVEZ) != 0) + s << "\t\tDDSCAPS2_CUBEMAP_POSITIVEZ\n"; + if((header.dwCaps2 & DDSCAPS2_CUBEMAP_NEGATIVEZ) != 0) + s << "\t\tDDSCAPS2_CUBEMAP_NEGATIVEZ\n"; + } + if((header.dwCaps2 & DDSCAPS2_VOLUME) != 0) + s << "\t\tDDSCAPS2_VOLUME\n"; + + s << std::dec; + + if(m_fileInfo.hadDx10Extension) + { + const nv_dds::DDSHeaderDX10& ddsh10 = m_fileInfo.ddsh10; + + s << "DX10 Header:\n"; + const char* dxgiFormatName = texture_formats::getDXGIFormatName(ddsh10.dxgiFormat); + s << "\tDXGI Format: " << ddsh10.dxgiFormat << " (" // + << ((dxgiFormatName == nullptr) ? "?" : dxgiFormatName) // + << ")\n"; + s << "\tResource dimension: " << static_cast(ddsh10.resourceDimension) << " ("; + switch(ddsh10.resourceDimension) + { + case ResourceDimension::eUnknown: + s << "UNKNOWN"; + break; + case ResourceDimension::eBuffer: + s << "BUFFER"; + break; + case ResourceDimension::eTexture1D: + s << "TEXTURE1D"; + break; + case ResourceDimension::eTexture2D: + s << "TEXTURE2D"; + break; + case ResourceDimension::eTexture3D: + s << "TEXTURE3D"; + break; + default: + s << "?"; + break; + } + s << ")\n"; + + s << "\tMisc flags: " << ddsh10.miscFlag << "\n"; + if((ddsh10.miscFlag & DDS_RESOURCE_MISC_TEXTURECUBE) != 0) + s << "\t\tDDS_RESOURCE_MISC_TEXTURECUBE\n"; + s << "\tArray size flag: " << ddsh10.arraySize << "\n"; + s << "\tMisc flags 2: " << ddsh10.miscFlags2 << "\n"; + switch(alphaMode) + { + case DDS_ALPHA_MODE_UNKNOWN: + s << "\t\tDDS_ALPHA_MODE_UNKNOWN\n"; + break; + case DDS_ALPHA_MODE_STRAIGHT: + s << "\t\tDDS_ALPHA_MODE_STRAIGHT\n"; + break; + case DDS_ALPHA_MODE_PREMULTIPLIED: + s << "\t\tDDS_ALPHA_MODE_PREMULTIPLIED\n"; + break; + case DDS_ALPHA_MODE_OPAQUE: + s << "\t\tDDS_ALPHA_MODE_OPAQUE\n"; + break; + case DDS_ALPHA_MODE_CUSTOM: + s << "\t\tDDS_ALPHA_MODE_CUSTOM\n"; + break; + default: + break; + } + } + else + { + // No DDS10 header, but still show the format if we determined what it was + if(0 != dxgiFormat) + { + if(m_fileInfo.wasBitmasked) + { + s << "Bitmask would be decompressed to DXGI format: "; + } + else + { + s << "Inferred DXGI format: "; + } + const char* dxgiFormatName = texture_formats::getDXGIFormatName(dxgiFormat); + s << dxgiFormat << " (" << (dxgiFormatName ? dxgiFormatName : "?") << ")\n"; + } + } + + // Library + uint16_t v0 = 0; + uint8_t v1 = 0; + uint8_t v2 = 0; + parse3ByteLibraryVersion(m_fileInfo.writerLibraryVersion, v0, v1, v2); + switch(m_fileInfo.writerLibrary) + { + case WriterLibrary::eUnknown: + break; + case WriterLibrary::eNVTT: + s << "Library: NVIDIA Texture Tools\n"; + // These casts are so that they're formatted as numbers instead of + // characters -- this happens even with uint8_t. + s << "\tVersion: " << static_cast(v0) << "." << static_cast(v1) << "." + << static_cast(v2) << "\n"; + break; + case WriterLibrary::eNVTTExporter: + s << "Library: NVIDIA Texture Tools Exporter\n"; + switch(m_fileInfo.writerLibraryVersion) + { + case LIBRARY_EXPORTER_VERSION_START_THROUGH_2023_1_0: + s << "\tVersion: 2020.1.0 - 2023.1.0\n"; + break; + case LIBRARY_EXPORTER_VERSION_2023_1_1_PLUS: + s << "\tVersion: 2023.1.1+\n"; + break; + default: + s << "\tVersion: Unknown\n"; + break; + } + break; + case WriterLibrary::eNVPS: + s << "Library: nv_dds\n"; + s << "\tVersion: " << static_cast(v0) << "." << static_cast(v1) << "." + << static_cast(v2) << "\n"; + break; + case WriterLibrary::eGIMP: + s << "Library: GNU Image Manipulation Program's DDS plugin\n"; + s << "\tVersion: " << static_cast(v0) << "." << static_cast(v1) << "." + << static_cast(v2) << "\n"; + s << "\tGIMP Format FourCC: " << makeFourCCPrintable(header.dwReserved1[3]); + s << " (0x" << std::hex << std::setw(8) << header.dwReserved1[3] << std::dec << ")\n"; + break; + default: + s << "Library: " << static_cast(m_fileInfo.writerLibrary) << "\n"; + break; + } + + // User version + if(hasUserVersion) + { + s << "User version: " << userVersion << "\n"; + } + + return s.str(); +} + +} // namespace nv_dds diff --git a/nvpro_core_legacy/fileformats/nv_dds.h b/nvpro_core_legacy/fileformats/nv_dds.h new file mode 100644 index 0000000..9b527a9 --- /dev/null +++ b/nvpro_core_legacy/fileformats/nv_dds.h @@ -0,0 +1,718 @@ +/* + * Copyright (c) 2016-2025, NVIDIA CORPORATION. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-FileCopyrightText: Copyright (c) 2016-2025 NVIDIA CORPORATION + * SPDX-License-Identifier: Apache-2.0 + */ + +////////////////////////////////////////////////////////////////////////// +/** @DOC_START +# nv_dds 2.1.1 + +> A small yet complete library for reading and writing DDS files. + +Other than the C++ standard library, nv_dds only requires five files: +dxgiformat.h, nv_dds.h, nv_dds.cpp, texture_formats.h, and texture_formats.cpp. + +To load a DDS file, use `Image::readFromFile()`: + +```cpp +nv_dds::Image image; +nv_dds::ErrorWithText maybeError = image.readFromFile("data/image.dds", {}); +if(maybeError.has_value()) +{ + // Do something with the error message, maybeError.value() +} +else +{ + // Access subresources using image.subresource(...), and upload them + // to the GPU using your graphics API of choice. +} +``` + +`Image`'s format field is a DXGI format. If you need to use this data with +another API, you can use the functions in texture_formats.h to look up +the corresponding API format. + +To write a DDS file, use `Image::writeToFile()`: + +```cpp +nv_dds::ErrorWithText maybe_error = image.writeToFile("output.dds", {}); +if(maybe_error.has_value()) +{ + LOGE("Failed to write to output.dds! The DDS writer reported: %s\n", + maybe_error.value().c_str()); +} +``` + +`Image` also provides functions to read and write streams. Each of these +read and write functions supports various settings; see `ReadSettings` +and `WriteSettings`. + +Images can also be created from raw data: +```cpp +nv_dds::Image image; +image.allocate(1, // _numMips + 1, // _numLayers + 1); // _numFaces +image.subresource(0, 0, 0) // mip, layer, face + .create(512, 512, 1, subresource_data); // width, height, depth, data + = nv_dds::Subresource(512, 512, 1, subresource_data); // width, height, depth, data +``` + +## Limitations + +Not currently supported: +* Multi-plane YUV textures with chroma subsampling + (e.g. `DXGI_FORMAT_R8G8_B8G8_UNORM`) +* Paletted textures +* DirectDraw Surface versions before DX9 + +## Changes from nv_dds 1.0 + +nv_dds adds support for many more formats, fixes many issues, and now aims +to be secure against untrusted input, so it's worth updating. However, the API +has almost entirely changed, and now looks much more like nv_ktx's API: + +* `CSurface` is now `nv_dds::Subresource` +* `CDDSImage` is now `nv_dds::Image` +* `CTexture` (representing a mip chain) has been moved to part of `Image`. +* Images can no longer be flipped. It turns out the code for this only worked +for mips whose height was a multiple of the block size; in all other cases, +flipping a block-compressed image across the y axis requires decompressing +and recompressing it, which is outside the scope of nv_dds. (We recommend +flipping your sampling y axis instead; if flipping compressed image data is +absolutely necessary, consider using a library such as NVTT.) + +-- @DOC_END */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include + +namespace nv_dds { + +struct DDSPixelFormat +{ + uint32_t dwSize; + uint32_t dwFlags; + uint32_t dwFourCC; + uint32_t dwRGBBitCount; + uint32_t dwRBitMask; + uint32_t dwGBitMask; + uint32_t dwBBitMask; + uint32_t dwABitMask; +}; + +struct DDSHeader +{ + uint32_t dwSize; + uint32_t dwFlags; + uint32_t dwHeight; + uint32_t dwWidth; + uint32_t dwPitchOrLinearSize; + uint32_t dwDepth; + uint32_t dwMipMapCount; + uint32_t dwReserved1[11]; + DDSPixelFormat ddspf; + uint32_t dwCaps1; + uint32_t dwCaps2; + uint32_t dwReserved2[3]; +}; + +enum class ResourceDimension : uint32_t +{ + eUnknown, + eBuffer, + eTexture1D, + eTexture2D, + eTexture3D, + eCount +}; + +struct DDSHeaderDX10 +{ + uint32_t dxgiFormat; + ResourceDimension resourceDimension; + uint32_t miscFlag; + uint32_t arraySize; + uint32_t miscFlags2; +}; + +// Some DDS writers store their writer IDs and versions in fields of the DDS +// header. WriterLibrary and WriterLibraryVersion enumerate writers that nv_dds +// can recognize: +enum class WriterLibrary : uint32_t +{ + eUnknown, + eNVTT, // NVIDIA Texture Tools core library + eNVTTExporter, // NVIDIA Texture Tools Exporter + eNVPS, // This library + eGIMP // GNU Image Manipulation Program +}; + +// Returns the name of a writer library. +// For WriterLibrary::eUnknown, returns "Unknown". +const char* getWriterLibraryString(WriterLibrary writerLibrary); + +// Some DDS files store their data in special encodings before compression. +// The reader will try to find and identify these if it can; the app will need +// to implement its own logic to convert from the stored data to the +// true colors. +// Although it's technically possible for a file to mix these by, say, +// combining the YUV flag with the RXGB FourCC code, only one of these are +// usually present at a time in real files. +enum class ColorTransform +{ + eNone, + // This image stores luminance values. This distinguishes between R8 and L8. + eLuminance, + // Also known as RXGB; the red and alpha channel are swapped. This appears + // often when encoding normals in BC3 textures; because the two components + // of normals are usually not very correlated, and the RGB and A channels are + // encoded separately in BC3, this gives higher-quality results than, say, + // using BC1. + // Nowadays, a better alternative is to use BC5. + eAGBR, + // The image uses the DDPF_YUV flag. @nbickford is unsure which primaries + // this uses. + eYUV, + // The image stores data in the YCoCg color model. + // See nvtt::fromYCoCg(). + eYCoCg, + // The image stores data in a scaled YCoCg format. + // This isn't quite the same as nvtt::blockScaleCoCg(), which operates on + // 4x4 blocks. Instead, when decoding, multiply the Co and Cg terms by + // 1.f / (blue / 8.0f + 1.0f) + // where blue ranges from 0-255, before further decoding YCoCg. + eYCoCgScaled, + // The image stores data where the alpha channel acts as a scaling factor. + // Multiply the R, G, and B channels by the A channel when decoding. + // Note that although this stands for "alpha exponent", it's different than + // the RGBE encodings used by the .hdr file format and NVTT, and the A + // channel is only a scaling factor. + eAEXP, + // Swap the red and green channels. + eSwapRG, + // Reconstruct the blue channel from the red and green channels using + // sqrt(1-r^2-g^2). + // This usually appears with an SNORM format; e.g. D3DFMT_CxV8U8 is + // R8G8_SNORM + this reconstruction. + // Writing is only supported when using R8G8_SNORM without the DX10 extension. + eOrthographicNormal +}; +// Returns the ColorTransform in string form. Returns "?" if out-of-bounds. +const char* getColorTransformString(ColorTransform transform); + +// miscFlags2 enumeration: Alpha modes +const uint32_t DDS_ALPHA_MODE_UNKNOWN = 0x0; +const uint32_t DDS_ALPHA_MODE_STRAIGHT = 0x1; +const uint32_t DDS_ALPHA_MODE_PREMULTIPLIED = 0x2; +const uint32_t DDS_ALPHA_MODE_OPAQUE = 0x3; +const uint32_t DDS_ALPHA_MODE_CUSTOM = 0x4; +// Returns the alpha mode in string form. Returns "?" if out-of-bounds. +const char* getAlphaModeString(uint32_t alphaMode); + +// These functions return an empty std::optional if they succeeded, and a +// value with text describing the error if they failed. +// Functions that return these also will do their best not to throw exceptions. +// (Constructing an std::string from a constant string could throw an exception +// if memory is extremely low.) +using ErrorWithText = std::optional; + +// Represents a single 3D image subresource. +struct Subresource +{ + // Default constructor. + Subresource() = default; + // Frees existing data and reallocates or copies data. + // Specifically, if `pixels` is nullptr, `data` will be zero-initialized and + // set to the given length in bytes. Otherwise, `data` will be copied from + // `pixels`. + // Returns an error message if imageSizeBytes is 0. + ErrorWithText create(size_t imageSizeBytes, const void* pixels); + // Frees image data and resets the size. + void clear(); + + std::vector data; // The image's raw data. +}; + +// Contains all the settings for reading DDS files. +struct ReadSettings +{ + // The maximum size for any subresource in bytes. + // This prevents resource exhaustion attacks; otherwise, it's possible for + // a stream to list an impossibly large size. + size_t maxSubresourceSizeBytes = sizeof(float) * 4ULL * 65536ULL * 32768ULL; + // If true, the reader will validate that the DDS file can plausibly contain + // the data it says it contains. This will involve seeking to the end of the + // stream to determine the length of the data. + bool validateInputSize = true; + // Whether mips should be read beyond the base mip. + bool mips = true; + // Makes the DDS reader always decompress bitmasked DDS files to + // DXGI_FORMAT_R32G32B32A32_SFLOAT. + // + // By default, if a DDS file uses bitmasks and each component stores + // <= 8 bits of data, the DDS reader decompresses to + // DXGI_FORMAT_R8G8B8A8_UNORM; it only decompresses to + // DXGI_FORMAT_R32G32B32A32_SFLOAT if a component has more bits. + // However, if you know you're always converting the output to RGBAF32, then + // you can skip a conversion by setting this to true. + bool bitmaskForceRgbaF32 = false; +}; + +struct WriteSettings +{ + // If set to true, the writer will try to always use the DX10 header + // extension, which is more precise, if the format settings allow it. + // + // By default (false), the writer will prefer DX9-style headers for BC1-BC3 + // and some uncompressed DXGI formats, since these are more compatible with + // older readers (including nv_dds 1.0). However, newer formats like BC7 + // can't be expressed in DX9-style headers (although there are some obscure + // FourCC codes for them), and will always use DX10. + bool useDx10HeaderIfPossible = false; + + // Before the DX10 header existed, DX9 versions of the DDS file format + // allowed writing D3D9 D3DFORMAT values into the dwFourCC field. + // This is undocumented in DX10 and later versions of the format, so reader + // support for it varies greatly. If a reader doesn't support the DX10 + // extension, it might recognize D3DFORMATs in dwFourCC. + // + // Set this to `true` to allow the writer to write D3DFORMAT values into the + // dwFourCC field. + bool legacyNvtteStyleFloatCodes = false; + + // If set to `true`, the writer will ignore the Image's `format` field, + // and will instead use a DX9 header with the bitmasks given below. + // dwRGBBitCount, the RGB flag of dwFlags, and the ALPHA flag of dwFlags will + // be automatically set based on the bitmask values. + // This also overrides `useDx10HeaderIfPossible`. + bool useCustomBitmask = false; + uint32_t bitmaskR = 0; + uint32_t bitmaskG = 0; + uint32_t bitmaskB = 0; + uint32_t bitmaskA = 0; +}; + +// Represents a full image (with optional cubemap faces and mips) as contents +// of a DDS file. Includes the format in which the data is stored. +// Various flags describe how the image should be interpreted by readers, +// without fully decompressing the image. +struct Image +{ +public: + // Clears, then sets up the vector of subresources for an image with the + // given dimensions. These must all be greater than 0, and _numMips must be + // less than 32. + // This can fail e.g. if the parameters are so large that the app runs out of + // memory when allocating space. + ErrorWithText allocate( + // The number of mips (levels) in the image, including the base mip. + uint32_t _numMips = 1, + // The number of array elements (layers) in the image. + uint32_t _numLayers = 1, + // The number of faces in the image (1 for a 2D texture, 6 for a complete + // cube map; if storing an incomplete cube map, don't forget to set + // `cubemap_face_flags`. + uint32_t _numFaces = 1); + + // Clears all stored image data. Does not clear properties. + // allocate() must be called again before one can access subresources. + void clear(); + + // Returns the intended DirectX resource dimension of this texture. + // If this wasn't specified in the DX10 header, it's inferred from whether + // any of the dimensions of the base mip were 0. + // If you want the raw resource dimension, access + // `resource_dimension` directly. + ResourceDimension inferResourceDimension() const; + + // Mutably accesses the subresource at the given mip, layer, and face. If the + // given indices are out of range, throws an std::out_of_range exception. + const Subresource& subresource(uint32_t mip = 0, uint32_t layer = 0, uint32_t face = 0) const; + Subresource& subresource(uint32_t mip = 0, uint32_t layer = 0, uint32_t face = 0); + + // Reads only the header of this structure from a DDS stream, advancing the + // stream as well. + // Note that for bitmasked data, m_fileInfo.wasBitmasked will be set, + // and dxgiFormat will be the format the bitmasked data will be decompressed + // to. + ErrorWithText readHeaderFromStream(std::istream& input, // The input stream, at the start of the DDS data. + const ReadSettings& readSettings); // Settings for the reader. + + // Wrapper for readHeaderFromStream for a file. + ErrorWithText readHeaderFromFile(const char* filename, // The .dds file to read from. + const ReadSettings& readSettings); // Settings for the reader. + + // Wrapper for readHeaderFromStream for a buffer in memory. + ErrorWithText readHeaderFromMemory(const char* buffer, // The buffer in memory. + size_t bufferSize, // Its length in bytes. + const ReadSettings& readSettings); // Settings for the reader. + + + // Reads this structure from a DDS stream, advancing the stream as well. + // Returns an optional error message if the read failed. + // Bitmasked data will be automatically decompressed. + ErrorWithText readFromStream(std::istream& input, // The input stream, at the start of the DDS data. + const ReadSettings& readSettings); // Settings for the reader. + + // Wrapper for readFromStream for a file. + ErrorWithText readFromFile(const char* filename, // The .dds file to read from. + const ReadSettings& readSettings); // Settings for the reader. + + // Wrapper for readFromStream for a buffer in memory. + ErrorWithText readFromMemory(const char* buffer, // The buffer in memory. + size_t bufferSize, // Its length in bytes. + const ReadSettings& readSettings); // Settings for the reader. + + + // Writes this structure in DDS format to a stream. + ErrorWithText writeToStream(std::ostream& output, // The output stream, at the point to start writing + const WriteSettings& writeSettings); // Settings for the writer + + // Wrapper for writeToStream for a filename. Customarily, the filename ends + // in .dds. + ErrorWithText writeToFile(const char* filename, // The output stream, at the point to start writing + const WriteSettings& writeSettings); // Settings for the writer + + + // Returns the width of the given mip. + // Always greater than or equal to 1. + inline uint32_t getWidth(uint32_t mip) const + { + assert(mip < 32); + const uint32_t shiftResult = mip0Width >> mip; + return (shiftResult == 0 ? 1 : shiftResult); + } + + // Returns the height of the given mip. + // Always greater than or equal to 1. + inline uint32_t getHeight(uint32_t mip) const + { + assert(mip < 32); + const uint32_t shiftResult = mip0Height >> mip; + return (shiftResult == 0 ? 1 : shiftResult); + } + + // Returns the depth of the given mip. + // Always greater than or equal to 1. + inline uint32_t getDepth(uint32_t mip) const + { + assert(mip < 32); + const uint32_t shiftResult = mip0Depth >> mip; + return (shiftResult == 0 ? 1 : shiftResult); + } + + // Returns the size of the base mip of the image in bytes. + // Note that the image must have been completely loaded first. + // Always greater than or equal to 1. + inline size_t getSize() const + { + assert(!m_data.empty()); + return m_data[0].data.size(); + } + + // Returns the number of mips (levels) in the image, including the base mip. + // Always greater than or equal to 1. + inline uint32_t getNumMips() const { return m_numMips; } + + // The number of array elements (layers) in the image. + inline uint32_t getNumLayers() const { return m_numLayers; } + + // The number of faces in the image (1 for a 2D texture, 6 for a complete + // cube map, some other number for an incomplete cube map). + inline uint32_t getNumFaces() const { return m_numFaces; } + + // Read-only properties of a DDS file. + struct FileInfo + { + // The original DDS headers. + // The information below is parsed from the headers. + DDSHeader ddsh{}; + DDSHeaderDX10 ddsh10{}; + + WriterLibrary writerLibrary = WriterLibrary::eUnknown; + // Parsing this depends on the library; see formatInfo()'s implementation. + uint32_t writerLibraryVersion = 0; + + // Whether the DDS file used the DX10 extension. + bool hadDx10Extension = false; + + // Whether the DDS file was decompressed from bitmasked, non-DX10 data. + bool wasBitmasked = false; + // If the texture was bitmasked, whether it had an alpha component. + bool bitmaskHasAlpha = false; + // If the texture was bitmasked, whether it had RGB components. + bool bitmaskHasRgb = false; + // If the texture was bitmasked, whether it used the "bump du dv" encoding + // for normal maps. + bool bitmaskWasBumpDuDv = false; + }; + + // Read-only accessor for some properties of a DDS file. + inline const FileInfo& getFileInfo() const { return m_fileInfo; } + + // Returns a printable string containing information about the Image. + std::string formatInfo() const; + + // These members can generally be freely modified. + + // Unlike Vulkan, each of these must be nonzero for a valid Image. + uint32_t mip0Width = 0; + uint32_t mip0Height = 0; + uint32_t mip0Depth = 0; + + // The DXGI format of the image. To use this with an API other than DirectX, + // find the corresponding texture format using texture_formats.h. + // To write a bitmasked image, set this to UNKNOWN (0), and use + // WriteSettings' bitmask fields. + uint32_t dxgiFormat = 0; + + // The type of the image: buffer, 1D texture, 2D texture, or 3D texture. + // Set this to Unknown to automatically infer it during writing. + ResourceDimension resourceDimension = ResourceDimension::eUnknown; + + // A bitmask of the faces included in the DDS file, if this is a cubemap. + // Note that this starts at DDSCAPS2_CUBEMAP_POSITIVEX, not 1! + uint32_t cubemapFaceFlags = 0; + + // The alpha mode; straight, premultiplied, opaque, or custom. + // See DDS_ALPHA_MODE. + // MSDN notes that the D3DX 10 and D3DX 11 libraries can't load DDS files + // with this set to anything other than 0 (DDS10_ALPHA_MODE_UNKNOWN). + uint32_t alphaMode = DDS_ALPHA_MODE_STRAIGHT; + + // See ColorTransform. + ColorTransform colorTransform = ColorTransform::eNone; + + // Whether to write the DDPF_NORMAL flag. + bool isNormal = false; + + // Some DDS files have a 'user version' field: 'UVER' in dwReserved1[7], and + // an arbitrary 32-bit integer in dwReserved1[8]. `has_user_version` controls + // whether to write this integer or whether it existed, and userVersion is + // its value. + bool hasUserVersion = false; + uint32_t userVersion = 0; + +private: + uint32_t m_numMips = 1; + uint32_t m_numLayers = 1; + uint32_t m_numFaces = 1; + + FileInfo m_fileInfo = {}; + + // A structure containing all the image's encoded data. We store this in a + // buffer with an entry per subresource, and provide accessors to it. + std::vector m_data; +}; + +//----------------------------------------------------------------------------- +// These values are included for convenience, if you need to visualize the +// contents of the DDS header. + +#ifdef NV_DDS_UTILITY_VALUES +// surface description flags +// https://docs.microsoft.com/en-us/windows/win32/direct3ddds/dds-header +const uint32_t DDSD_CAPS = 0x00000001U; +const uint32_t DDSD_HEIGHT = 0x00000002U; +const uint32_t DDSD_WIDTH = 0x00000004U; +const uint32_t DDSD_PITCH = 0x00000008U; +const uint32_t DDSD_PIXELFORMAT = 0x00001000U; +const uint32_t DDSD_MIPMAPCOUNT = 0x00020000U; +const uint32_t DDSD_LINEARSIZE = 0x00080000U; +const uint32_t DDSD_DEPTH = 0x00800000U; + +// pixel format flags +const uint32_t DDPF_ALPHAPIXELS = 0x00000001U; +const uint32_t DDPF_ALPHA = 0x00000002U; +const uint32_t DDPF_FOURCC = 0x00000004U; +const uint32_t DDPF_PALETTEINDEXED4 = 0x00000008U; +const uint32_t DDPF_PALETTEINDEXEDTO8 = 0x00000010U; +const uint32_t DDPF_PALETTEINDEXED8 = 0x00000020U; +const uint32_t DDPF_RGB = 0x00000040U; +const uint32_t DDPF_COMPRESSED = 0x00000080U; +const uint32_t DDPF_RGBTOYUV = 0x00000100U; +const uint32_t DDPF_YUV = 0x00000200U; +const uint32_t DDPF_ZBUFFER = 0x00000400U; +const uint32_t DDPF_PALETTEINDEXED1 = 0x00000800U; +const uint32_t DDPF_PALETTEINDEXED2 = 0x00001000U; +const uint32_t DDPF_ZPIXELS = 0x00002000U; +const uint32_t DDPF_STENCILBUFFER = 0x00004000U; +const uint32_t DDPF_ALPHAPREMULT = 0x00008000U; +// TODO: What was 0x00010000U? +const uint32_t DDPF_LUMINANCE = 0x00020000U; +const uint32_t DDPF_BUMPLUMINANCE = 0x00040000U; +const uint32_t DDPF_BUMPDUDV = 0x00080000U; +const uint32_t DDPF_RGBA = DDPF_RGB | DDPF_ALPHAPIXELS; +// Custom NVTT flags. +const uint32_t DDPF_SRGB = 0x40000000U; +const uint32_t DDPF_NORMAL = 0x80000000U; + +// dwCaps1 flags +const uint32_t DDSCAPS_COMPLEX = 0x00000008U; +const uint32_t DDSCAPS_TEXTURE = 0x00001000U; +const uint32_t DDSCAPS_MIPMAP = 0x00400000U; + +// dwCaps2 flags +const uint32_t DDSCAPS2_CUBEMAP = 0x00000200U; +const uint32_t DDSCAPS2_CUBEMAP_POSITIVEX = 0x00000400U; +const uint32_t DDSCAPS2_CUBEMAP_NEGATIVEX = 0x00000800U; +const uint32_t DDSCAPS2_CUBEMAP_POSITIVEY = 0x00001000U; +const uint32_t DDSCAPS2_CUBEMAP_NEGATIVEY = 0x00002000U; +const uint32_t DDSCAPS2_CUBEMAP_POSITIVEZ = 0x00004000U; +const uint32_t DDSCAPS2_CUBEMAP_NEGATIVEZ = 0x00008000U; +const uint32_t DDSCAPS2_CUBEMAP_ALL_FACES = DDSCAPS2_CUBEMAP_POSITIVEX | DDSCAPS2_CUBEMAP_NEGATIVEX + | DDSCAPS2_CUBEMAP_POSITIVEY | DDSCAPS2_CUBEMAP_NEGATIVEY + | DDSCAPS2_CUBEMAP_POSITIVEZ | DDSCAPS2_CUBEMAP_NEGATIVEZ; +const uint32_t DDSCAPS2_VOLUME = 0x00200000U; + +inline constexpr uint32_t MakeFourCC(char c0, char c1, char c2, char c3) +{ + return ((uint32_t)(uint8_t)(c0) | ((uint32_t)(uint8_t)(c1) << 8) | ((uint32_t)(uint8_t)(c2) << 16) + | ((uint32_t)(uint8_t)(c3) << 24)); +} + +// The DDS magic number. +const uint32_t FOURCC_DDS = MakeFourCC('D', 'D', 'S', ' '); + +// Compressed texture types +const uint32_t FOURCC_DXT1 = MakeFourCC('D', 'X', 'T', '1'); +const uint32_t FOURCC_DXT2 = MakeFourCC('D', 'X', 'T', '2'); +const uint32_t FOURCC_DXT3 = MakeFourCC('D', 'X', 'T', '3'); +const uint32_t FOURCC_DXT4 = MakeFourCC('D', 'X', 'T', '4'); +const uint32_t FOURCC_DXT5 = MakeFourCC('D', 'X', 'T', '5'); + +// Additional FOURCC codes from DirectXTex and other sources +const uint32_t FOURCC_BC4U = MakeFourCC('B', 'C', '4', 'U'); +const uint32_t FOURCC_BC4S = MakeFourCC('B', 'C', '4', 'S'); +const uint32_t FOURCC_BC5U = MakeFourCC('B', 'C', '5', 'U'); +const uint32_t FOURCC_BC5S = MakeFourCC('B', 'C', '5', 'S'); +const uint32_t FOURCC_BC6H = MakeFourCC('B', 'C', '6', 'H'); +const uint32_t FOURCC_BC7L = MakeFourCC('B', 'C', '7', 'L'); +const uint32_t FOURCC_BC70 = MakeFourCC('B', 'C', '7', '\0'); +const uint32_t FOURCC_ZOLA = MakeFourCC('Z', 'O', 'L', 'A'); // Written by NVTT +const uint32_t FOURCC_CTX1 = MakeFourCC('C', 'T', 'X', '1'); // Written by NVTT +const uint32_t FOURCC_RGBG = MakeFourCC('R', 'G', 'B', 'G'); +const uint32_t FOURCC_GRGB = MakeFourCC('G', 'R', 'G', 'B'); +const uint32_t FOURCC_ATI1 = MakeFourCC('A', 'T', 'I', '1'); // aka BC4 +const uint32_t FOURCC_ATI2 = MakeFourCC('A', 'T', 'I', '2'); // BC5 with red and green swapped +const uint32_t FOURCC_UYVY = MakeFourCC('U', 'Y', 'V', 'Y'); +const uint32_t FOURCC_YUY2 = MakeFourCC('Y', 'U', 'Y', '2'); +const uint32_t FOURCC_AEXP = MakeFourCC('A', 'E', 'X', 'P'); // Written by GIMP +const uint32_t FOURCC_RXGB = MakeFourCC('R', 'X', 'G', 'B'); // Written by GIMP +const uint32_t FOURCC_YCOCG = MakeFourCC('Y', 'C', 'G', '1'); // Written by GIMP +const uint32_t FOURCC_YCOCG_SCALED = MakeFourCC('Y', 'C', 'G', '2'); // Written by GIMP +const uint32_t FOURCC_A2XY = MakeFourCC('A', '2', 'X', 'Y'); // Written by NVTT +const uint32_t FOURCC_A2D5 = MakeFourCC('A', '2', 'D', '5'); // Written by NVTT + +const uint32_t FOURCC_DX10 = MakeFourCC('D', 'X', '1', '0'); + +// TODO (nbickford): Support FOURCC codes from +// https://docs.microsoft.com/en-us/windows/win32/medfound/recommended-8-bit-yuv-formats-for-video-rendering + +// The various NVTT-derived DDS writers store their writer IDs in the +// dwReserved1[9] field. Here's a table of versions that exist so far: +const uint32_t FOURCC_LIBRARY_EXPORTER = MakeFourCC('N', 'V', 'T', '3'); +const uint32_t FOURCC_LIBRARY_NVTT = MakeFourCC('N', 'V', 'T', 'T'); +const uint32_t FOURCC_LIBRARY_NVPS = MakeFourCC('N', 'V', 'P', 'S'); +// The Exporter stores a version number in dwReserved1[10]: +const uint32_t LIBRARY_EXPORTER_VERSION_START_THROUGH_2023_1_0 = 0; +const uint32_t LIBRARY_EXPORTER_VERSION_2023_1_1_PLUS = 1; +// NVTT and NVPS also store version numbers in dwReserved1[10]; see +// formatInfo() for how to parse these. + +// GIMP's DDS plugin stores its writer ID in dwReserved1[0:1] and its version +// number in dwReserved[2]. +const uint32_t FOURCC_LIBRARY_GIMP_WORD0 = MakeFourCC('G', 'I', 'M', 'P'); +const uint32_t FOURCC_LIBRARY_GIMP_WORD1 = MakeFourCC('-', 'D', 'D', 'S'); +// GIMP's DDS plugin version works like NVTT and NVPS'. + +// The UVER tag, which sometimes appears in dwReserved1[7]. +const uint32_t FOURCC_UVER = MakeFourCC('U', 'V', 'E', 'R'); + +// DDS10 header miscFlag flags +const uint32_t DDS_RESOURCE_MISC_TEXTURECUBE = 0x4l; + +// Some DDS writers (e.g. GLI, some modes of DirectXTex, and floating-point +// formats in old versions of NVTT) write out formats by storing their D3D9 +// D3DFMT in the FourCC field. +// See https://docs.microsoft.com/en-us/windows/win32/direct3d9/d3dformat +// and https://github.com/g-truc/gli/blob/master/gli/dx.hpp +const uint32_t D3DFMT_UNKNOWN = 0; +const uint32_t D3DFMT_R8G8B8 = 20; +const uint32_t D3DFMT_A8R8G8B8 = 21; +const uint32_t D3DFMT_X8R8G8B8 = 22; +const uint32_t D3DFMT_R5G6B5 = 23; +const uint32_t D3DFMT_X1R5G5B5 = 24; +const uint32_t D3DFMT_A1R5G5B5 = 25; +const uint32_t D3DFMT_A4R4G4B4 = 26; +const uint32_t D3DFMT_R3G3B2 = 27; +const uint32_t D3DFMT_A8 = 28; +const uint32_t D3DFMT_A8R3G3B2 = 29; +const uint32_t D3DFMT_X4R4G4B4 = 30; +const uint32_t D3DFMT_A2B10G10R10 = 31; +const uint32_t D3DFMT_A8B8G8R8 = 32; +const uint32_t D3DFMT_X8B8G8R8 = 33; +const uint32_t D3DFMT_G16R16 = 34; +const uint32_t D3DFMT_A2R10G10B10 = 35; +const uint32_t D3DFMT_A16B16G16R16 = 36; +const uint32_t D3DFMT_A8P8 = 40; +const uint32_t D3DFMT_P8 = 41; +const uint32_t D3DFMT_L8 = 50; +const uint32_t D3DFMT_A8L8 = 51; +const uint32_t D3DFMT_A4L4 = 52; +const uint32_t D3DFMT_V8U8 = 60; +const uint32_t D3DFMT_L6V5U5 = 61; +const uint32_t D3DFMT_X8L8V8U8 = 62; +const uint32_t D3DFMT_Q8W8V8U8 = 63; +const uint32_t D3DFMT_V16U16 = 64; +const uint32_t D3DFMT_A2W10V10U10 = 67; +const uint32_t D3DFMT_D16_LOCKABLE = 70; +const uint32_t D3DFMT_D32 = 71; +const uint32_t D3DFMT_D15S1 = 73; +const uint32_t D3DFMT_D24S8 = 75; +const uint32_t D3DFMT_D24X8 = 77; +const uint32_t D3DFMT_D24X4S4 = 79; +const uint32_t D3DFMT_D16 = 80; +const uint32_t D3DFMT_L16 = 81; +const uint32_t D3DFMT_D32F_LOCKABLE = 82; +const uint32_t D3DFMT_D24FS8 = 83; +const uint32_t D3DFMT_D32_LOCKABLE = 84; +const uint32_t D3DFMT_S8_LOCKABLE = 85; +const uint32_t D3DFMT_VERTEXDATA = 100; +const uint32_t D3DFMT_INDEX16 = 101; +const uint32_t D3DFMT_INDEX32 = 102; +const uint32_t D3DFMT_Q16W16V16U16 = 110; +const uint32_t D3DFMT_R16F = 111; +const uint32_t D3DFMT_G16R16F = 112; +const uint32_t D3DFMT_A16B16G16R16F = 113; +const uint32_t D3DFMT_R32F = 114; +const uint32_t D3DFMT_G32R32F = 115; +const uint32_t D3DFMT_A32B32G32R32F = 116; +const uint32_t D3DFMT_CxV8U8 = 117; +const uint32_t D3DFMT_A1 = 118; +const uint32_t D3DFMT_A2B10G10R10_XR_BIAS = 119; +const uint32_t D3DFMT_BINARYBUFFER = 199; +#endif // NV_DDS_UTILITY_VALUES + +} // namespace nv_dds diff --git a/nvpro_core_legacy/fileformats/nv_ktx.cpp b/nvpro_core_legacy/fileformats/nv_ktx.cpp new file mode 100644 index 0000000..503c558 --- /dev/null +++ b/nvpro_core_legacy/fileformats/nv_ktx.cpp @@ -0,0 +1,3196 @@ +/* + * Copyright (c) 2021-2024, NVIDIA CORPORATION. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-FileCopyrightText: Copyright (c) 2021-2024 NVIDIA CORPORATION + * SPDX-License-Identifier: Apache-2.0 + */ + +#include "nv_ktx.h" + +#include +#include +#include +#include // Some functions produce assertion errors to assist with debugging when NDEBUG is false. +#include +#include +#include +#include // memcpy +#include +#ifdef NVP_SUPPORTS_ZSTD +#include +#endif +#ifdef NVP_SUPPORTS_GZLIB +#include +#endif +#ifdef NVP_SUPPORTS_BASISU +#include +#include +#endif + +#include "khr_df.h" +#include "texture_formats.h" + +namespace nv_ktx { + +// Some sources for this code: +// KTX 1 specification at https://github.com/KhronosGroup/KTX-Specification/releases/tag/1.0-final +// KTX 2 specification at https://github.khronos.org/KTX-Specification/ +// Khronos Data Format Specification 1.3.1 at https://www.khronos.org/registry/DataFormat/specs/1.3/dataformat.1.3.html +// (especially chapters 3-5) + +//----------------------------------------------------------------------------- +// SHARED KTX1 + KTX2 FUNCTIONS +//----------------------------------------------------------------------------- + +const size_t IDENTIFIER_LEN = 12; +const uint8_t ktx1Identifier[IDENTIFIER_LEN] = {0xAB, 0x4B, 0x54, 0x58, 0x20, 0x31, 0x31, 0xBB, 0x0D, 0x0A, 0x1A, 0x0A}; +const uint8_t ktx2Identifier[IDENTIFIER_LEN] = {0xAB, 0x4B, 0x54, 0x58, 0x20, 0x32, 0x30, 0xBB, 0x0D, 0x0A, 0x1A, 0x0A}; + +namespace { +// Resizing a vector can produce an exception if the allocation fails, but +// there's no real way to validate this ahead of time. So we use +// a try/catch block. +template +ErrorWithText ResizeVectorOrError(std::vector& vec, size_t newSize) +{ + try + { + vec.resize(newSize); + } + catch(...) + { + return "Allocating " + std::to_string(newSize) + " bytes of data failed."; + } + return {}; +} + +// Multiplies three values, returning false if the calculation would overflow, +// interpreting each value as 1 if it would be 0. +bool GetNumSubresources(size_t a, size_t b, size_t c, size_t& out) +{ + return checked_math::mul3(std::max(a, size_t(1)), std::max(b, size_t(1)), std::max(c, size_t(1)), out); +} +} // namespace + +ErrorWithText KTXImage::allocate(uint32_t _num_mips, uint32_t _num_layers, uint32_t _num_faces) +{ + clear(); + + num_mips = _num_mips; + num_layers_possibly_0 = _num_layers; + num_faces = _num_faces; + + size_t num_subresources = 0; + if(!GetNumSubresources(num_mips, num_layers_possibly_0, num_faces, num_subresources)) + { + return "Computing the required number of subresources overflowed a size_t!"; + } + return ResizeVectorOrError(data, num_subresources); +} + +void KTXImage::clear() +{ + data.clear(); +} + +std::vector& KTXImage::subresource(uint32_t mip, uint32_t layer, uint32_t face) +{ + const uint32_t num_mips_clamped = std::max(num_mips, 1U); + const uint32_t num_layers_clamped = std::max(num_layers_possibly_0, 1U); + if(mip >= num_mips_clamped || layer >= num_layers_clamped || face >= num_faces) + { + throw std::out_of_range("KTXImage::subresource values were out of range"); + } + + // Here's the layout for data that we use. Note that we store the lowest mips + // (mip 0) first, while the KTX format stores the highest mips first. + return data[(size_t(mip) * size_t(num_layers_clamped) + size_t(layer)) * size_t(num_faces) + size_t(face)]; +} + +VkImageType KTXImage::getImageType() const +{ + if(mip_0_width == 0) + { + return VK_IMAGE_TYPE_1D; + } + else if(mip_0_depth == 0) + { + return VK_IMAGE_TYPE_2D; + } + else + { + return VK_IMAGE_TYPE_3D; + } +} + +uint32_t KTXImage::getKTXVersion() const +{ + return read_ktx_version; +} + +// Macro for "read this variable from the istream; if it fails, return an error message" +#define READ_OR_ERROR(input, variable, error_message) \ + if(!(input).read(reinterpret_cast(&(variable)), sizeof(variable))) \ + { \ + return (error_message); \ + } + +// Macro for "If this returned an error, propagate that error" +#define UNWRAP_ERROR(expr_returning_error_with_text) \ + if(ErrorWithText unwrap_error_tmp = (expr_returning_error_with_text)) \ + { \ + return unwrap_error_tmp; \ + } + +namespace { +size_t RoundUp(size_t value, size_t multiplier) +{ + const size_t mod = value % multiplier; + if(mod == 0) + return value; + return value + (multiplier - mod); +} + +// Basic Data Format Descriptor from the Khronos Data Format, +// without sample information. +struct BasicDataFormatDescriptor +{ + uint32_t vendorId : 17; + uint32_t descriptorType : 15; + uint16_t versionNumber : 16; + uint16_t descriptorBlockSize : 16; + uint8_t colorModel : 8; + uint8_t colorPrimaries : 8; + uint8_t transferFunction : 8; + uint8_t flags : 8; + uint8_t texelBlockDimension0 : 8; + uint8_t texelBlockDimension1 : 8; + uint8_t texelBlockDimension2 : 8; + uint8_t texelBlockDimension3 : 8; + uint8_t bytesPlane0 : 8; + uint8_t bytesPlane1 : 8; + uint8_t bytesPlane2 : 8; + uint8_t bytesPlane3 : 8; + uint8_t bytesPlane4 : 8; + uint8_t bytesPlane5 : 8; + uint8_t bytesPlane6 : 8; + uint8_t bytesPlane7 : 8; +}; +static_assert(sizeof(BasicDataFormatDescriptor) == 24, "Basic data format descriptor size must match the KDF spec!"); + +struct DFSample +{ + uint16_t bitOffset; + uint8_t bitLength; + uint8_t channelType; + uint8_t samplePosition0; + uint8_t samplePosition1; + uint8_t samplePosition2; + uint8_t samplePosition3; + uint32_t lower; + uint32_t upper; +}; +static_assert(sizeof(DFSample) == 16, "Basic data format descriptor sample type size must match Khronos Data Format spec!"); + +// Interprets T as an array of uint32_ts and swaps the endianness of each element. +template +void SwapEndian32(T& data) +{ + static_assert((sizeof(T) % 4) == 0, "T must be interpretable as an array of 32-bit words."); + size_t numInts = sizeof(T) / 4; + uint32_t* reinterpretedData = reinterpret_cast(&data); + for(size_t i = 0; i < numInts; i++) + { + uint32_t value = reinterpretedData[i]; + value = ((value & 0x000000FFu) << 24) // + | ((value & 0x0000FF00u) << 8) // + | ((value & 0x00FF0000u) >> 8) // + | ((value & 0xFF000000u) >> 24); + reinterpretedData[i] = value; + } +} + +// Interprets data, an array dataSizeBytes long, as an array of elements of size +// typeSizeBytes. Then swaps the endianness of each element. +void SwapEndianGeneral(size_t dataSizeBytes, void* data, uint32_t typeSizeBytes) +{ + if(typeSizeBytes == 0 || typeSizeBytes == 1) + { + return; // Nothing to do + } + assert(dataSizeBytes % typeSizeBytes == 0); // Otherwise we'll swap all but the last element + uint8_t* dataAsBytes = reinterpret_cast(data); + const size_t typeSize64 = size_t(typeSizeBytes); + const size_t numElements = dataSizeBytes / typeSizeBytes; // e.g. 5/3 -> 1 element + const size_t numSwaps = typeSize64 / 2; // e.g. 3 bytes -> 1 swap + + for(size_t eltIdx = 0; eltIdx < numElements; eltIdx++) + { + for(size_t swapIdx = 0; swapIdx < numSwaps; swapIdx++) + { + std::swap(dataAsBytes[eltIdx * typeSize64 + swapIdx], dataAsBytes[eltIdx * typeSize64 + typeSize64 - 1 - swapIdx]); + } + } +} + +static_assert(CHAR_BIT == 8, "Things will probably go wrong in nv_ktx code with istream reads if chars aren't 8 bits."); + +ErrorWithText ReadKeyValueData(std::istream& input, + uint32_t kvdByteLength, + bool srcIsBigEndian, + std::map>& outKeyValueData) +{ + std::vector kvBlock; + UNWRAP_ERROR(ResizeVectorOrError(kvBlock, kvdByteLength)); + if(!input.read(kvBlock.data(), size_t(kvdByteLength))) + { + return "Unable to read " + std::to_string(kvdByteLength) + " bytes of KTX2 key/value data."; + } + + size_t byteIndex = 0; + while(byteIndex < kvdByteLength) + { + // Read keyAndValueByteLength + uint32_t keyAndValueByteLength = 0; + // Check to make sure we don't read out of bounds + if(byteIndex + sizeof(keyAndValueByteLength) >= kvBlock.size()) + { + return "Key/value data starting at byte " + std::to_string(byteIndex) + + "of the key/value data block did not have enough space to contain the 32-bit key/value size. Is the key/value data truncated?"; + } + memcpy(&keyAndValueByteLength, &kvBlock[byteIndex], sizeof(keyAndValueByteLength)); + if(srcIsBigEndian) + { + SwapEndian32(keyAndValueByteLength); + } + byteIndex += sizeof(keyAndValueByteLength); + + // If byteIndex + keyAndValueByteLength > the length of kvBlock, we read + // byteIndex incorrectly; we'll treat this as a non-fatal error. + if(byteIndex + keyAndValueByteLength > kvBlock.size()) + { + assert("Key/value data had byte length that was too long!"); + return {}; + } + + // Parse the key and value according to 3.11.2 "keyAndValue". + // First, find the index of the NUL character terminating the key. + size_t keyLength = 0; + while(keyLength < size_t(keyAndValueByteLength)) + { + if(kvBlock[byteIndex + keyLength] == '\0') + { + break; // Found the NUL character! + } + keyLength++; // Next character + } + + // If we somehow reached the end without finding the NUL character, this + // key is invalid - we could read it correctly, but others might not, + // and we have to copy the keys to the output anyways. + if(keyLength == size_t(keyAndValueByteLength)) + { + return "Key starting at byte " + std::to_string(byteIndex) + " of the key/value data did not have a NUL character."; + } + + // Construct the key and value from ranges. + std::string key(&kvBlock[byteIndex], keyLength); // Don't include null character + std::vector value(kvBlock.begin() + (byteIndex + keyLength + 1), kvBlock.begin() + (byteIndex + keyAndValueByteLength)); + // Handle duplicate keys gracefully by using later keys. Note that KTX + // requires that keys not be duplicated. + outKeyValueData.insert_or_assign(key, value); + + // Skip directly to the next key, including padding. + byteIndex += RoundUp(size_t(keyAndValueByteLength), 4); + } + + return {}; +} + +// Computes the size of a subresource of size `width` x `height` x `depth`, encoded +// using ASTC blocks of size `blockWidth` x `blockHeight` x `blockDepth`. Returns false +// if the calculation would overflow, and returns true and stores the result in +// `out` otherwise. +bool ASTCSize(size_t blockWidth, size_t blockHeight, size_t blockDepth, size_t width, size_t height, size_t depth, size_t& out) +{ + return checked_math::mul4(((width + blockWidth - 1) / blockWidth), // # of ASTC blocks along the x axis + ((height + blockHeight - 1) / blockHeight), // # of ASTC blocks along the y axis + ((depth + blockDepth - 1) / blockDepth), // # of ASTC blocks along the z axis + 16, // Each ASTC block size is 128 bits = 16 bytes + out); +} + +// Returns the size of a width x height x depth image of the given VkFormat. +// Returns an error if the given image sizes are strictly invalid. +ErrorWithText ExportSize(size_t width, size_t height, size_t depth, VkFormat format, size_t& outSize) +{ + static const char* overflow_error_message = + "Invalid file: One of the subresources had a size that would require more than 2^64-1 bytes of data!"; + switch(format) + { + case VK_FORMAT_R4G4_UNORM_PACK8: + case VK_FORMAT_R8_UNORM: + case VK_FORMAT_R8_SNORM: + case VK_FORMAT_R8_USCALED: + case VK_FORMAT_R8_SSCALED: + case VK_FORMAT_R8_UINT: + case VK_FORMAT_R8_SINT: + case VK_FORMAT_R8_SRGB: + case VK_FORMAT_S8_UINT: + if(!checked_math::mul4(width, height, depth, 8 / 8, outSize)) // 8 bits per pixel + return overflow_error_message; + return {}; + case VK_FORMAT_R4G4B4A4_UNORM_PACK16: + case VK_FORMAT_B4G4R4A4_UNORM_PACK16: + case VK_FORMAT_R5G6B5_UNORM_PACK16: + case VK_FORMAT_B5G6R5_UNORM_PACK16: + case VK_FORMAT_R5G5B5A1_UNORM_PACK16: + case VK_FORMAT_B5G5R5A1_UNORM_PACK16: + case VK_FORMAT_A1R5G5B5_UNORM_PACK16: + case VK_FORMAT_R8G8_UNORM: + case VK_FORMAT_R8G8_SNORM: + case VK_FORMAT_R8G8_USCALED: + case VK_FORMAT_R8G8_SSCALED: + case VK_FORMAT_R8G8_UINT: + case VK_FORMAT_R8G8_SINT: + case VK_FORMAT_R8G8_SRGB: + case VK_FORMAT_R16_UNORM: + case VK_FORMAT_R16_SNORM: + case VK_FORMAT_R16_USCALED: + case VK_FORMAT_R16_SSCALED: + case VK_FORMAT_R16_UINT: + case VK_FORMAT_R16_SINT: + case VK_FORMAT_R16_SFLOAT: + case VK_FORMAT_D16_UNORM: + case VK_FORMAT_D16_UNORM_S8_UINT: + if(!checked_math::mul4(width, height, depth, 16 / 8, outSize)) // 16 bits per pixel + return overflow_error_message; + return {}; + case VK_FORMAT_R8G8B8_UNORM: + case VK_FORMAT_R8G8B8_SNORM: + case VK_FORMAT_R8G8B8_USCALED: + case VK_FORMAT_R8G8B8_SSCALED: + case VK_FORMAT_R8G8B8_UINT: + case VK_FORMAT_R8G8B8_SINT: + case VK_FORMAT_R8G8B8_SRGB: + case VK_FORMAT_B8G8R8_UNORM: + case VK_FORMAT_B8G8R8_SNORM: + case VK_FORMAT_B8G8R8_USCALED: + case VK_FORMAT_B8G8R8_SSCALED: + case VK_FORMAT_B8G8R8_UINT: + case VK_FORMAT_B8G8R8_SINT: + case VK_FORMAT_B8G8R8_SRGB: + if(!checked_math::mul4(width, height, depth, 24 / 8, outSize)) // 24 bits per pixel + return overflow_error_message; + return {}; + case VK_FORMAT_R8G8B8A8_UNORM: + case VK_FORMAT_R8G8B8A8_SNORM: + case VK_FORMAT_R8G8B8A8_USCALED: + case VK_FORMAT_R8G8B8A8_SSCALED: + case VK_FORMAT_R8G8B8A8_UINT: + case VK_FORMAT_R8G8B8A8_SINT: + case VK_FORMAT_R8G8B8A8_SRGB: + case VK_FORMAT_B8G8R8A8_UNORM: + case VK_FORMAT_B8G8R8A8_SNORM: + case VK_FORMAT_B8G8R8A8_USCALED: + case VK_FORMAT_B8G8R8A8_SSCALED: + case VK_FORMAT_B8G8R8A8_UINT: + case VK_FORMAT_B8G8R8A8_SINT: + case VK_FORMAT_B8G8R8A8_SRGB: + case VK_FORMAT_A8B8G8R8_UNORM_PACK32: + case VK_FORMAT_A8B8G8R8_SNORM_PACK32: + case VK_FORMAT_A8B8G8R8_USCALED_PACK32: + case VK_FORMAT_A8B8G8R8_SSCALED_PACK32: + case VK_FORMAT_A8B8G8R8_UINT_PACK32: + case VK_FORMAT_A8B8G8R8_SINT_PACK32: + case VK_FORMAT_A8B8G8R8_SRGB_PACK32: + case VK_FORMAT_A2R10G10B10_UNORM_PACK32: + case VK_FORMAT_A2R10G10B10_SNORM_PACK32: + case VK_FORMAT_A2R10G10B10_USCALED_PACK32: + case VK_FORMAT_A2R10G10B10_SSCALED_PACK32: + case VK_FORMAT_A2R10G10B10_UINT_PACK32: + case VK_FORMAT_A2R10G10B10_SINT_PACK32: + case VK_FORMAT_A2B10G10R10_UNORM_PACK32: + case VK_FORMAT_A2B10G10R10_SNORM_PACK32: + case VK_FORMAT_A2B10G10R10_USCALED_PACK32: + case VK_FORMAT_A2B10G10R10_SSCALED_PACK32: + case VK_FORMAT_A2B10G10R10_UINT_PACK32: + case VK_FORMAT_A2B10G10R10_SINT_PACK32: + case VK_FORMAT_R16G16_UNORM: + case VK_FORMAT_R16G16_SNORM: + case VK_FORMAT_R16G16_USCALED: + case VK_FORMAT_R16G16_SSCALED: + case VK_FORMAT_R16G16_UINT: + case VK_FORMAT_R16G16_SINT: + case VK_FORMAT_R16G16_SFLOAT: + case VK_FORMAT_R32_UINT: + case VK_FORMAT_R32_SINT: + case VK_FORMAT_R32_SFLOAT: + case VK_FORMAT_B10G11R11_UFLOAT_PACK32: + case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: + case VK_FORMAT_X8_D24_UNORM_PACK32: + case VK_FORMAT_D32_SFLOAT: + case VK_FORMAT_D24_UNORM_S8_UINT: + if(!checked_math::mul4(width, height, depth, 32 / 8, outSize)) // 32 bits per pixel + return overflow_error_message; + return {}; + case VK_FORMAT_R16G16B16_UNORM: + case VK_FORMAT_R16G16B16_SNORM: + case VK_FORMAT_R16G16B16_USCALED: + case VK_FORMAT_R16G16B16_SSCALED: + case VK_FORMAT_R16G16B16_UINT: + case VK_FORMAT_R16G16B16_SINT: + case VK_FORMAT_R16G16B16_SFLOAT: + if(!checked_math::mul4(width, height, depth, 48 / 8, outSize)) // 48 bits per pixel + return overflow_error_message; + return {}; + case VK_FORMAT_R16G16B16A16_UNORM: + case VK_FORMAT_R16G16B16A16_SNORM: + case VK_FORMAT_R16G16B16A16_USCALED: + case VK_FORMAT_R16G16B16A16_SSCALED: + case VK_FORMAT_R16G16B16A16_UINT: + case VK_FORMAT_R16G16B16A16_SINT: + case VK_FORMAT_R16G16B16A16_SFLOAT: + case VK_FORMAT_R32G32_UINT: + case VK_FORMAT_R32G32_SINT: + case VK_FORMAT_R32G32_SFLOAT: + case VK_FORMAT_R64_UINT: + case VK_FORMAT_R64_SINT: + case VK_FORMAT_R64_SFLOAT: + // Technically 40 or 64, but we choose the latter to make earlier special cases work: + case VK_FORMAT_D32_SFLOAT_S8_UINT: + if(!checked_math::mul4(width, height, depth, 64 / 8, outSize)) // 64 bits per pixel + return overflow_error_message; + return {}; + case VK_FORMAT_R32G32B32_UINT: + case VK_FORMAT_R32G32B32_SINT: + case VK_FORMAT_R32G32B32_SFLOAT: + if(!checked_math::mul4(width, height, depth, 96 / 8, outSize)) // 96 bits per pixel + return overflow_error_message; + return {}; + case VK_FORMAT_R32G32B32A32_UINT: + case VK_FORMAT_R32G32B32A32_SINT: + case VK_FORMAT_R32G32B32A32_SFLOAT: + case VK_FORMAT_R64G64_UINT: + case VK_FORMAT_R64G64_SINT: + case VK_FORMAT_R64G64_SFLOAT: + if(!checked_math::mul4(width, height, depth, 128 / 8, outSize)) // 128 bits per pixel + return overflow_error_message; + return {}; + case VK_FORMAT_R64G64B64_UINT: + case VK_FORMAT_R64G64B64_SINT: + case VK_FORMAT_R64G64B64_SFLOAT: + if(!checked_math::mul4(width, height, depth, 196 / 8, outSize)) // 196 bits per pixel + return overflow_error_message; + return {}; + case VK_FORMAT_R64G64B64A64_UINT: + case VK_FORMAT_R64G64B64A64_SINT: + case VK_FORMAT_R64G64B64A64_SFLOAT: + if(!checked_math::mul4(width, height, depth, 256 / 8, outSize)) // 256 bits per pixel + return overflow_error_message; + return {}; + case VK_FORMAT_BC1_RGB_UNORM_BLOCK: + case VK_FORMAT_BC1_RGB_SRGB_BLOCK: + case VK_FORMAT_BC1_RGBA_UNORM_BLOCK: + case VK_FORMAT_BC1_RGBA_SRGB_BLOCK: + case VK_FORMAT_BC4_UNORM_BLOCK: + case VK_FORMAT_BC4_SNORM_BLOCK: + if(!checked_math::mul4((width + 3) / 4, (height + 3) / 4, depth, 8, outSize)) // 8 bytes per block + return overflow_error_message; + return {}; + case VK_FORMAT_BC2_UNORM_BLOCK: + case VK_FORMAT_BC2_SRGB_BLOCK: + case VK_FORMAT_BC3_UNORM_BLOCK: + case VK_FORMAT_BC3_SRGB_BLOCK: + case VK_FORMAT_BC5_UNORM_BLOCK: + case VK_FORMAT_BC5_SNORM_BLOCK: + case VK_FORMAT_BC6H_UFLOAT_BLOCK: + case VK_FORMAT_BC6H_SFLOAT_BLOCK: + case VK_FORMAT_BC7_UNORM_BLOCK: + case VK_FORMAT_BC7_SRGB_BLOCK: + if(!checked_math::mul4((width + 3) / 4, (height + 3) / 4, depth, 16, outSize)) // 16 bytes per block + return overflow_error_message; + return {}; + case VK_FORMAT_ASTC_4x4_UNORM_BLOCK: + case VK_FORMAT_ASTC_4x4_SRGB_BLOCK: + if(!ASTCSize(4, 4, 1, width, height, depth, outSize)) + return overflow_error_message; + return {}; + case VK_FORMAT_ASTC_5x4_UNORM_BLOCK: + case VK_FORMAT_ASTC_5x4_SRGB_BLOCK: + if(!ASTCSize(5, 4, 1, width, height, depth, outSize)) + return overflow_error_message; + return {}; + case VK_FORMAT_ASTC_5x5_UNORM_BLOCK: + case VK_FORMAT_ASTC_5x5_SRGB_BLOCK: + if(!ASTCSize(5, 5, 1, width, height, depth, outSize)) + return overflow_error_message; + return {}; + case VK_FORMAT_ASTC_6x5_UNORM_BLOCK: + case VK_FORMAT_ASTC_6x5_SRGB_BLOCK: + if(!ASTCSize(6, 5, 1, width, height, depth, outSize)) + return overflow_error_message; + return {}; + case VK_FORMAT_ASTC_6x6_UNORM_BLOCK: + case VK_FORMAT_ASTC_6x6_SRGB_BLOCK: + if(!ASTCSize(6, 6, 1, width, height, depth, outSize)) + return overflow_error_message; + return {}; + case VK_FORMAT_ASTC_8x5_UNORM_BLOCK: + case VK_FORMAT_ASTC_8x5_SRGB_BLOCK: + if(!ASTCSize(8, 5, 1, width, height, depth, outSize)) + return overflow_error_message; + return {}; + case VK_FORMAT_ASTC_8x6_UNORM_BLOCK: + case VK_FORMAT_ASTC_8x6_SRGB_BLOCK: + if(!ASTCSize(8, 6, 1, width, height, depth, outSize)) + return overflow_error_message; + return {}; + case VK_FORMAT_ASTC_8x8_UNORM_BLOCK: + case VK_FORMAT_ASTC_8x8_SRGB_BLOCK: + if(!ASTCSize(8, 8, 1, width, height, depth, outSize)) + return overflow_error_message; + return {}; + case VK_FORMAT_ASTC_10x5_UNORM_BLOCK: + case VK_FORMAT_ASTC_10x5_SRGB_BLOCK: + if(!ASTCSize(10, 5, 1, width, height, depth, outSize)) + return overflow_error_message; + return {}; + case VK_FORMAT_ASTC_10x6_UNORM_BLOCK: + case VK_FORMAT_ASTC_10x6_SRGB_BLOCK: + if(!ASTCSize(10, 6, 1, width, height, depth, outSize)) + return overflow_error_message; + return {}; + case VK_FORMAT_ASTC_10x8_UNORM_BLOCK: + case VK_FORMAT_ASTC_10x8_SRGB_BLOCK: + if(!ASTCSize(10, 8, 1, width, height, depth, outSize)) + return overflow_error_message; + return {}; + case VK_FORMAT_ASTC_10x10_UNORM_BLOCK: + case VK_FORMAT_ASTC_10x10_SRGB_BLOCK: + if(!ASTCSize(10, 10, 1, width, height, depth, outSize)) + return overflow_error_message; + return {}; + case VK_FORMAT_ASTC_12x10_UNORM_BLOCK: + case VK_FORMAT_ASTC_12x10_SRGB_BLOCK: + if(!ASTCSize(12, 10, 1, width, height, depth, outSize)) + return overflow_error_message; + return {}; + case VK_FORMAT_ASTC_12x12_UNORM_BLOCK: + case VK_FORMAT_ASTC_12x12_SRGB_BLOCK: + if(!ASTCSize(12, 12, 1, width, height, depth, outSize)) + return overflow_error_message; + return {}; + default: + return "Tried to find size of unrecognized VkFormat " + std::to_string(format) + "."; + } +} + +ErrorWithText ExportSizeExtended(size_t width, size_t height, size_t depth, VkFormat format, size_t& outSize, CustomExportSizeFuncPtr extra_callback) +{ + const ErrorWithText builtin_result = ExportSize(width, height, depth, format, outSize); + if(!builtin_result.has_value() || extra_callback == nullptr) + { + return builtin_result; + } + + // We didn't recognize the format using the built-in ExportSize, so try the + // provided reader. + return extra_callback(width, height, depth, format, outSize); +} + +//----------------------------------------------------------------------------- +// KTX1 READER +//----------------------------------------------------------------------------- + +// Used in the KTX1 reader to determine the default transfer function for a +// VkFormat, since KTX1 doesn't have the Data Format Descriptor. +bool IsKTX1FormatSRGBByDefault(VkFormat format) +{ + switch(format) + { + // Formats that are definitely always sRGB + case VK_FORMAT_R8_SRGB: + case VK_FORMAT_R8G8_SRGB: + case VK_FORMAT_R8G8B8_SRGB: + case VK_FORMAT_B8G8R8_SRGB: + case VK_FORMAT_R8G8B8A8_SRGB: + case VK_FORMAT_B8G8R8A8_SRGB: + case VK_FORMAT_A8B8G8R8_SRGB_PACK32: + case VK_FORMAT_BC1_RGB_SRGB_BLOCK: + case VK_FORMAT_BC1_RGBA_SRGB_BLOCK: + case VK_FORMAT_BC2_SRGB_BLOCK: + case VK_FORMAT_BC3_SRGB_BLOCK: + case VK_FORMAT_BC7_SRGB_BLOCK: + case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: + case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: + case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: + case VK_FORMAT_ASTC_4x4_SRGB_BLOCK: + case VK_FORMAT_ASTC_5x4_SRGB_BLOCK: + case VK_FORMAT_ASTC_5x5_SRGB_BLOCK: + case VK_FORMAT_ASTC_6x5_SRGB_BLOCK: + case VK_FORMAT_ASTC_6x6_SRGB_BLOCK: + case VK_FORMAT_ASTC_8x5_SRGB_BLOCK: + case VK_FORMAT_ASTC_8x6_SRGB_BLOCK: + case VK_FORMAT_ASTC_8x8_SRGB_BLOCK: + case VK_FORMAT_ASTC_10x5_SRGB_BLOCK: + case VK_FORMAT_ASTC_10x6_SRGB_BLOCK: + case VK_FORMAT_ASTC_10x8_SRGB_BLOCK: + case VK_FORMAT_ASTC_10x10_SRGB_BLOCK: + case VK_FORMAT_ASTC_12x10_SRGB_BLOCK: + case VK_FORMAT_ASTC_12x12_SRGB_BLOCK: + case VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG: + case VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG: + case VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG: + case VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG: + return true; + // Formats that are definitely always linear + case VK_FORMAT_R32G32B32A32_SFLOAT: + case VK_FORMAT_R32G32B32_SFLOAT: + case VK_FORMAT_R16G16B16A16_SFLOAT: + case VK_FORMAT_R32G32_SFLOAT: + case VK_FORMAT_R16G16_SFLOAT: + case VK_FORMAT_D32_SFLOAT: + case VK_FORMAT_R32_SFLOAT: + case VK_FORMAT_R16_SFLOAT: + case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: + case VK_FORMAT_BC6H_SFLOAT_BLOCK: + case VK_FORMAT_BC6H_UFLOAT_BLOCK: + // According to toktx, otherwise the correct choice is to interpret it as linear: + default: + return false; + } +} + +// The values from UInt32 endianness through UInt32 bytesOfKeyValueData in the KTX1 header. +struct KTX1TopLevelHeader +{ + uint32_t endianness; + uint32_t glType; + uint32_t glTypeSize; + uint32_t glFormat; + uint32_t glInternalFormat; + uint32_t glBaseInternalFormat; + uint32_t pixelWidth; + uint32_t pixelHeight; + uint32_t pixelDepth; + uint32_t numberOfArrayElements; + uint32_t numberOfFaces; + uint32_t numberOfMipmapLevels; + uint32_t bytesOfKeyValueData; +}; +} // namespace + +// Reads a KTX 1.0 file, *starting after the 12-byte identifier*. +ErrorWithText KTXImage::readFromKTX1Stream(std::istream& input, const ReadSettings& readSettings) +{ + size_t validation_input_size = 0; + if(readSettings.validate_input_size) + { + const std::streampos initial_pos = input.tellg(); + input.seekg(0, std::ios_base::end); + const std::streampos end_pos = input.tellg(); + validation_input_size = end_pos - initial_pos + 12; + input.seekg(initial_pos, std::ios_base::beg); + } + + KTX1TopLevelHeader header{}; + READ_OR_ERROR(input, header, "Failed to read KTX1 header."); + // Determine if the file needs to be swapped from big-endian to little-endian. + // (We assume the machine is little-endian as we use CUDA.) + // If this is true, we need to swap every UInt32 in the KTX1 File Structure + // as well as each element in uncompressed texture data. + bool needsSwapEndian = false; + if(header.endianness == 0x01020304u) + { + needsSwapEndian = true; + } + else if(header.endianness != 0x04030201u) + { + std::stringstream str; + str << "KXT1 endianness (0x" << std::hex << header.endianness << ") did not match either big-endian or little-endian formats."; + return str.str(); + } + + if(needsSwapEndian) + { + SwapEndian32(header); + } + + // Set the dimensions in the structure to indicate the size and type of the + // texture. Then replace some fields with 1 if they were 0 to make the rest + // of the importer less complex. + mip_0_width = header.pixelWidth; + mip_0_height = header.pixelHeight; + mip_0_depth = header.pixelDepth; + num_layers_possibly_0 = header.numberOfArrayElements; + num_faces = header.numberOfFaces; + + app_should_generate_mips = (header.numberOfMipmapLevels == 0); + if(app_should_generate_mips) + { + header.numberOfMipmapLevels = 1; + } + // Because KTX1 files store mips from largest to smallest (as opposed to KTX2), + // we can handle readSettings.mips by truncating num_mips. + if(!readSettings.mips) + { + header.numberOfMipmapLevels = 1; + } + num_mips = (readSettings.mips ? header.numberOfMipmapLevels : 1); + // Keep track of the special case where we have padding with non-array cubemap textures: + const bool isArray = (header.numberOfArrayElements != 0); + if(!isArray) + header.numberOfArrayElements = 1; + if(header.pixelDepth == 0) + header.pixelDepth = 1; + if(header.pixelHeight == 0) + header.pixelHeight = 1; + + // Validate pixel width + if(header.pixelWidth == 0) + { + return "KTX1 image had a width of 0 pixels!"; + } + // Validate number of faces + if(header.numberOfFaces == 0) + { + return "KTX1 image had no faces!"; + } + if(header.numberOfFaces > 6) + { + return "KTX1 image had too many faces!"; + } + // The maximum image dimensions are 2^32-1 by 2^32-1, so there can be at most + // 31 mips. + if(header.numberOfMipmapLevels > 31) + { + return "KTX1 image had more than 31 mips!"; + } + if(readSettings.validate_input_size) + { + size_t validation_num_subresources = 0; + if(!GetNumSubresources(num_mips, num_layers_possibly_0, num_faces, validation_num_subresources)) + { + return "Computing the number of mips times layers times faces in the file overflowed!"; + } + if(validation_num_subresources > validation_input_size) + { + return "The KTX1 input had a likely invalid header - it listed " + std::to_string(num_mips) + " mips (or 0), " + + std::to_string(num_layers_possibly_0) + " layers (or 0), and " + std::to_string(num_faces) + + " faces - but the input was only " + std::to_string(validation_input_size) + " bytes long!"; + } + if(header.bytesOfKeyValueData > validation_input_size) + { + return "The KTX1 input had an invalid header - it listed " + std::to_string(header.bytesOfKeyValueData) + + " bytes of key/value data, but the input was only " + std::to_string(validation_input_size) + " bytes long!"; + } + } + + //--------------------------------------------------------------------------- + // Read key-value data. + UNWRAP_ERROR(ReadKeyValueData(input, header.bytesOfKeyValueData, needsSwapEndian, key_value_data)); + + // KTX1 doesn't have ktxSwizzle, so: + swizzle = {KTX_SWIZZLE::R, KTX_SWIZZLE::G, KTX_SWIZZLE::B, KTX_SWIZZLE::A}; + + //--------------------------------------------------------------------------- + // Calculate formats and fields used for decompression. + + // Determine a corresponding VkFormat for the given GL format. + format = texture_formats::openGLToVulkan({header.glInternalFormat, header.glFormat, header.glType}); + if(VK_FORMAT_UNDEFINED == format) + { + return "Could not determine a corresponding Vulkan format for GL internal format " + std::to_string(header.glInternalFormat) + + ", GL format " + std::to_string(header.glFormat) + ", and GL type " + std::to_string(header.glType) + "."; + } + + // Guess if this format is sRGB. + is_srgb = IsKTX1FormatSRGBByDefault(format); + + // Always set this to false, since DXT2 and DXT4 aren't supported in + // EXT_texture_compression_s3tc. + is_premultiplied = false; + + // Allocate table of subresources. + UNWRAP_ERROR(allocate(num_mips, num_layers_possibly_0, num_faces)); + + for(uint32_t mip = 0; mip < header.numberOfMipmapLevels; mip++) + { + // Read the image size. We use this for mip padding later on, and rely on + // ExportSize for individual subresources. + uint32_t imageSize = 0; + READ_OR_ERROR(input, imageSize, "Failed to read KTX1 imageSize for mip 0."); + if(needsSwapEndian) + { + SwapEndian32(imageSize); + } + + const size_t mipWidth = std::max(1u, header.pixelWidth >> mip); + const size_t mipHeight = std::max(1u, header.pixelHeight >> mip); + const size_t mipDepth = std::max(1u, header.pixelDepth >> mip); + + // Compute the size of a face in bytes + size_t faceSizeBytes = 0; + UNWRAP_ERROR(ExportSizeExtended(mipWidth, mipHeight, mipDepth, format, faceSizeBytes, readSettings.custom_size_callback)); + // Validate it + if(readSettings.validate_input_size) + { + if(((validation_input_size / size_t(header.numberOfArrayElements)) / size_t(header.numberOfFaces)) < faceSizeBytes) + { + return "The KTX1 file said it contained " + std::to_string(header.numberOfArrayElements) + + " array elements and " + std::to_string(header.numberOfFaces) + " faces in mip " + std::to_string(mip) + + ", but the input was too short (" + std::to_string(validation_input_size) + " bytes) to contain that!"; + } + } + + for(uint32_t array_element = 0; array_element < header.numberOfArrayElements; array_element++) + { + for(uint32_t face = 0; face < header.numberOfFaces; face++) + { + // Allocate storage for the encoded face + std::vector& faceBuffer = subresource(mip, array_element, face); + ErrorWithText maybeError = ResizeVectorOrError(faceBuffer, faceSizeBytes); + if(maybeError.has_value()) + { + return "Allocating encoded data for mip " + std::to_string(mip) + " layer " + std::to_string(array_element) + + " face " + std::to_string(face) + " failed (probably out of memory)."; + } + + if(!input.read(faceBuffer.data(), faceSizeBytes)) + { + return "Reading mip " + std::to_string(mip) + " layer " + std::to_string(array_element) + " face " + + std::to_string(face) + " failed (is the file truncated)?"; + } + + // Apply endianness swapping + if(needsSwapEndian) + { + SwapEndianGeneral(faceBuffer.size(), faceBuffer.data(), header.glTypeSize); + } + + // Handle cubePadding + if((!isArray) && (header.numberOfFaces == 6)) + { + // faceSizeBytes mod 4: 0 1 2 3 + // cubePadding : 0 3 2 1 + const std::streamoff cubePaddingBytes = 3 - ((static_cast(faceSizeBytes) + 3) % 4); + input.seekg(cubePaddingBytes, std::ios_base::cur); + } + } + } + // Handle mip padding. The spec says that this is always 3 - ((imageSize + 3)%4) bytes, + // and we assume bytes are the same size as chars. + { + const std::streamoff mipPaddingBytes = 3 - ((static_cast(imageSize) + 3) % 4); + input.seekg(mipPaddingBytes, std::ios_base::cur); + } + } + + return {}; +} + + +//----------------------------------------------------------------------------- +// KTX2 READER + WRITER +//----------------------------------------------------------------------------- + +// KDF_DF_MODEL_UASTC (not KHR_DF) is only defined in the KTX2 spec at the +// moment per https://github.com/KhronosGroup/KTX-Specification/issues/119, +// and has value 166. +const uint32_t KDF_DF_MODEL_UASTC = 166; +// Similarly, these channel types are only described in the KTX2 spec at the moment. +// We include an enum for quick combination lookup. +const uint32_t KHR_DF_CHANNEL_ETC1S_RGB = 0; +const uint32_t KHR_DF_CHANNEL_ETC1S_RRR = 3; +const uint32_t KHR_DF_CHANNEL_ETC1S_GGG = 4; +const uint32_t KHR_DF_CHANNEL_ETC1S_AAA = 15; +// Describes the four valid combinations of ETC1S slices in the KTX2 +// specification. These are listed in the order they appear there. +enum class ETC1SCombination +{ + RGB, // One slice, RGB + RGBA, // Two slices, RGB + AAA + R, // One slice, RRR + RG // Two slices, RRR + GGG +}; +// Also specific to Basis ETC1S+BasisLZ - Basis includes support for texture +// array animation encoding using P-frames and I-frames, and it marks which +// frames are which using flags in its table of image descriptions. +// This is the "isPFrame" flag in the KTX2 specification. +const uint32_t KTX2_IMAGE_IS_P_FRAME = 2; + +// KTX 2 Level Index structure (Section 3.9.7 "Level Index") +struct LevelIndex +{ + uint64_t byteOffset; + uint64_t byteLength; + uint64_t uncompressedByteLength; +}; +static_assert(sizeof(LevelIndex) == 3 * sizeof(uint64_t), "LevelIndex size must match KTX2 spec!"); + +#ifdef NVP_SUPPORTS_ZSTD +// A Zstandard decompression context that is automatically freed when it goes out of scope. +struct ScopedZstdDContext +{ + ScopedZstdDContext() {} + ~ScopedZstdDContext() { Free(); } + void Init() + { + Free(); + pCtx = ZSTD_createDCtx(); + } + void Free() + { + if(pCtx != nullptr) + { + ZSTD_freeDCtx(pCtx); + pCtx = nullptr; + } + } + ZSTD_DCtx* pCtx = nullptr; +}; + +// A Zstandard compression context that is automatically freed when it goes out of scope. +struct ScopedZstdCContext +{ + ScopedZstdCContext() {} + ~ScopedZstdCContext() { Free(); } + void Init() + { + Free(); + pCtx = ZSTD_createCCtx(); + } + void Free() + { + if(pCtx != nullptr) + { + ZSTD_freeCCtx(pCtx); + pCtx = nullptr; + } + } + ZSTD_CCtx* pCtx = nullptr; +}; +#endif + +#ifdef NVP_SUPPORTS_GZLIB +// A Zlib inflation stream that is automatically deinitialized when it goes out of scope. +struct ScopedZlibDStream +{ + ScopedZlibDStream() {} + ~ScopedZlibDStream() { Free(); } + int Init() + { + Free(); + stream.zalloc = Z_NULL; + stream.zfree = Z_NULL; + stream.opaque = Z_NULL; + stream.avail_in = 0; + stream.next_in = Z_NULL; + return inflateInit(&stream); + } + void Free() { inflateEnd(&stream); } + z_stream stream{}; +}; +#endif + +#ifdef NVP_SUPPORTS_BASISU + +// Stores data per-image that is required to transcode a BasisLZ+ETC1S image. +struct BasisLZDecompressionObjects +{ + // Stores and knows how to decode the BasisLZ + ETC1S stream + basist::basisu_lowlevel_etc1s_transcoder* etc1sTranscoder = nullptr; + // Additional information from the global data block not included in the transcoder + std::vector etc1sImageDescs; + basist::ktx2_transcoder_state ktx2TranscoderState; + + ~BasisLZDecompressionObjects() + { + if(etc1sTranscoder) + { + delete etc1sTranscoder; + etc1sTranscoder = nullptr; + } + } +}; + +// Basis Universal makes use of some global data, and prints developer error +// messages if we attempt to initialize this more than once. +// This Meyers singleton keeps track of said global data. +struct BasisUSingleton +{ + static BasisUSingleton& GetInstance() + { + static BasisUSingleton s; + return s; + } + + // No copying + BasisUSingleton(const BasisUSingleton&) = delete; + BasisUSingleton& operator=(const BasisUSingleton&) = delete; + + void TranscodeUASTCToBC7OrASTC44(char* output, const char* inData, size_t width, size_t height, size_t depth, bool to_astc) + { + if(!Initialize()) + return; + + const basist::uastc_block* buf = reinterpret_cast(inData); + const size_t numBlocksX = (width + 3) / 4; + const size_t numBlocksY = (height + 3) / 4; + const size_t numBlocksZ = (depth + 3) / 4; + const size_t numBlocks = numBlocksX * numBlocksY * numBlocksZ; + if(numBlocks > INT64_MAX) + return; // Won't fit in an OpenMP range + + const int64_t numBlocksI = static_cast(numBlocks); + if(to_astc) + { +#if defined(_OPENMP) +#pragma omp parallel for +#endif + for(int64_t blockIdx = 0; blockIdx < numBlocksI; blockIdx++) + { + const basist::uastc_block& block = buf[blockIdx]; + char* dst = output + size_t(blockIdx) * 16; // 16 bytes per ASTC block + basist::transcode_uastc_to_astc(block, dst); + } + } + else + { + // To BC7 +#if defined(_OPENMP) +#pragma omp parallel for +#endif + for(int64_t blockIdx = 0; blockIdx < numBlocksI; blockIdx++) + { + const basist::uastc_block& block = buf[blockIdx]; + char* dst = output + size_t(blockIdx) * 16; // 16 bytes per BC7 block + basist::transcode_uastc_to_bc7(block, dst); + } + } + } + + ErrorWithText PrepareBasisLZObjects(BasisLZDecompressionObjects& outObjects, + const std::vector& ktxSGD, + const uint32_t numMips, + const uint32_t numLayers, + const uint32_t numFaces) + { + if(!Initialize()) + { + return "Initializing BasisU failed!"; + } + // For reference, see Basis Universal's ktx2_transcoder::decompress_etc1s_global_data(). + + // Compute the image count, erroring if we would overflow: + uint32_t imageCount = numMips; + { + if(numMips == 0 || numLayers == 0 || numFaces == 0) + { + return "The number of mips, layers, or faces was 0!"; + } + if(imageCount >= (UINT_MAX / numLayers)) + { + return "The number of images was over 2^32-1!"; + } + imageCount *= numLayers; + if(imageCount >= (UINT_MAX / numFaces)) + { + return "The number of images was over 2^32-1!"; + } + imageCount *= numFaces; + } + + if(ktxSGD.size() < sizeof(basist::ktx2_etc1s_global_data_header)) + { + return "The data included ETC1S+BasisLZ compression, but the length of the supercompression global data was too " + "short to contain the required information!"; + } + + size_t offsetInSGD = 0; + + basist::ktx2_etc1s_global_data_header etc1sHeader; + memcpy(&etc1sHeader, ktxSGD.data() + offsetInSGD, sizeof(etc1sHeader)); + offsetInSGD += sizeof(etc1sHeader); + + // Check the ETC1S header. + if((!etc1sHeader.m_endpoints_byte_length) || (!etc1sHeader.m_selectors_byte_length) || (!etc1sHeader.m_tables_byte_length)) + { + return "The data included ETC1S+BasisLZ compression, but the supercompression global data had invalid byte " + "length " + "properties!"; + } + + if((!etc1sHeader.m_endpoint_count) || (!etc1sHeader.m_selector_count)) + { + return "The data included ETC1S+BasisLZ compression, but the endpoint or selector count is 0, which is invalid!"; + } + + if((sizeof(basist::ktx2_etc1s_global_data_header) + sizeof(basist::ktx2_etc1s_image_desc) * imageCount + etc1sHeader.m_endpoints_byte_length + + etc1sHeader.m_selectors_byte_length + etc1sHeader.m_tables_byte_length + etc1sHeader.m_extended_byte_length) + > ktxSGD.size()) + { + return "The data included ETC1S+BasisLZ compression, but the supercompression global data was invalid: it was " + "too " + "small to contain the data its header said it contains!"; + } + + // Read the image descriptions + UNWRAP_ERROR(ResizeVectorOrError(outObjects.etc1sImageDescs, imageCount)); + memcpy(outObjects.etc1sImageDescs.data(), ktxSGD.data() + offsetInSGD, sizeof(basist::ktx2_etc1s_image_desc) * imageCount); + offsetInSGD += sizeof(basist::ktx2_etc1s_image_desc) * imageCount; + + // We'll verify that slice byte lengths are nonzero later. + + // Initialize the ETC1S transcoder. + if(outObjects.etc1sTranscoder) + delete outObjects.etc1sTranscoder; + outObjects.etc1sTranscoder = new basist::basisu_lowlevel_etc1s_transcoder(); + outObjects.etc1sTranscoder->clear(); + + // Decode tables and palettes. + const uint8_t* endpointData = ktxSGD.data() + offsetInSGD; + const uint8_t* selectorData = endpointData + uint32_t(etc1sHeader.m_endpoints_byte_length); + const uint8_t* tablesData = selectorData + uint32_t(etc1sHeader.m_selectors_byte_length); + + if(!outObjects.etc1sTranscoder->decode_tables(tablesData, etc1sHeader.m_tables_byte_length)) + { + return "Failed to decode tables from the BasisLZ supercompression data"; + } + + if(!outObjects.etc1sTranscoder->decode_palettes(etc1sHeader.m_endpoint_count, endpointData, etc1sHeader.m_endpoints_byte_length, // + etc1sHeader.m_selector_count, selectorData, etc1sHeader.m_selectors_byte_length)) + { + return "Failed to decode palettes from the BasisLZ supercompression data"; + } + + outObjects.ktx2TranscoderState.clear(); + + return {}; + } + + // Attempts to initialize the Basis encoder and decoder, and returns true if that + // succeeded or if it was already initialized (this can be called + // multiple times) + bool Initialize() + { + if(!m_initialized.load()) + { + std::lock_guard lock(m_modificationMutex); + basist::basisu_transcoder_init(); + basisu::basisu_encoder_init(); + m_initialized.store(true); + } + return true; + } + +private: + BasisUSingleton(){}; + // Frees objects if loaded + ~BasisUSingleton() + { + std::lock_guard lock(m_modificationMutex); + m_initialized.store(false); + } + +private: + std::mutex m_modificationMutex; + std::atomic m_initialized = false; +}; +#endif + +#pragma pack(push, 1) +struct KTX2TopLevelHeader +{ + VkFormat vkFormat; + uint32_t typeSize; + uint32_t pixelWidth; + uint32_t pixelHeight; + uint32_t pixelDepth; + uint32_t layerCount; // Num array elements + uint32_t faceCount; + uint32_t levelCount; // Num mips + uint32_t supercompressionScheme; + + // Index (1) + uint32_t dfdByteOffset; + uint32_t dfdByteLength; + uint32_t kvdByteOffset; + uint32_t kvdByteLength; + uint64_t sgdByteOffset; + uint64_t sgdByteLength; +}; +#pragma pack(pop) + +static_assert(sizeof(VkFormat) == sizeof(uint32_t), "VkFormat size must match KTX2 spec!"); +static_assert(sizeof(KTX2TopLevelHeader) == 68, "KTX2 top-level header size must match spec! Padding issue?"); + +// Reads a KTX 2.0 file, *starting after the 12-byte identifier*. +ErrorWithText KTXImage::readFromKTX2Stream(std::istream& input, const ReadSettings& readSettings) +{ + // Get the position of the start of the file in the stream so that we can add + // padding correctly later. + const std::streampos start_pos = input.tellg() - std::streampos(12); // Since we start after the identifier + size_t validation_input_size = 0; + if(readSettings.validate_input_size) + { + const std::streampos initial_pos = input.tellg(); + input.seekg(0, std::ios_base::end); + const std::streampos end_pos = input.tellg(); + validation_input_size = end_pos - initial_pos + 12; + input.seekg(initial_pos, std::ios_base::beg); + } + + //--------------------------------------------------------------------------- + // Read sections 0 and 1 of the file structure. + KTX2TopLevelHeader header{}; + READ_OR_ERROR(input, header, "Failed to read KTX2 header and section 1."); + + // Copy the dimensions into the structure so that we can determine the + // texture type later. + format = header.vkFormat; // This is the inflated VkFormat; we may swap this out during supercompression due to transcoding. + mip_0_width = header.pixelWidth; + mip_0_height = header.pixelHeight; + mip_0_depth = header.pixelDepth; + num_layers_possibly_0 = header.layerCount; + // num_faces cannot be 0, on the other hand, so we set it below! + + // If the image width is 0, we can't read it (and the file is invalid). + if(header.pixelWidth == 0) + { + return "KTX2 image width was 0 (i.e. the file contains no pixels)."; + } + + // These dimensions are 0 only to indicate the type of the texture + // (see section 4.1). To make the rest of the reader simpler and to avoid + // errors later on, we can change each of these to 1 if they're 0. + if(header.pixelHeight == 0) + header.pixelHeight = 1; + if(header.pixelDepth == 0) + header.pixelDepth = 1; + if(header.layerCount == 0) + header.layerCount = 1; + if(header.faceCount == 0) + header.faceCount = 1; + // KTX files also only use levelCount == 0 to indicate that loaders should + // generate other levels if needed (section 3.7 "levelCount"). Since the user + // ultimately controls this and we always only load the first mip, we change + // a 0 to a 1 here as well. + // We have a special case where we need max(1, the original number of levels) + // for Basis ETC1S unpacking. + const uint32_t original_num_mips_max_1 = std::max(1u, header.levelCount); + app_should_generate_mips = (header.levelCount == 0); + if(app_should_generate_mips) + { + header.levelCount = 1; + } + num_mips = (readSettings.mips ? static_cast(header.levelCount) : 1); + + num_faces = header.faceCount; + + // Validate the data format descriptor byte length. KDF 1.3 assumes the Data + // Format Descriptor works as a series of 32-bit words, and there's language + // in the KTX2 spec that reinforces this (although it may not quite match + // the Basic Structure). + if((header.dfdByteLength % 4) != 0) + { + return "KTX2 Data Format Descriptor byte length was not a multiple of 4, so is not valid."; + } + + // Validate the level count because we allocate memory based off it. It can't + // be larger than 31 - if it were, then pixelWidth and pixelHeight wouldn't + // fit in UInt32 types. + if(original_num_mips_max_1 > 31) + { + std::stringstream str; + str << "KTX2 levelCount was too large (" << original_num_mips_max_1 << ") - the " + << "maximum number of mips possible in a KTX2 file is 31."; + return str.str(); + } + if(readSettings.validate_input_size) + { + size_t validation_num_subresources = 0; + if(!GetNumSubresources(original_num_mips_max_1, num_layers_possibly_0, num_faces, validation_num_subresources)) + { + return "Computing the number of mips times layers times faces in the file overflowed!"; + } + if(validation_num_subresources > validation_input_size) + { + return "The KTX1 input had a likely invalid header - it listed " + std::to_string(original_num_mips_max_1) + + " mips (or 0), " + std::to_string(num_layers_possibly_0) + " layers (or 0), and " + std::to_string(num_faces) + + " faces - but the input was only " + std::to_string(validation_input_size) + " bytes long!"; + } + if(header.dfdByteLength > validation_input_size) + { + return "The KTX2 input had an invalid header - it said its Data Format Descriptor was " + std::to_string(header.dfdByteLength) + + " bytes long, but the input was only " + std::to_string(validation_input_size) + " bytes long!"; + } + if(header.kvdByteLength > validation_input_size) + { + return "The KTX2 input had an invalid header - it listed " + std::to_string(header.kvdByteLength) + + " bytes of key/value data, but the input was only " + std::to_string(validation_input_size) + " bytes long!"; + } + } + + //--------------------------------------------------------------------------- + // Load the level indices (section 2) + std::vector levelIndices(original_num_mips_max_1); + if(!input.read(reinterpret_cast(levelIndices.data()), sizeof(LevelIndex) * original_num_mips_max_1)) + { + return "Unable to read Level Index from KTX2 file."; + } + + // Check the size of the level indices against the developer-supplied limits + for(size_t i = 0; i < levelIndices.size(); i++) + { + if(levelIndices[i].uncompressedByteLength > readSettings.max_resource_size_in_bytes) + { + return "Mip level " + std::to_string(i) + "'s uncompressedByteLength (" + + std::to_string(levelIndices[i].uncompressedByteLength) + + ") was larger than the max image size in bytes per mip specified in " + "the KTX reader's ReadSettings (" + + std::to_string(readSettings.max_resource_size_in_bytes) + + "). This file is either invalid, or if this size is intended, " + "ReadSettings::max_resource_size_in_bytes should be set to a larger value."; + } + } + + //--------------------------------------------------------------------------- + // Load the Data Format Descriptor. We read this as a uint32_t array and then + // interpret it later. + // We also start counting the number of bytes read here so that we can handle + // the align(8) sgdPadding correctly. + std::vector dfd; + UNWRAP_ERROR(ResizeVectorOrError(dfd, header.dfdByteLength / 4)); + if(!input.read(reinterpret_cast(dfd.data()), header.dfdByteLength)) + { + return "Unable to read Data Format Descriptor from KTX2 file."; + } + + // Get some information from the Basic Data Format Descriptor. + uint32_t dfdTotalSize = 0; + BasicDataFormatDescriptor basicDFD{}; + std::vector dfdSamples; + bool basicDFDExists = false; + if(header.dfdByteLength >= sizeof(dfdTotalSize) + sizeof(basicDFD)) + { + dfdTotalSize = dfd[0]; + if(dfdTotalSize != header.dfdByteLength) + { + return "KTX2 Data Format Descriptor was invalid (data format descriptor's dfdTotalSize didn't match the index's " + "dfdByteLength)"; + } + + memcpy(&basicDFD, &dfd[1], sizeof(BasicDataFormatDescriptor)); + basicDFDExists = true; + + // Attempt to read the sample data from the Data Format Descriptor. + if(size_t(basicDFD.descriptorBlockSize) + sizeof(dfdTotalSize) > header.dfdByteLength) + { + return "KTX2 Data Format Descriptor was invalid (the basic data format descriptor descriptorBlockSize was " + + std::to_string(basicDFD.descriptorBlockSize) + + " - that plus 4 bytes for totalSize was larger than the length of the whole data format descriptor, " + + std::to_string(dfdTotalSize) + ")"; + } + if(size_t(basicDFD.descriptorBlockSize) < sizeof(BasicDataFormatDescriptor)) + { + return "KTX2 Data Format Descriptor was invalid (the basic data format descriptor descriptorBlockSize was " + + std::to_string(basicDFD.descriptorBlockSize) + ", which was shorter than the size of the basic DFD itself, " + + std::to_string(sizeof(BasicDataFormatDescriptor)) + ")"; + } + + const size_t numDFDSamples = (size_t(basicDFD.descriptorBlockSize) - sizeof(BasicDataFormatDescriptor)) / sizeof(DFSample); + UNWRAP_ERROR(ResizeVectorOrError(dfdSamples, numDFDSamples)); + // If numDFDSamples is 0, dfdSamples.data() can be nullptr, and passing nullptr to memcpy() is undefined behavior. + if(numDFDSamples != 0) + { + memcpy(dfdSamples.data(), reinterpret_cast(dfd.data()) + sizeof(dfdTotalSize) + sizeof(BasicDataFormatDescriptor), + numDFDSamples * sizeof(DFSample)); + } + } + + + uint32_t khrDfPrimaries = KHR_DF_PRIMARIES_SRGB; + is_premultiplied = false; + is_srgb = true; + size_t basisETC1SNumSlices = 1; // Basis ETC1S can have 1 or two slices (which occurs in RGBA and R+G) + ETC1SCombination basisETC1SCombo{}; +#ifdef NVP_SUPPORTS_BASISU + basist::transcoder_texture_format basisDstFmt = basist::transcoder_texture_format::cTFBC7_RGBA; // Same as the inflated VkFormat but in an enum Basis uses +#endif + if(basicDFDExists) + { + if((basicDFD.flags & KHR_DF_FLAG_ALPHA_PREMULTIPLIED) != 0) + { + is_premultiplied = true; + } + + if(basicDFD.transferFunction == KHR_DF_TRANSFER_SRGB) + { + is_srgb = true; + } + else if(basicDFD.transferFunction == KHR_DF_TRANSFER_LINEAR) + { + is_srgb = false; + } + else + { + return "KTX2 Data Format Descriptor had an unhandled transferFunction (" + std::to_string(basicDFD.transferFunction) + ")"; + } + + if(header.vkFormat == VK_FORMAT_UNDEFINED) + { + if(basicDFD.colorModel == KDF_DF_MODEL_UASTC) + { +#ifdef NVP_SUPPORTS_BASISU + input_supercompression = InputSupercompression::eBasisUASTC; + if(readSettings.device_supports_astc) + { + // Prefer ASTC, since then transcoding is lossless: + format = is_srgb ? VK_FORMAT_ASTC_4x4_SRGB_BLOCK : VK_FORMAT_ASTC_4x4_UNORM_BLOCK; + } + else + { + // Otherwise, BC7 is preferred: + format = is_srgb ? VK_FORMAT_BC7_SRGB_BLOCK : VK_FORMAT_BC7_UNORM_BLOCK; + } +#else + return "KTX2 color model was Basis UASTC, but NVP_SUPPORTS_BASISU was not defined."; +#endif + } + else if(basicDFD.colorModel == KHR_DF_MODEL_ETC1S) + { +#ifdef NVP_SUPPORTS_BASISU + input_supercompression = InputSupercompression::eBasisETC1S; + // There are four ETC1S channel possibilities. The final format is + // BC4 for RRR, BC5 for RRR+GGG, and BC7 for RGB and RGB+AAA. + basisETC1SNumSlices = dfdSamples.size(); + if(dfdSamples.size() == 1) + { + // Must be RRR or RGB + if(dfdSamples[0].channelType == KHR_DF_CHANNEL_ETC1S_RRR) + { + basisETC1SCombo = ETC1SCombination::R; + basisDstFmt = basist::transcoder_texture_format::cTFBC4; + format = VK_FORMAT_BC4_UNORM_BLOCK; + } + else if(dfdSamples[0].channelType == KHR_DF_CHANNEL_ETC1S_RGB) + { + basisETC1SCombo = ETC1SCombination::RGB; + basisDstFmt = basist::transcoder_texture_format::cTFBC7_RGBA; + format = is_srgb ? VK_FORMAT_BC7_SRGB_BLOCK : VK_FORMAT_BC7_UNORM_BLOCK; + } + else + { + return "KTX2 color model was Basis ETC1S, but there was one slice of an unknown channel type (" + + std::to_string(dfdSamples[0].channelType) + ")"; + } + } + else if(dfdSamples.size() == 2) + { + // Must be RRR+GGG or RGB+AAA; we disallow listing these channels + // in a different order. + if(dfdSamples[0].channelType == KHR_DF_CHANNEL_ETC1S_RRR && dfdSamples[1].channelType == KHR_DF_CHANNEL_ETC1S_GGG) + { + basisETC1SCombo = ETC1SCombination::RG; + basisDstFmt = basist::transcoder_texture_format::cTFBC5; + format = VK_FORMAT_BC5_UNORM_BLOCK; + } + else if(dfdSamples[0].channelType == KHR_DF_CHANNEL_ETC1S_RGB && dfdSamples[1].channelType == KHR_DF_CHANNEL_ETC1S_AAA) + { + basisETC1SCombo = ETC1SCombination::RGBA; + basisDstFmt = basist::transcoder_texture_format::cTFBC7_RGBA; + format = is_srgb ? VK_FORMAT_BC7_SRGB_BLOCK : VK_FORMAT_BC7_UNORM_BLOCK; + } + else + { + return "KTX2 color model was Basis ETC1S and there were two slices, but the channel types (" + + std::to_string(dfdSamples[0].channelType) + " and " + std::to_string(dfdSamples[1].channelType) + " were unknown"; + } + } + else + { + return "KTX2 color model was Basis ETC1S, but there were an unusual number of slices (" + + std::to_string(dfdSamples.size()) + ", should be 1 or 2)"; + } +#else + return "KTX2 color model was Basis ETC1S, but NVP_SUPPORTS_BASISU was not defined."; +#endif + } + else + { + return "KTX2 VkFormat was VK_FORMAT_UNDEFINED, but the Data Format Descriptor block had unrecognized " + "colorModel number " + + std::to_string(basicDFD.colorModel) + "."; + } + } + } + + // Perform additional validation to rule out invalid Basis+format+supercompression + // combinations. Not doing these checks can lead to surprising behavior! + // Basis ETC1S must only appear with supercompression mode 1, and vice versa. + if((input_supercompression == InputSupercompression::eBasisETC1S) != (header.supercompressionScheme == 1)) + { + return "KTX2 file was invalid - the Basis ETC1S flag didn't match whether supercompression scheme 1 (BasisLZ) was used."; + } + + //--------------------------------------------------------------------------- + // Read section 4, key/value data. To do this, we can read kvdByteLength + // bytes, then extract keys and values from that. + UNWRAP_ERROR(ReadKeyValueData(input, header.kvdByteLength, false, key_value_data)); + + // Parse the ktxSwizzle value if it exists. + { + swizzle = {KTX_SWIZZLE::R, KTX_SWIZZLE::G, KTX_SWIZZLE::B, KTX_SWIZZLE::A}; + const auto kvpIt = key_value_data.find("KTXswizzle"); + if(kvpIt != key_value_data.end()) + { + // Read up to 4 characters (slightly less constrained than the spec) + const std::vector value = kvpIt->second; + // Value should end with a NULL character, but if it doesn't that's OK + const size_t charsToRead = std::min(size_t(4), value.size()); + for(size_t i = 0; i < charsToRead; i++) + { + switch(value[i]) + { + case 'r': + swizzle[i] = KTX_SWIZZLE::R; + break; + case 'g': + swizzle[i] = KTX_SWIZZLE::G; + break; + case 'b': + swizzle[i] = KTX_SWIZZLE::B; + break; + case 'a': + swizzle[i] = KTX_SWIZZLE::A; + break; + case '0': + swizzle[i] = KTX_SWIZZLE::ZERO; + break; + case '1': + swizzle[i] = KTX_SWIZZLE::ONE; + break; + default: + break; + } + } + } + } + + //--------------------------------------------------------------------------- + // The align(8) sgdPadding. + if(header.sgdByteLength > 0) + { + std::streampos bytesReadMod8 = ((input.tellg() - start_pos) % 8); + if(bytesReadMod8 > 0) + { + input.seekg(bytesReadMod8, std::ios::cur); + } + } + + // Section 6, supercompression global data. + // First check the sgdByteLength because we allocate memory based off it. + // Values that are really large are allowed by the KTX2 spec, but someone could + // use this to cause an out-of-memory error. + if(header.sgdByteLength > readSettings.max_resource_size_in_bytes) + { + return "Supercompression global data length (sgdByteLength) was over the maximum size specified in the " + "ReadSettings object! The file is either invalid, or if this is intentional, " + "ReadSettings::max_resource_size_in_bytes should be set to a larger value."; + } + std::vector supercompressionGlobalData; + UNWRAP_ERROR(ResizeVectorOrError(supercompressionGlobalData, header.sgdByteLength)); + if(header.sgdByteLength > 0) + { + if(!input.read(reinterpret_cast(supercompressionGlobalData.data()), header.sgdByteLength)) + { + return "Reading supercompressionGlobalData failed."; + } + } + +// Initialize supercompression +#ifdef NVP_SUPPORTS_ZSTD + ScopedZstdDContext zstdDCtx; +#endif +#ifdef NVP_SUPPORTS_BASISU + BasisLZDecompressionObjects basisLZDCtx; + // Basis ETC1S supports a sort of video format, where there are I-frames + // and P-frames and frames correspond to array elements. The Basis code + // currently allows this if there's a KTXanimData key, or if there are + // P-frames indicated in the supercompression image descriptions. + // We diverge slightly from Basis here and require videos to be 2D; Basis + // technically allows cubemap arrays with KTXanimData set to be interpreted + // as videos, I think. + bool isVideo = false; +#endif + if(header.supercompressionScheme == 1) + { +#ifdef NVP_SUPPORTS_BASISU + // Initialize supercompression global data + UNWRAP_ERROR(BasisUSingleton::GetInstance().PrepareBasisLZObjects(basisLZDCtx, supercompressionGlobalData, original_num_mips_max_1, + std::max(1u, num_layers_possibly_0), num_faces)); + // Video criterion; don't permit 1-frame videos following Basis here + if(num_faces == 1 && num_layers_possibly_0 > 1) + { + isVideo = (key_value_data.find("KTXanimData") != key_value_data.end()); + if(!isVideo) + { + for(const basist::ktx2_etc1s_image_desc& id : basisLZDCtx.etc1sImageDescs) + { + if(id.m_image_flags & KTX2_IMAGE_IS_P_FRAME) + { + isVideo = true; + break; + } + } + } + } + + // Check validity of slice sizes + for(const basist::ktx2_etc1s_image_desc& id : basisLZDCtx.etc1sImageDescs) + { + if(id.m_rgb_slice_byte_length == 0) + { + return "KTX2 stream was incorrectly formatted: a BasisLZ+ETC1S RGB slice had byte length 0."; + } + if((basisETC1SNumSlices == 2) && (id.m_alpha_slice_byte_length == 0)) + { + return "KTX2 stream was incorrectly formatted: a BasisLZ+ETC1S alpha slice had byte length 0."; + } + } +#else + return "KTX2 header specified BasisLZ supercompression, but NVP_SUPPORTS_BASISU was not defined."; +#endif + } + else if(header.supercompressionScheme == 2) + { + // Set up Zstandard +#ifdef NVP_SUPPORTS_ZSTD + zstdDCtx.Init(); + if(zstdDCtx.pCtx == nullptr) + { + return "Initializing Zstandard context failed."; + } +#else + return "KTX2 stream uses Zstandard supercompression, but nv_ktx was built without Zstd."; +#endif + } + else if(header.supercompressionScheme == 3) + { +// Nothing to do for Zlib, but check to ensure it's supported +#ifndef NVP_SUPPORTS_GZLIB + return "KTX2 stream uses Zlib supercompression, but nv_ktx was built without Zlib."; +#endif + } + else if(header.supercompressionScheme > 3) + { + return "Does not know about supercompression scheme " + std::to_string(header.supercompressionScheme) + "."; + } + + //--------------------------------------------------------------------------- + // Section 7, Mip Level Array. + // Read, inflate, and decompress each image in turn. + // + // For each mip: + // If uncompressed: + // Copy each subresource + // Else if Zstd: + // Zstd decompress the mip data + // Copy each subresource + // Else if Zlib: + // Zlib decompress the mip data + // Copy each subresource + // Else if Basis ETC1S+BasisLZ: + // BasisLZ decompress the mip data to 1 or 2 ETC1S slices. + // For each subresource + // Transcode it from ETC1S to the inflated VkFormat + // + // Then: if UASTC: + // For each subresource + // Transcode it from UASTC to the inflated VkFormat + + // First initialize the output: + UNWRAP_ERROR(allocate(num_mips, num_layers_possibly_0, num_faces)); + // Temporary buffers used for supercompressed data. + std::vector supercompressedData; + std::vector inflatedData; + // Traverse mips in reverse order following the spec + for(int mip = num_mips - 1; mip >= 0; mip--) + { + // Seek to the start of that mip's data and read it. Note that this skips + // over mipPadding. + const LevelIndex& levelIndex = levelIndices[mip]; + if(!input.seekg(levelIndex.byteOffset + start_pos, std::ios::beg)) + { + return "Failed to seek to KTX2 mip " + std::to_string(mip) + " data!"; + } + + const size_t mipWidth = std::max(1u, header.pixelWidth >> mip); + const size_t mipHeight = std::max(1u, header.pixelHeight >> mip); + const size_t mipDepth = std::max(1u, header.pixelDepth >> mip); + + // The size of each face in the inflated vkFormat, after inflation. + size_t inflatedFaceSize = 0; + if(header.vkFormat == VK_FORMAT_UNDEFINED) + { + // Check for the Basis UASTC and Universal cases. I don't know if ETC1S + // or UASTC supports depth. + if(input_supercompression == InputSupercompression::eBasisUASTC) + { + if(!checked_math::mul4((mipWidth + 3) / 4, (mipHeight + 3) / 4, mipDepth, 16, inflatedFaceSize)) // 16 bytes per 4x4 block + return "Invalid KTX2 file: A subresource had size " + std::to_string(mipWidth) + " x " + std::to_string(mipHeight) + + " x " + std::to_string(mipDepth) + ", which would require more than 2^64 - 1 bytes to store decompressed."; + } + else if(input_supercompression == InputSupercompression::eBasisETC1S) + { + if(!checked_math::mul5((mipWidth + 3) / 4, (mipHeight + 3) / 4, mipDepth, basisETC1SNumSlices, 8, inflatedFaceSize)) // 8 bytes per 4x4 block per slice + return "Invalid KTX2 file: A subresource had size " + std::to_string(mipWidth) + " x " + std::to_string(mipHeight) + + " x " + std::to_string(mipDepth) + " with " + std::to_string(basisETC1SNumSlices) + + " slices, which would require more than 2^64 - 1 bytes to store decompressed."; + } + else + { + return "Tried to find the size of an undefined VkFormat, with an unknown Khronos Data Format color model. Is " + "this a new texture format?"; + } + } + else + { + UNWRAP_ERROR(ExportSizeExtended(mipWidth, mipHeight, mipDepth, header.vkFormat, inflatedFaceSize, readSettings.custom_size_callback)); + } + + // The size of each face in the final vkFormat, after inflation and transcoding. + size_t finalFaceSize = 0; + UNWRAP_ERROR(ExportSizeExtended(mipWidth, mipHeight, mipDepth, format, finalFaceSize, readSettings.custom_size_callback)); + + if(finalFaceSize > readSettings.max_resource_size_in_bytes) + { + return "Subresource was too large! The KTX2 file said that each mip 0 face had dimensions " + + std::to_string(mipWidth) + " x " + std::to_string(mipHeight) + " x " + std::to_string(mipDepth) + + " with format " + std::to_string(format) + ". This has a computed size of " + + std::to_string(finalFaceSize) + " bytes, which is larger than the limit of max_resource_size_in_bytes = " + + std::to_string(readSettings.max_resource_size_in_bytes) + " bytes."; + } + + // Validate sizes + if(readSettings.validate_input_size) + { + // Level-wide constraint on read data + if(levelIndex.byteLength > validation_input_size) + { + return "The KTX2 file said that level " + std::to_string(mip) + " contained " + std::to_string(levelIndex.byteLength) + + " bytes of supercompressed data, but the file was only " + std::to_string(validation_input_size) + " bytes long!"; + } + + if(header.supercompressionScheme == 0) + { + // Level-wide constraint on read data + if(levelIndex.uncompressedByteLength > validation_input_size) + { + return "The KTX2 file said no supercompression was used and that level " + std::to_string(mip) + " contained " + + std::to_string(levelIndex.uncompressedByteLength) + " bytes of data, but the file was only " + + std::to_string(validation_input_size) + " bytes long!"; + } + + // Per-face more specific constraint, making use of how non-supercompressed + // UASTC and ASTC (the transcoded-to format) are both 128 bits/block. + if((validation_input_size / size_t(header.layerCount)) / size_t(header.faceCount) < finalFaceSize) + { + return "The KTX2 file said it contained " + std::to_string(header.layerCount) + " array elements and " + + std::to_string(header.faceCount) + " faces in mip " + std::to_string(mip) + + ", but the input was too short (" + std::to_string(validation_input_size) + " bytes) to contain that!"; + } + } + } + + // FAST PATH - if no supercompression and no UASTC, we can read directly: + if((header.supercompressionScheme == 0) && (input_supercompression != InputSupercompression::eBasisUASTC)) + { + for(uint32_t layer = 0; layer < header.layerCount; layer++) + { + for(uint32_t face = 0; face < header.faceCount; face++) + { + std::vector& subresource_data = subresource(mip, layer, face); + UNWRAP_ERROR(ResizeVectorOrError(subresource_data, finalFaceSize)); + if(!input.read(subresource_data.data(), finalFaceSize)) + { + return "Reading data for mip " + std::to_string(mip) + " layer " + std::to_string(layer) + " face " + + std::to_string(face) + " from the stream failed. Is the stream truncated?"; + } + } + } + } + else + { + // decompression transcoding + // supercompressedData -> inflatedData -> subresource + // ^ + // | + // in the ETC1S + UASTC case, we load file data into here directly + // (it turns out ETC1S doesn't do anything per-level) + if(header.supercompressionScheme == 0) + { + // UASTC, ETC1S: Load file data into inflatedData directly + UNWRAP_ERROR(ResizeVectorOrError(inflatedData, levelIndex.uncompressedByteLength)); + if(!input.read(inflatedData.data(), levelIndex.uncompressedByteLength)) + { + return "Reading mip " + std::to_string(mip) + "'s data failed."; + } + } + else if(header.supercompressionScheme == 1) + { + // ETC1S files often have uncompressedByteLength set to 0 for some reason. + // In any case, we want to read the compressed byte length. + UNWRAP_ERROR(ResizeVectorOrError(inflatedData, levelIndex.byteLength)); + if(!input.read(inflatedData.data(), levelIndex.byteLength)) + { + return "Reading mip " + std::to_string(mip) + "'s data failed."; + } + } + else + { + // Read into supercompressedData + UNWRAP_ERROR(ResizeVectorOrError(supercompressedData, levelIndex.byteLength)); + if(!input.read(supercompressedData.data(), levelIndex.byteLength)) + { + return "Reading mip " + std::to_string(mip) + "'s supercompressed data failed."; + } + + // Inflate the supercompressed data. We must use another buffer for this. + UNWRAP_ERROR(ResizeVectorOrError(inflatedData, levelIndex.uncompressedByteLength)); + + if(header.supercompressionScheme == 2) + { + // Zstandard +#ifdef NVP_SUPPORTS_ZSTD + size_t zstdError = ZSTD_decompress(inflatedData.data(), inflatedData.size(), // + supercompressedData.data(), supercompressedData.size()); + if(ZSTD_isError(zstdError)) + { + const char* zstdErrorName = ZSTD_getErrorName(zstdError); + return "Mip " + std::to_string(mip) + " Zstandard inflation failed with the message '" + + std::string(zstdErrorName) + "' (code " + std::to_string(zstdError) + ")."; + } +#else + assert(!"nv_ktx was compiled without Zstandard support, but the KTX stream was not rejected! This should never happen."); +#endif + } + else if(header.supercompressionScheme == 3) + { + // Zlib +#ifdef NVP_SUPPORTS_GZLIB + ScopedZlibDStream zlibStream; + int zlibError = zlibStream.Init(); + if(zlibError != Z_OK) + { + return "Zlib initialization failed (error code " + std::to_string(zlibError) + ")."; + } + if(supercompressedData.size() > UINT_MAX || inflatedData.size() > UINT_MAX) + { + return "Zlib compressed or decompressed data for mip " + std::to_string(mip) + " was larger than 4 GB."; + } + zlibStream.stream.next_in = reinterpret_cast(supercompressedData.data()); + zlibStream.stream.avail_in = static_cast(supercompressedData.size()); + zlibStream.stream.next_out = reinterpret_cast(inflatedData.data()); + zlibStream.stream.avail_out = static_cast(inflatedData.size()); + zlibError = inflate(&zlibStream.stream, Z_NO_FLUSH); + if(zlibError != Z_OK) + { + return "Zlib inflation failed (error code " + std::to_string(zlibError) + ")."; + } + zlibStream.Free(); +#else + assert(!"nv_ktx was compiled without Zlib support, but the KTX stream was not rejected! This should never happen."); +#endif + } + } + + // Check size ahead of time to ensure we don't read out of bounds. + // This would otherwise result in an access violation on + // invalid_face_count_and_padding.ktx2, or on an otherwise truncated file. + // This doesn't apply to ETC1S, because it does inflation and transcoding + // all at once. + if(header.supercompressionScheme != 1) + { + const size_t inflatedDataSize = inflatedData.size(); + const size_t expected_bytes_in_this_mip = inflatedFaceSize * size_t(header.layerCount) * size_t(header.faceCount); + if(expected_bytes_in_this_mip > inflatedDataSize) + { + return "Expected " + std::to_string(expected_bytes_in_this_mip) + " bytes in mip " + std::to_string(mip) + + ", but the inflated data was only " + std::to_string(inflatedDataSize) + " bytes long."; + } + } + + // Write into each subresource, possibly transcoding from the source + // format to this->format (for UASTC and ETC1S) + size_t inflatedDataPos = 0; // Read position in inflatedData + for(uint32_t layer = 0; layer < header.layerCount; layer++) + { + for(uint32_t face = 0; face < header.faceCount; face++) + { + std::vector& subresource_data = subresource(mip, layer, face); + UNWRAP_ERROR(ResizeVectorOrError(subresource_data, finalFaceSize)); + + if(input_supercompression == InputSupercompression::eBasisUASTC) + { +#ifdef NVP_SUPPORTS_BASISU + BasisUSingleton::GetInstance().TranscodeUASTCToBC7OrASTC44(subresource_data.data(), + &inflatedData[inflatedDataPos], mipWidth, mipHeight, + mipDepth, readSettings.device_supports_astc); +#else + assert(!"nv_ktx was compiled without Basis support, but the KTX stream was not rejected! This should never happen."); +#endif + } + else if(input_supercompression == InputSupercompression::eBasisETC1S) + { +#ifdef NVP_SUPPORTS_BASISU + // Get the ETC1S image description + const size_t etc1sImageIdx = + (std::max(1u, num_layers_possibly_0) * size_t(mip) + size_t(layer)) * size_t(num_faces) + size_t(face); + const basist::ktx2_etc1s_image_desc imageDesc = basisLZDCtx.etc1sImageDescs[etc1sImageIdx]; + const size_t numBlocksX = (mipWidth + 3) / 4; + const size_t numBlocksY = (mipHeight + 3) / 4; + + if(!basisLZDCtx.etc1sTranscoder->transcode_image( + basisDstFmt, // Basis destination format + subresource_data.data(), // Output data + uint32_t(numBlocksX * numBlocksY), // Number of blocks in the output + reinterpret_cast(inflatedData.data()), // Compressed data for this level + uint32_t(inflatedData.size()), // Compressed data length + uint32_t(numBlocksX), uint32_t(numBlocksY), // Block dimensions + uint32_t(mipWidth), uint32_t(mipHeight), // Pixel dimensions + uint32_t(mip), // Mip number + imageDesc.m_rgb_slice_byte_offset, imageDesc.m_rgb_slice_byte_length, // Range of first slice from the start of the compressed data + imageDesc.m_alpha_slice_byte_offset, imageDesc.m_alpha_slice_byte_length, // Range of second slice from the start of the compressed data + 0, // No need for nonstandard decoder flags here + (basisETC1SNumSlices == 2), // Whether it has 2 slices or only 1 + isVideo, // Whether this is ETC1S video + 0, // Output row pitch in blocks, or 0 + &basisLZDCtx.ktx2TranscoderState.m_transcoder_state, // Persistent transcoder state + false)) // Output in blocks, not pixels + { + return "Failed to decompress BasisLZ+ETC1S mip " + std::to_string(mip) + ", layer " + + std::to_string(layer) + ", face " + std::to_string(face) + "!"; + } +#else + assert(!"nv_ktx was compiled without Basis support, but the KTX stream was not rejected! This should never happen."); +#endif + } + else + { + // Not UASTC or ETC1S, no transcoding needed + // We've checked to make sure this is okay above, but double-check + // here in case the behavior above changes in future versions of + // the code. + if(header.supercompressionScheme == 1) + { + return "Failed to read KTX2 file: BasisLZ supercompression was enabled, but control reached the non-BasisLZ copy. This should never happen."; + } + if(inflatedDataPos + inflatedFaceSize > inflatedData.size()) + { + return "Failed to read KTX2 file: the size of the inflated data didn't match the expected size."; + } + memcpy(subresource_data.data(), &inflatedData[inflatedDataPos], inflatedFaceSize); + } + + // Advance to next image + inflatedDataPos += inflatedFaceSize; + } + } + } + } + + return {}; +} + +//----------------------------------------------------------------------------- +// Writing functions + +namespace { +// Sets the Data Format Descriptor information for ASTC LDR formats given the +// size of the block. Doesn't change the transfer function and flags. +void SetASTCFlags(uint8_t xsize, uint8_t ysize, BasicDataFormatDescriptor& descriptor, std::vector& samples) +{ + descriptor.colorModel = KHR_DF_MODEL_ASTC; + descriptor.colorPrimaries = KHR_DF_PRIMARIES_BT709; + // Don't override transferFunction and flags. + assert(xsize > 0 && ysize > 0); + descriptor.texelBlockDimension0 = xsize - 1; + descriptor.texelBlockDimension1 = ysize - 1; + descriptor.bytesPlane0 = 16; + + samples.resize(1); + samples[0].bitLength = 127; + samples[0].channelType = KHR_DF_CHANNEL_ASTC_DATA; + samples[0].lower = 0; + samples[0].upper = UINT32_MAX; +} + +template +size_t SizeofVector(const std::vector& vec) +{ + return vec.size() * sizeof(T); +} + +std::vector StringToCharVector(const std::string& str) +{ + const char* cString = str.c_str(); + const size_t strlenWithZero = str.size() + 1; + return std::vector(cString, cString + strlenWithZero); +} + +// Returns the least common multiple of n and 4. +size_t LCM4(size_t n) +{ + if(n % 4 == 0) + { + return n; + } + else if(n % 2 == 0) + { + return n * 2; + } + else + { + return n * 4; + } +} +} // namespace + + +ErrorWithText KTXImage::writeKTX2Stream(std::ostream& output, const WriteSettings& writeSettings) +{ + // This function is more difficult than DDS writing, since the header + // contains offsets into the rest of the file. + // The way this works is that we'll initially write a blank identifier and + // top-level header, then write the rest of the file keeping track of the + // different offsets. Then we'll rewind back to the start and write the + // header and offsets. + + // For Basis formats, we actually use the Basis Universal KTX2 writer entirely. + // The reason is that basisu::basis_compressor doesn't have a level of + // abstraction between "compress a block of data" and + // "write a .basis or .ktx2 file" - the functions to do so are declared as + // private. KTX-Software gets around this by writing to a .basis stream + // in-memory, then reading the .basis stream and getting the needed data, + // which takes a few hundred lines of code. It feels safest and least cursed + // to me to rely on the built-in Basis implementation here. + + //--------------------------------------------------------------------------- + // Common things for both writers. + // Some dimension fields can be 0 to indicate the texture type; create copies + // of them where these 0s have been changed to 1s for indexing. + if(num_mips < 1) + { + return "Failed to write KTX2 file: num_mips (" + std::to_string(num_mips) + ") was less than 1."; + } + const uint32_t num_layers_or_1 = std::max(num_layers_possibly_0, 1u); + + // First, apply modifications to the KTXswizzle information early so that + // they're handled by both writers. + { + std::stringstream ktxSwizzle; + for(int c = 0; c < 4; c++) + { + switch(swizzle[c]) + { + case KTX_SWIZZLE::R: + ktxSwizzle << "r"; + break; + case KTX_SWIZZLE::G: + ktxSwizzle << "g"; + break; + case KTX_SWIZZLE::B: + ktxSwizzle << "b"; + break; + case KTX_SWIZZLE::A: + ktxSwizzle << "a"; + break; + case KTX_SWIZZLE::ZERO: + ktxSwizzle << "0"; + break; + case KTX_SWIZZLE::ONE: + ktxSwizzle << "1"; + break; + default: + assert(!"Unknown KTX_SWIZZLE!"); + return "Internal error: Unknown KTX_SWIZZLE."; + break; + } + } + key_value_data["KTXswizzle"] = StringToCharVector(ktxSwizzle.str()); + } + + if(writeSettings.encode_rgba8_to_format != EncodeRGBA8ToFormat::NO) + { +#ifndef NVP_SUPPORTS_BASISU + return "Failed to write KTX2 file: encoding to a Basis format was specified, but NVP_SUPPORTS_BASISU was " + "not defined."; +#else + // Validate format + if((format != VK_FORMAT_B8G8R8A8_SRGB) && (format != VK_FORMAT_B8G8R8A8_UNORM)) + { + return "Failed to write KTX2 file: encoding RGBA8 data to a Basis format was specified, but the Vulkan format of " + "the input data, " + + std::to_string(format) + " wasn't VK_FORMAT_B8G8R8A8_UNORM or VK_FORMAT_B8G8R8A8_SRGB."; + } + + // Basisu doesn't support volume textures fully yet, I think + if(mip_0_depth > 1) + { + return "Failed to write KTX2 file: Volumes with Basis compression aren't supported yet."; + } + + BasisUSingleton::GetInstance().Initialize(); + basisu::basis_compressor_params params; + params.m_perceptual = is_srgb; + params.m_ktx2_srgb_transfer_func = is_srgb; + params.m_mip_gen = false; + params.m_read_source_images = false; + params.m_write_output_basis_files = false; + params.m_status_output = false; + params.m_debug = false; + params.m_validate_etc1s = false; + params.m_compression_level = writeSettings.etc1s_encoding_level; + params.m_check_for_alpha = false; + params.m_multithreading = true; + params.m_create_ktx2_file = true; + params.m_quality_level = 128; + + // Determine the texture type + if((mip_0_depth == 0) || (mip_0_depth == 1)) // Avoid volumes for now + { + // [2D or cubemap] * + if(num_faces == 6) + { + // Cubemap + params.m_tex_type = basist::cBASISTexTypeCubemapArray; + } + else + { + if(num_layers_possibly_0 == 0) + { + // 2D non-array + params.m_tex_type = basist::cBASISTexType2D; + } + else + { + // 2D array + params.m_tex_type = basist::cBASISTexType2DArray; + } + } + } + else + { + // Volumes; reject cubemaps + if(num_faces == 6) + { + return "Cubemaps where each face is a volume are not supported in KTX2 according to section 4.1, Texture Type."; + } + else + { + params.m_tex_type = basist::cBASISTexTypeVolume; + } + } + + // UASTC vs. ETC1S + if(writeSettings.encode_rgba8_to_format == EncodeRGBA8ToFormat::UASTC) + { + params.m_uastc = true; + params.m_pack_uastc_flags = static_cast(writeSettings.uastc_encoding_quality); + params.m_force_alpha = true; + if(writeSettings.supercompression == WriteSupercompressionType::ZSTD) + { + params.m_rdo_uastc = true; + params.m_rdo_uastc_quality_scalar = writeSettings.rdo_lambda; + params.m_rdo_uastc_multithreading = true; + params.m_ktx2_uastc_supercompression = basist::ktx2_supercompression::KTX2_SS_ZSTANDARD; + params.m_ktx2_zstd_supercompression_level = writeSettings.supercompression_level; + } + } + else + { + params.m_force_alpha = (writeSettings.encode_rgba8_to_format == EncodeRGBA8ToFormat::ETC1S_RGBA); + params.m_quality_level = std::max(0, std::min((writeSettings.etc1s_encoding_level * 255) / 6, 255)); + //params.m_global_sel_pal = true; // Enabling this seems to make things very slow + params.m_uastc = false; + // KTX-Software currently sets these to true if the input is a normal map. + params.m_no_endpoint_rdo = !writeSettings.rdo_etc1s; + params.m_no_selector_rdo = !writeSettings.rdo_etc1s; + if(!writeSettings.rdo_etc1s) + { + params.m_compression_level = 0; + } + } + + // Create a job pool for multithreading + basisu::job_pool job_pool(std::thread::hardware_concurrency()); + params.m_pJob_pool = &job_pool; + + // Copy key/value data, except for KTXwriter, since basisu will make its + // own key for that. + for(const auto& kvp : key_value_data) + { + if(kvp.first == "KTXwriter") + continue; + params.m_ktx2_key_values.push_back(basist::ktx2_transcoder::key_value()); + basist::ktx2_transcoder::key_value& outKVP = params.m_ktx2_key_values.back(); + if((kvp.first.size() > (UINT32_MAX - 1)) || (kvp.second.size() > UINT32_MAX)) + { + return "A key/value pair was too large for Basis' KTX2 writer."; + } + outKVP.m_key.append(reinterpret_cast(kvp.first.data()), static_cast(kvp.first.size())); + outKVP.m_key.push_back(0); + outKVP.m_value.append(reinterpret_cast(kvp.second.data()), static_cast(kvp.second.size())); + } + + // Copy image data. I believe these are in KTX2 order. + params.m_source_images.reserve(size_t(num_layers_or_1) * size_t(num_faces)); + params.m_source_mipmap_images.reserve(size_t(num_layers_or_1) * size_t(num_faces)); + for(uint32_t layer = 0; layer < num_layers_or_1; layer++) + { + for(uint32_t face = 0; face < num_faces; face++) + { + if(num_mips > 1) + { + params.m_source_mipmap_images.push_back(basisu::vector()); + params.m_source_mipmap_images.back().reserve(size_t(num_mips) - 1); + } + for(uint32_t mip = 0; mip < num_mips; mip++) + { + std::vector& this_subresource = subresource(mip, layer, face); + const uint32_t width = std::max(1u, mip_0_width >> mip); + const uint32_t height = std::max(1u, mip_0_height >> mip); + const size_t widthS = static_cast(width); + const size_t heightS = static_cast(height); + // Mip 0 images go in m_source_images, while higher mips go in m_source_mipmap_images. + if(mip == 0) + { + params.m_source_images.push_back(basisu::image(width, height)); + } + else + { + params.m_source_mipmap_images.back().push_back(basisu::image(width, height)); + } + basisu::image& out_image = (mip == 0 ? params.m_source_images.back() : params.m_source_mipmap_images.back().back()); + + for(size_t y = 0; y < heightS; y++) + { + for(size_t x = 0; x < widthS; x++) + { + // Workaround for an issue where basisu ignores m_check_for_alpha set to false if user-supplied mips are provided + const uint8_t a = params.m_force_alpha ? static_cast(this_subresource[(widthS * y + x) * 4 + 3]) : 255; + out_image(uint32_t(x), uint32_t(y)) + .set(static_cast(this_subresource[(widthS * y + x) * 4 + 2]), // R from B + static_cast(this_subresource[(widthS * y + x) * 4 + 1]), // G from G + static_cast(this_subresource[(widthS * y + x) * 4 + 0]), // B from R + a); // A from A + } + } + } + } + } + + // Create the KTX2 data! + basisu::basis_compressor basis_compressor; + // basisu::enable_debug_printf(true); // Uncomment this to print out status messages + + if(!basis_compressor.init(params)) + { + return "Failed to initialize Basis Universal compressor."; + } + + const basisu::basis_compressor::error_code basis_result = basis_compressor.process(); + switch(basis_result) + { + case basisu::basis_compressor::cECSuccess: + break; + case basisu::basis_compressor::cECFailedReadingSourceImages: + return "Basis Universal compressor failed to read source images."; + case basisu::basis_compressor::cECFailedValidating: + return "Basis Universal compressor input failed validation (most likely an error in the Texture Tools " + "Exporter)."; + case basisu::basis_compressor::cECFailedEncodeUASTC: + return "Basis Universal compressor failed to encode to UASTC."; + case basisu::basis_compressor::cECFailedFrontEnd: + return "Basis Universal compressor failed in the ETC1S frontend."; + case basisu::basis_compressor::cECFailedFontendExtract: + return "Basis Universal compressor failed to extract data from the ETC1S frontend."; + case basisu::basis_compressor::cECFailedBackend: + return "Basis Universal compressor failed during BasisLZ compression."; + case basisu::basis_compressor::cECFailedCreateBasisFile: + return "Basis Universal compressor failed when creating Basis-formatted output."; + case basisu::basis_compressor::cECFailedWritingOutput: + return "Basis Universal compressor failed when writing the output file."; + case basisu::basis_compressor::cECFailedUASTCRDOPostProcess: + return "Basis Universal compressor failed when performing the UASTC Rate-Distortion Optimization post-process."; + case basisu::basis_compressor::cECFailedCreateKTX2File: + return "Basis Universal compressor to create a KTX2 file."; + case basisu::basis_compressor::cECFailedInitializing: + return "Basis Universal failed initializing."; + default: + return "Basis Universal error."; + } + + // Write it out to the stream! + if(!output.write(reinterpret_cast(basis_compressor.get_output_ktx2_file().data()), + basis_compressor.get_output_ktx2_file().size())) + { + return "Basis Universal compressor succeeded, but the I/O operation of writing the compressed data to a stream " + "failed! Is the file in use or the location requires administrator permissions?"; + } + + return {}; +#endif + } + + //--------------------------------------------------------------------------- + // Normal KTX2 writing + const std::streampos start_pos = output.tellp(); + + // Allocate the header and Level Index. + KTX2TopLevelHeader header{}; + std::vector levelIndex(num_mips); // "mip offsets" + + // Write the header (we'll write it again), then zeros up to the Data Format Descriptor. + if(!output.write(reinterpret_cast(ktx2Identifier), IDENTIFIER_LEN)) + { + return "Failed to write identifier the first time. Is the stream writable?"; + } + if(!output.write(reinterpret_cast(&header), sizeof(header))) + { + return "Failed to write zeros for header."; + } + if(!output.write(reinterpret_cast(levelIndex.data()), SizeofVector(levelIndex))) + { + return "Failed to write zeros for level index."; + } + + //--------------------------------------------------------------------------- + // Write the Data Format Descriptor. + // First, we know header.dfdByteOffset now. + header.dfdByteOffset = static_cast(output.tellp() - start_pos); + // Since the Khronos Data Format specifies + // data format descriptors for most of the formats we support, we base + // things off that. + // Unfortunately, BC2, BC3, and BC5 use two samples, so we need to use a vector here: + std::vector dfSamples(1); // Can be resized + BasicDataFormatDescriptor dfdBlock{}; + // Set some initial fields + dfdBlock.descriptorType = 0; + dfdBlock.vendorId = 0; // Khronos + dfdBlock.versionNumber = 2; + dfdBlock.colorPrimaries = KHR_DF_PRIMARIES_BT709; + // Note that we don't use the transferFunctions in the examples, since we + // specify a transfer function for each format. + dfdBlock.transferFunction = is_srgb ? KHR_DF_TRANSFER_SRGB : KHR_DF_TRANSFER_LINEAR; + // Similarly with premultiplied alpha: + if(is_premultiplied) + { + dfdBlock.flags |= KHR_DF_FLAG_ALPHA_PREMULTIPLIED; + } + else + { + dfdBlock.flags |= KHR_DF_FLAG_ALPHA_STRAIGHT; + } + + // Switch over formats + // The only case where VkFormat isn't enough is BGRX vs. BGRA, where we have + // to do something special for the BGRX case. + switch(format) + { + case VK_FORMAT_BC7_UNORM_BLOCK: + case VK_FORMAT_BC7_SRGB_BLOCK: + // BC7 + dfdBlock.colorModel = KHR_DF_MODEL_BC7; + dfdBlock.colorPrimaries = KHR_DF_PRIMARIES_BT709; + dfdBlock.texelBlockDimension0 = 3; + dfdBlock.texelBlockDimension1 = 3; + dfdBlock.bytesPlane0 = 16; + dfSamples[0].bitLength = 127; + dfSamples[0].channelType = KHR_DF_CHANNEL_BC7_COLOR; + dfSamples[0].upper = UINT32_MAX; + break; + case VK_FORMAT_BC6H_SFLOAT_BLOCK: + // BC6H signed + dfdBlock.colorModel = KHR_DF_MODEL_BC6H; + dfdBlock.colorPrimaries = KHR_DF_PRIMARIES_BT709; + dfdBlock.texelBlockDimension0 = 3; + dfdBlock.texelBlockDimension1 = 3; + dfdBlock.bytesPlane0 = 16; + dfSamples[0].bitLength = 127; + dfSamples[0].channelType = + uint8_t(KHR_DF_CHANNEL_BC6H_COLOR) | uint8_t(KHR_DF_SAMPLE_DATATYPE_FLOAT | KHR_DF_SAMPLE_DATATYPE_SIGNED); + dfSamples[0].lower = 0xBF800000u; // -1.0f + dfSamples[0].upper = 0x3F800000u; // 1.0f + break; + case VK_FORMAT_BC6H_UFLOAT_BLOCK: + // BC6H unsigned + dfdBlock.colorModel = KHR_DF_MODEL_BC6H; + dfdBlock.colorPrimaries = KHR_DF_PRIMARIES_BT709; + dfdBlock.texelBlockDimension0 = 3; + dfdBlock.texelBlockDimension1 = 3; + dfdBlock.bytesPlane0 = 16; + dfSamples[0].bitLength = 127; + dfSamples[0].channelType = uint8_t(KHR_DF_CHANNEL_BC6H_COLOR) | uint8_t(KHR_DF_SAMPLE_DATATYPE_FLOAT); + dfSamples[0].lower = 0; // 0.0f + dfSamples[0].upper = 0x3F800000u; // 1.0f + break; + case VK_FORMAT_ASTC_4x4_UNORM_BLOCK: + case VK_FORMAT_ASTC_4x4_SRGB_BLOCK: + SetASTCFlags(4, 4, dfdBlock, dfSamples); + break; + case VK_FORMAT_ASTC_5x4_UNORM_BLOCK: + case VK_FORMAT_ASTC_5x4_SRGB_BLOCK: + SetASTCFlags(5, 4, dfdBlock, dfSamples); + break; + case VK_FORMAT_ASTC_5x5_UNORM_BLOCK: + case VK_FORMAT_ASTC_5x5_SRGB_BLOCK: + SetASTCFlags(5, 5, dfdBlock, dfSamples); + break; + case VK_FORMAT_ASTC_6x5_UNORM_BLOCK: + case VK_FORMAT_ASTC_6x5_SRGB_BLOCK: + SetASTCFlags(6, 5, dfdBlock, dfSamples); + break; + case VK_FORMAT_ASTC_6x6_UNORM_BLOCK: + case VK_FORMAT_ASTC_6x6_SRGB_BLOCK: + SetASTCFlags(6, 6, dfdBlock, dfSamples); + break; + case VK_FORMAT_ASTC_8x5_UNORM_BLOCK: + case VK_FORMAT_ASTC_8x5_SRGB_BLOCK: + SetASTCFlags(8, 5, dfdBlock, dfSamples); + break; + case VK_FORMAT_ASTC_8x6_UNORM_BLOCK: + case VK_FORMAT_ASTC_8x6_SRGB_BLOCK: + SetASTCFlags(8, 6, dfdBlock, dfSamples); + break; + case VK_FORMAT_ASTC_8x8_UNORM_BLOCK: + case VK_FORMAT_ASTC_8x8_SRGB_BLOCK: + SetASTCFlags(8, 8, dfdBlock, dfSamples); + break; + case VK_FORMAT_ASTC_10x5_UNORM_BLOCK: + case VK_FORMAT_ASTC_10x5_SRGB_BLOCK: + SetASTCFlags(10, 5, dfdBlock, dfSamples); + break; + case VK_FORMAT_ASTC_10x6_UNORM_BLOCK: + case VK_FORMAT_ASTC_10x6_SRGB_BLOCK: + SetASTCFlags(10, 6, dfdBlock, dfSamples); + break; + case VK_FORMAT_ASTC_10x8_UNORM_BLOCK: + case VK_FORMAT_ASTC_10x8_SRGB_BLOCK: + SetASTCFlags(10, 8, dfdBlock, dfSamples); + break; + case VK_FORMAT_ASTC_10x10_UNORM_BLOCK: + case VK_FORMAT_ASTC_10x10_SRGB_BLOCK: + SetASTCFlags(10, 10, dfdBlock, dfSamples); + break; + case VK_FORMAT_ASTC_12x10_UNORM_BLOCK: + case VK_FORMAT_ASTC_12x10_SRGB_BLOCK: + SetASTCFlags(12, 10, dfdBlock, dfSamples); + break; + case VK_FORMAT_ASTC_12x12_UNORM_BLOCK: + case VK_FORMAT_ASTC_12x12_SRGB_BLOCK: + SetASTCFlags(12, 12, dfdBlock, dfSamples); + break; + case VK_FORMAT_BC5_UNORM_BLOCK: + dfdBlock.colorModel = KHR_DF_MODEL_BC5; + dfdBlock.colorPrimaries = KHR_DF_PRIMARIES_BT709; + dfdBlock.texelBlockDimension0 = 3; + dfdBlock.texelBlockDimension1 = 3; + dfdBlock.bytesPlane0 = 16; + dfSamples.resize(2); + dfSamples[0].bitLength = 63; + dfSamples[0].channelType = KHR_DF_CHANNEL_BC5_RED; + dfSamples[0].upper = UINT32_MAX; + dfSamples[1].bitLength = 63; + dfSamples[1].bitOffset = 64; + dfSamples[1].channelType = KHR_DF_CHANNEL_BC5_GREEN; + dfSamples[1].upper = UINT32_MAX; + break; + case VK_FORMAT_BC4_UNORM_BLOCK: + dfdBlock.colorModel = KHR_DF_MODEL_BC4; + dfdBlock.colorPrimaries = KHR_DF_PRIMARIES_BT709; + dfdBlock.texelBlockDimension0 = 3; + dfdBlock.texelBlockDimension1 = 3; + dfdBlock.bytesPlane0 = 8; + dfSamples[0].bitLength = 63; + dfSamples[0].channelType = KHR_DF_CHANNEL_BC4_DATA; + dfSamples[0].upper = UINT32_MAX; + break; + case VK_FORMAT_BC3_UNORM_BLOCK: + case VK_FORMAT_BC3_SRGB_BLOCK: + // We actually switch between DXT4 and DXT5 here based on + // premultiplication, following the examples in the spec. + if(is_premultiplied) + { + dfdBlock.colorModel = KHR_DF_MODEL_DXT4; + } + else + { + dfdBlock.colorModel = KHR_DF_MODEL_DXT5; + } + dfdBlock.colorPrimaries = KHR_DF_PRIMARIES_BT709; + dfdBlock.texelBlockDimension0 = 3; + dfdBlock.texelBlockDimension1 = 3; + dfdBlock.bytesPlane0 = 16; + dfSamples.resize(2); + dfSamples[0].bitLength = 63; + dfSamples[0].channelType = uint8_t(KHR_DF_CHANNEL_BC3_ALPHA) | uint8_t(KHR_DF_SAMPLE_DATATYPE_LINEAR); + dfSamples[0].upper = UINT32_MAX; + dfSamples[1].bitOffset = 64; + dfSamples[1].bitLength = 63; + dfSamples[1].channelType = KHR_DF_CHANNEL_BC3_COLOR; + dfSamples[1].upper = UINT32_MAX; + break; + case VK_FORMAT_BC2_UNORM_BLOCK: + case VK_FORMAT_BC2_SRGB_BLOCK: + // Same premultiplication situation here as BC3 + if(is_premultiplied) + { + dfdBlock.colorModel = KHR_DF_MODEL_DXT2; + } + else + { + dfdBlock.colorModel = KHR_DF_MODEL_DXT3; + } + dfdBlock.colorPrimaries = KHR_DF_PRIMARIES_BT709; + dfdBlock.texelBlockDimension0 = 3; + dfdBlock.texelBlockDimension1 = 3; + dfdBlock.bytesPlane0 = 16; + dfSamples.resize(2); + dfSamples[0].bitLength = 63; + // The alpha channel must always be linear! + dfSamples[0].channelType = uint8_t(KHR_DF_CHANNEL_BC2_ALPHA) | uint8_t(KHR_DF_SAMPLE_DATATYPE_LINEAR); + dfSamples[0].upper = UINT32_MAX; + dfSamples[1].bitOffset = 64; + dfSamples[1].bitLength = 63; + dfSamples[1].channelType = KHR_DF_CHANNEL_BC2_COLOR; + dfSamples[1].upper = UINT32_MAX; + break; + case VK_FORMAT_BC1_RGBA_UNORM_BLOCK: + case VK_FORMAT_BC1_RGBA_SRGB_BLOCK: + // BC1a + dfdBlock.colorModel = KHR_DF_MODEL_DXT1A; + dfdBlock.colorPrimaries = KHR_DF_PRIMARIES_BT709; + dfdBlock.texelBlockDimension0 = 3; + dfdBlock.texelBlockDimension1 = 3; + dfdBlock.bytesPlane0 = 8; + dfSamples[0].bitLength = 63; + dfSamples[0].channelType = KHR_DF_CHANNEL_BC1A_ALPHAPRESENT; + dfSamples[0].upper = UINT32_MAX; + break; + case VK_FORMAT_BC1_RGB_UNORM_BLOCK: + case VK_FORMAT_BC1_RGB_SRGB_BLOCK: + // BC1 + dfdBlock.colorModel = KHR_DF_MODEL_DXT1A; + dfdBlock.colorPrimaries = KHR_DF_PRIMARIES_BT709; + dfdBlock.texelBlockDimension0 = 3; + dfdBlock.texelBlockDimension1 = 3; + dfdBlock.bytesPlane0 = 8; + dfSamples[0].bitLength = 63; + dfSamples[0].channelType = KHR_DF_CHANNEL_BC1A_COLOR; + dfSamples[0].upper = UINT32_MAX; + break; + case VK_FORMAT_R8_UNORM: + case VK_FORMAT_R8_SRGB: + // R8 + dfdBlock.colorModel = KHR_DF_MODEL_RGBSDA; + dfdBlock.colorPrimaries = KHR_DF_PRIMARIES_BT709; + dfdBlock.texelBlockDimension0 = 0; + dfdBlock.texelBlockDimension1 = 0; + dfdBlock.bytesPlane0 = 1; + + dfSamples[0].bitOffset = 0; + dfSamples[0].bitLength = 7; // "8" + dfSamples[0].channelType = KHR_DF_CHANNEL_RGBSDA_RED; + dfSamples[0].upper = 255; + break; + case VK_FORMAT_B8G8R8_UNORM: + case VK_FORMAT_B8G8R8_SRGB: + // B in byte 0, G in byte 1, R in byte 2 + dfdBlock.colorModel = KHR_DF_MODEL_RGBSDA; + dfdBlock.colorPrimaries = KHR_DF_PRIMARIES_BT709; + dfdBlock.texelBlockDimension0 = 0; + dfdBlock.texelBlockDimension1 = 0; + dfdBlock.bytesPlane0 = 3; + + dfSamples.resize(3); + + dfSamples[0].bitOffset = 0; + dfSamples[0].bitLength = 7; // "8" + dfSamples[0].channelType = KHR_DF_CHANNEL_RGBSDA_BLUE; + dfSamples[0].upper = 255; + + dfSamples[1].bitOffset = 8; + dfSamples[1].bitLength = 7; // "8" + dfSamples[1].channelType = KHR_DF_CHANNEL_RGBSDA_GREEN; + dfSamples[1].upper = 255; + + dfSamples[2].bitOffset = 16; + dfSamples[2].bitLength = 7; // "8" + dfSamples[2].channelType = KHR_DF_CHANNEL_RGBSDA_RED; + dfSamples[2].upper = 255; + break; + case VK_FORMAT_B8G8R8A8_UNORM: + case VK_FORMAT_B8G8R8A8_SRGB: + dfdBlock.colorModel = KHR_DF_MODEL_RGBSDA; + dfdBlock.colorPrimaries = KHR_DF_PRIMARIES_BT709; + dfdBlock.texelBlockDimension0 = 0; + dfdBlock.texelBlockDimension1 = 0; + dfdBlock.bytesPlane0 = 4; + + // B in byte 0, G in byte 1, R in byte 2, A in byte 3 + dfSamples.resize(4); + + dfSamples[0].bitOffset = 0; + dfSamples[0].bitLength = 7; // "8" + dfSamples[0].channelType = KHR_DF_CHANNEL_RGBSDA_BLUE; + dfSamples[0].upper = 255; + + dfSamples[1].bitOffset = 8; + dfSamples[1].bitLength = 7; // "8" + dfSamples[1].channelType = KHR_DF_CHANNEL_RGBSDA_GREEN; + dfSamples[1].upper = 255; + + dfSamples[2].bitOffset = 16; + dfSamples[2].bitLength = 7; // "8" + dfSamples[2].channelType = KHR_DF_CHANNEL_RGBSDA_RED; + dfSamples[2].upper = 255; + + dfSamples[3].bitOffset = 24; + dfSamples[3].bitLength = 7; // "8" + dfSamples[3].channelType = uint8_t(KHR_DF_CHANNEL_RGBSDA_ALPHA) | uint8_t(KHR_DF_SAMPLE_DATATYPE_LINEAR); + dfSamples[3].upper = 255; + break; + case VK_FORMAT_R8G8B8_UNORM: + case VK_FORMAT_R8G8B8_SRGB: + // R in byte 0, G in byte 1, B in byte 2 + dfdBlock.colorModel = KHR_DF_MODEL_RGBSDA; + dfdBlock.colorPrimaries = KHR_DF_PRIMARIES_BT709; + dfdBlock.texelBlockDimension0 = 0; + dfdBlock.texelBlockDimension1 = 0; + dfdBlock.bytesPlane0 = 3; + + dfSamples.resize(3); + + dfSamples[0].bitOffset = 0; + dfSamples[0].bitLength = 7; // "8" + dfSamples[0].channelType = KHR_DF_CHANNEL_RGBSDA_RED; + dfSamples[0].upper = 255; + + dfSamples[1].bitOffset = 8; + dfSamples[1].bitLength = 7; // "8" + dfSamples[1].channelType = KHR_DF_CHANNEL_RGBSDA_GREEN; + dfSamples[1].upper = 255; + + dfSamples[2].bitOffset = 16; + dfSamples[2].bitLength = 7; // "8" + dfSamples[2].channelType = KHR_DF_CHANNEL_RGBSDA_BLUE; + dfSamples[2].upper = 255; + break; + case VK_FORMAT_R8G8B8A8_UNORM: + case VK_FORMAT_R8G8B8A8_SRGB: + dfdBlock.colorModel = KHR_DF_MODEL_RGBSDA; + dfdBlock.colorPrimaries = KHR_DF_PRIMARIES_BT709; + dfdBlock.texelBlockDimension0 = 0; + dfdBlock.texelBlockDimension1 = 0; + dfdBlock.bytesPlane0 = 4; + + // B in byte 0, G in byte 1, R in byte 2, A in byte 3 + dfSamples.resize(4); + + dfSamples[0].bitOffset = 0; + dfSamples[0].bitLength = 7; // "8" + dfSamples[0].channelType = KHR_DF_CHANNEL_RGBSDA_RED; + dfSamples[0].upper = 255; + + dfSamples[1].bitOffset = 8; + dfSamples[1].bitLength = 7; // "8" + dfSamples[1].channelType = KHR_DF_CHANNEL_RGBSDA_GREEN; + dfSamples[1].upper = 255; + + dfSamples[2].bitOffset = 16; + dfSamples[2].bitLength = 7; // "8" + dfSamples[2].channelType = KHR_DF_CHANNEL_RGBSDA_BLUE; + dfSamples[2].upper = 255; + + dfSamples[3].bitOffset = 24; + dfSamples[3].bitLength = 7; // "8" + dfSamples[3].channelType = uint8_t(KHR_DF_CHANNEL_RGBSDA_ALPHA) | uint8_t(KHR_DF_SAMPLE_DATATYPE_LINEAR); + dfSamples[3].upper = 255; + break; + case VK_FORMAT_R16_SFLOAT: + dfdBlock.colorModel = KHR_DF_MODEL_RGBSDA; + dfdBlock.colorPrimaries = KHR_DF_PRIMARIES_BT709; + dfdBlock.texelBlockDimension0 = 0; + dfdBlock.texelBlockDimension1 = 0; + dfdBlock.bytesPlane0 = sizeof(uint16_t); + + dfSamples[0].bitOffset = 0; + dfSamples[0].bitLength = 15; // "16" + dfSamples[0].channelType = + uint8_t(KHR_DF_CHANNEL_RGBSDA_RED) | uint8_t(KHR_DF_SAMPLE_DATATYPE_SIGNED | KHR_DF_SAMPLE_DATATYPE_FLOAT); + // Yes, these are 32-bit floats, not 16-bit floats! From the spec + dfSamples[0].lower = 0xBF800000u; // -1.0f + dfSamples[0].upper = 0x3F800000u; // 1.0f + break; + case VK_FORMAT_R16G16_SFLOAT: + dfdBlock.colorModel = KHR_DF_MODEL_RGBSDA; + dfdBlock.colorPrimaries = KHR_DF_PRIMARIES_BT709; + dfdBlock.texelBlockDimension0 = 0; + dfdBlock.texelBlockDimension1 = 0; + dfdBlock.bytesPlane0 = sizeof(uint16_t) * 2; + + dfSamples.resize(2); + for(uint32_t c = 0; c < 2; c++) + { + dfSamples[c].bitOffset = 16 * c; + dfSamples[c].bitLength = 15; // "16" + dfSamples[c].lower = 0xBF800000u; // -1.0f + dfSamples[c].upper = 0x3F800000u; // 1.0f + } + + dfSamples[0].channelType = + uint8_t(KHR_DF_CHANNEL_RGBSDA_RED) | uint8_t(KHR_DF_SAMPLE_DATATYPE_SIGNED | KHR_DF_SAMPLE_DATATYPE_FLOAT); + dfSamples[1].channelType = + uint8_t(KHR_DF_CHANNEL_RGBSDA_GREEN) | uint8_t(KHR_DF_SAMPLE_DATATYPE_SIGNED | KHR_DF_SAMPLE_DATATYPE_FLOAT); + break; + case VK_FORMAT_R16G16B16A16_SFLOAT: + dfdBlock.colorModel = KHR_DF_MODEL_RGBSDA; + dfdBlock.colorPrimaries = KHR_DF_PRIMARIES_BT709; + dfdBlock.texelBlockDimension0 = 0; + dfdBlock.texelBlockDimension1 = 0; + dfdBlock.bytesPlane0 = sizeof(uint16_t) * 4; + + dfSamples.resize(4); + for(uint32_t c = 0; c < 4; c++) + { + dfSamples[c].bitOffset = 16 * c; + dfSamples[c].bitLength = 15; // "16" + dfSamples[c].lower = 0xBF800000u; // -1.0f + dfSamples[c].upper = 0x3F800000u; // 1.0f + } + + dfSamples[0].channelType = + uint8_t(KHR_DF_CHANNEL_RGBSDA_RED) | uint8_t(KHR_DF_SAMPLE_DATATYPE_SIGNED | KHR_DF_SAMPLE_DATATYPE_FLOAT); + dfSamples[1].channelType = + uint8_t(KHR_DF_CHANNEL_RGBSDA_GREEN) | uint8_t(KHR_DF_SAMPLE_DATATYPE_SIGNED | KHR_DF_SAMPLE_DATATYPE_FLOAT); + dfSamples[2].channelType = + uint8_t(KHR_DF_CHANNEL_RGBSDA_BLUE) | uint8_t(KHR_DF_SAMPLE_DATATYPE_SIGNED | KHR_DF_SAMPLE_DATATYPE_FLOAT); + dfSamples[3].channelType = + uint8_t(KHR_DF_CHANNEL_RGBSDA_ALPHA) | uint8_t(KHR_DF_SAMPLE_DATATYPE_SIGNED | KHR_DF_SAMPLE_DATATYPE_FLOAT); + break; + case VK_FORMAT_R32_SFLOAT: + dfdBlock.colorModel = KHR_DF_MODEL_RGBSDA; + dfdBlock.colorPrimaries = KHR_DF_PRIMARIES_BT709; + dfdBlock.texelBlockDimension0 = 0; + dfdBlock.texelBlockDimension1 = 0; + dfdBlock.bytesPlane0 = sizeof(uint32_t); + + dfSamples[0].bitOffset = 0; + dfSamples[0].bitLength = 31; // "32" + dfSamples[0].channelType = + uint8_t(KHR_DF_CHANNEL_RGBSDA_RED) | uint8_t(KHR_DF_SAMPLE_DATATYPE_SIGNED | KHR_DF_SAMPLE_DATATYPE_FLOAT); + dfSamples[0].lower = 0xBF800000u; // -1.0f + dfSamples[0].upper = 0x3F800000u; // 1.0f + break; + case VK_FORMAT_R32G32_SFLOAT: + dfdBlock.colorModel = KHR_DF_MODEL_RGBSDA; + dfdBlock.colorPrimaries = KHR_DF_PRIMARIES_BT709; + dfdBlock.texelBlockDimension0 = 0; + dfdBlock.texelBlockDimension1 = 0; + dfdBlock.bytesPlane0 = sizeof(uint32_t) * 2; + + dfSamples.resize(2); + for(uint32_t c = 0; c < 2; c++) + { + dfSamples[c].bitOffset = 32 * c; + dfSamples[c].bitLength = 31; // "32" + dfSamples[c].lower = 0xBF800000u; // -1.0f + dfSamples[c].upper = 0x3F800000u; // 1.0f + } + + dfSamples[0].channelType = + uint8_t(KHR_DF_CHANNEL_RGBSDA_RED) | uint8_t(KHR_DF_SAMPLE_DATATYPE_SIGNED | KHR_DF_SAMPLE_DATATYPE_FLOAT); + dfSamples[1].channelType = + uint8_t(KHR_DF_CHANNEL_RGBSDA_GREEN) | uint8_t(KHR_DF_SAMPLE_DATATYPE_SIGNED | KHR_DF_SAMPLE_DATATYPE_FLOAT); + break; + case VK_FORMAT_R32G32B32A32_SFLOAT: + dfdBlock.colorModel = KHR_DF_MODEL_RGBSDA; + dfdBlock.colorPrimaries = KHR_DF_PRIMARIES_BT709; + dfdBlock.texelBlockDimension0 = 0; + dfdBlock.texelBlockDimension1 = 0; + dfdBlock.bytesPlane0 = sizeof(uint32_t) * 4; + + dfSamples.resize(4); + for(uint32_t c = 0; c < 4; c++) + { + dfSamples[c].bitOffset = 32 * c; + dfSamples[c].bitLength = 31; // "32" + dfSamples[c].lower = 0xBF800000u; // -1.0f + dfSamples[c].upper = 0x3F800000u; // 1.0f + } + + dfSamples[0].channelType = + uint8_t(KHR_DF_CHANNEL_RGBSDA_RED) | uint8_t(KHR_DF_SAMPLE_DATATYPE_SIGNED | KHR_DF_SAMPLE_DATATYPE_FLOAT); + dfSamples[1].channelType = + uint8_t(KHR_DF_CHANNEL_RGBSDA_GREEN) | uint8_t(KHR_DF_SAMPLE_DATATYPE_SIGNED | KHR_DF_SAMPLE_DATATYPE_FLOAT); + dfSamples[2].channelType = + uint8_t(KHR_DF_CHANNEL_RGBSDA_BLUE) | uint8_t(KHR_DF_SAMPLE_DATATYPE_SIGNED | KHR_DF_SAMPLE_DATATYPE_FLOAT); + dfSamples[3].channelType = + uint8_t(KHR_DF_CHANNEL_RGBSDA_ALPHA) | uint8_t(KHR_DF_SAMPLE_DATATYPE_SIGNED | KHR_DF_SAMPLE_DATATYPE_FLOAT); + break; + default: + return "The writer has no method to write the Data Format Descriptor for VkFormat " + std::to_string(format) + "."; + } + + // In the case of supercompressed formats, we have to set all bytesPlane + // fields to 0 per the "DFD for Supercompressed Data" section. + if(writeSettings.supercompression != WriteSupercompressionType::NONE) + { + dfdBlock.bytesPlane0 = 0; + dfdBlock.bytesPlane1 = 0; + dfdBlock.bytesPlane2 = 0; + dfdBlock.bytesPlane3 = 0; + dfdBlock.bytesPlane4 = 0; + dfdBlock.bytesPlane5 = 0; + dfdBlock.bytesPlane6 = 0; + dfdBlock.bytesPlane7 = 0; + } + + // Compute sizes + dfdBlock.descriptorBlockSize = sizeof(dfdBlock) + SizeofVector(dfSamples); + const uint32_t dfdTotalSize = dfdBlock.descriptorBlockSize + sizeof(uint32_t); + + // Write the Data Format Descriptor + if(!output.write(reinterpret_cast(&dfdTotalSize), sizeof(dfdTotalSize))) + { + return "Writing dfdTotalSize failed."; + } + + if(!output.write(reinterpret_cast(&dfdBlock), sizeof(dfdBlock))) + { + return "Writing the Basic Data Format Descriptor failed."; + } + + if(!output.write(reinterpret_cast(dfSamples.data()), SizeofVector(dfSamples))) + { + return "Writing the samples of the Basic Data Format Descriptor failed."; + } + + // Also set dfdByteLength now. + header.dfdByteLength = dfdTotalSize; + + //--------------------------------------------------------------------------- + // Key/Value Data + + // Fill in the KTXwriter field if it's not already assigned. + if(key_value_data.find("KTXwriter") == key_value_data.end()) + { + key_value_data["KTXwriter"] = StringToCharVector("nvpro-samples' nv_ktx version 1"); + } + + // We now know the offset of the key/value data. + header.kvdByteOffset = static_cast(output.tellp() - start_pos); + header.kvdByteLength = 0; + // Write the key/value data. + for(const auto& kvp : key_value_data) + { + // Include the null character on the key, but note that the values already + // include it (and may not be strings!) + const uint32_t keySizeWithNull = static_cast(kvp.first.size() + 1); + const uint32_t valueSize = static_cast(kvp.second.size()); + // Write key and value byte length. Does not include padding! + const uint32_t keyAndValueByteLength = keySizeWithNull + valueSize; + if(!output.write(reinterpret_cast(&keyAndValueByteLength), sizeof(uint32_t))) + { + return "Writing keyAndValueByteLength failed."; + } + if(!output.write(kvp.first.c_str(), keySizeWithNull)) + { + return "Writing a key-value pair failed."; + } + if(!output.write(reinterpret_cast(kvp.second.data()), valueSize)) + { + return "Writing a key-value pair failed."; + } + + // Write up to 4 null characters + std::array nulls = {'\0', '\0', '\0', '\0'}; + const size_t valuePaddingSize = RoundUp(keyAndValueByteLength, 4) - keyAndValueByteLength; + assert(valuePaddingSize < 4); + if(!output.write(nulls.data(), valuePaddingSize)) + { + return "Writing value padding failed."; + } + + header.kvdByteLength += + static_cast(sizeof(uint32_t)) + keyAndValueByteLength + static_cast(valuePaddingSize); + } + + //--------------------------------------------------------------------------- + // Section 6 + // Currently no Basis supercompression, so no need for alignment here. + assert(header.sgdByteLength == 0); + + //--------------------------------------------------------------------------- + // Section 7, the Mip Level Array + // This is also where we perform Zstd supercompression! + + // First get the texel block size. + size_t texel_block_size; + ErrorWithText maybeError = ExportSizeExtended(1, 1, 1, format, texel_block_size, writeSettings.custom_size_callback); + if(maybeError.has_value()) + { + return "Error getting the texel block size for VkFormat " + std::to_string(format) + "!"; + } + +// Zstandard supercompression context +#ifdef NVP_SUPPORTS_ZSTD + ScopedZstdCContext zstdContext; + int zstd_clamped_supercompression_level = writeSettings.supercompression_level; +#endif + if(writeSettings.supercompression == WriteSupercompressionType::ZSTD) + { +#ifdef NVP_SUPPORTS_ZSTD + zstdContext.Init(); + if(zstdContext.pCtx == nullptr) + { + return "Initializing the Zstandard context for supercompression failed!"; + } + + // Clamp the compression level to Zstandard's min and max + const int zstdMinLevel = ZSTD_minCLevel(); + const int zstdMaxLevel = ZSTD_maxCLevel(); + assert(zstdMaxLevel >= zstdMinLevel); + if(zstd_clamped_supercompression_level < zstdMinLevel) + zstd_clamped_supercompression_level = zstdMinLevel; + if(zstd_clamped_supercompression_level > zstdMaxLevel) + zstd_clamped_supercompression_level = zstdMaxLevel; +#else + return "Zstandard supercompression was selected for KTX2 writing, but nv_ktx was built without Zstd!"; +#endif + } + + // Write mips from smallest to largest. + for(int64_t mip = static_cast(num_mips) - 1; mip >= 0; mip--) + { + // First the mip padding if not supercompressed: + if(writeSettings.supercompression == WriteSupercompressionType::NONE) + { + const size_t pos_from_start = output.tellp() - start_pos; + const size_t mipPaddingSize = RoundUp(pos_from_start, LCM4(texel_block_size)) - pos_from_start; + if(mipPaddingSize > 0) + { + // NOTE: Could be better + std::vector nulls(mipPaddingSize, 0); + if(!output.write(nulls.data(), nulls.size())) + { + return "Writing mip padding failed."; + } + } + } + // We now know levels[mip].byteOffset, which comes after mip padding. + levelIndex[mip].byteOffset = output.tellp() - start_pos; + + const size_t mipWidth = std::max(1u, mip_0_width >> mip); + const size_t mipHeight = std::max(1u, mip_0_height >> mip); + const size_t mipDepth = std::max(1u, mip_0_depth >> mip); + + // The size of each subresource of this mip in bytes. + size_t subresource_size_bytes = 0; + UNWRAP_ERROR(ExportSizeExtended(mipWidth, mipHeight, mipDepth, format, subresource_size_bytes, writeSettings.custom_size_callback)); + + // Compute the size of this mip in bytes. + levelIndex[mip].uncompressedByteLength = size_t(num_layers_or_1) * size_t(num_faces) * subresource_size_bytes; + + // If not supercompressing, write each face to the file. + if(writeSettings.supercompression == WriteSupercompressionType::NONE) + { + for(uint32_t layer = 0; layer < num_layers_or_1; layer++) + { + for(uint32_t face = 0; face < num_faces; face++) + { + const std::vector& this_subresource = subresource(static_cast(mip), layer, face); + assert(this_subresource.size() == subresource_size_bytes); + if(!output.write(this_subresource.data(), this_subresource.size())) + { + return "Writing mip " + std::to_string(mip) + " layer " + std::to_string(layer) + " face " + + std::to_string(face) + " failed."; + } + } + } + levelIndex[mip].byteLength = levelIndex[mip].uncompressedByteLength; + } + else + { +// We currently only support Zstd for writing. +#ifndef NVP_SUPPORTS_ZSTD + return "Zstandard supercompression was selected, but nv_ktx was built without Zstd and execution reached the " + "levelImages loop. This should never happen."; +#else + if(writeSettings.supercompression != WriteSupercompressionType::ZSTD) + { + return "Only Zstandard supercompression is currently supported."; + } + // Concatenate all face data into a single buffer. + // (Note: could potentially have lower peak memory usage but be more + // complex using the Zstandard streaming API.) + std::vector rawData; + { + UNWRAP_ERROR(ResizeVectorOrError(rawData, levelIndex[mip].uncompressedByteLength)); + size_t pos_in_raw_data = 0; + for(uint32_t layer = 0; layer < num_layers_or_1; layer++) + { + for(uint32_t face = 0; face < num_faces; face++) + { + const std::vector& this_subresource = subresource(uint32_t(mip), layer, face); + assert(this_subresource.size() == subresource_size_bytes); + memcpy(&rawData[pos_in_raw_data], this_subresource.data(), this_subresource.size()); + pos_in_raw_data += this_subresource.size(); + } + } + } + + // Also allocate a buffer with the maximum possible compressed size needed. + // (Note that this is always larger than the source!) + // Also note that we'll always write the supercompressed data even when + // it's larger, as the client controls whether supercompression is used. + const size_t fullMipUncompressedLength = levelIndex[mip].uncompressedByteLength; + const size_t supercompressedMaxSize = ZSTD_COMPRESSBOUND(fullMipUncompressedLength); + std::vector supercompressedData; + try + { + supercompressedData.resize(supercompressedMaxSize); + } + catch(...) + { + return "Allocating memory for Zstandard supercompressed output failed!"; + } + + // Compress! + size_t errOrSize = ZSTD_compressCCtx(zstdContext.pCtx, supercompressedData.data(), supercompressedData.size(), + rawData.data(), rawData.size(), zstd_clamped_supercompression_level); + if(ZSTD_isError(errOrSize)) + { + return "Zstandard supercompression returned error " + std::to_string(errOrSize) + "."; + } + + if(errOrSize > supercompressedData.size()) + { + assert(false); // This should never happen + return "ZSTD_compressCCtx returned a number that was larger than the size of the supercompressed data " + "buffer."; + } + + // Write the supercompressed data to the file. + if(!output.write(supercompressedData.data(), errOrSize)) + { + return "Writing mip " + std::to_string(mip) + "'s supercompressed data to the file failed!"; + } + levelIndex[mip].byteLength = errOrSize; +#endif + } + } + + // Now, fill in the header, then go back and write the identifier, header, and level index. + header.vkFormat = format; + switch(format) + { + case VK_FORMAT_R16_SFLOAT: + case VK_FORMAT_R16G16_SFLOAT: + case VK_FORMAT_R16G16B16A16_SFLOAT: + header.typeSize = 2; + break; + case VK_FORMAT_R32_SFLOAT: + case VK_FORMAT_R32G32_SFLOAT: + case VK_FORMAT_R32G32B32A32_SFLOAT: + header.typeSize = 4; + break; + default: + header.typeSize = 1; + break; + } + header.pixelWidth = mip_0_width; + header.pixelHeight = mip_0_height; + header.pixelDepth = mip_0_depth; + header.layerCount = num_layers_possibly_0; + header.faceCount = num_faces; + header.levelCount = app_should_generate_mips ? 0 : num_mips; + switch(writeSettings.supercompression) + { + case WriteSupercompressionType::NONE: + header.supercompressionScheme = 0; + break; + case WriteSupercompressionType::ZSTD: + header.supercompressionScheme = 2; + break; + default: + return "Unsupported WriteSupercompression type while writing KTX2 header."; + } + + output.seekp(start_pos, std::ios::beg); + output.write(reinterpret_cast(ktx2Identifier), IDENTIFIER_LEN); + output.write(reinterpret_cast(&header), sizeof(header)); + output.write(reinterpret_cast(levelIndex.data()), SizeofVector(levelIndex)); + + // And we're done! + return {}; +} + +ErrorWithText KTXImage::writeKTX2File(const char* filename, const WriteSettings& writeSettings) +{ + std::ofstream output(filename, std::ofstream::binary | std::ofstream::out | std::ofstream::trunc); + return writeKTX2Stream(output, writeSettings); +} + +//----------------------------------------------------------------------------- +// KTX1/KTX2 READING BRANCH +//----------------------------------------------------------------------------- + +ErrorWithText KTXImage::readFromStream(std::istream& input, const ReadSettings& readSettings) +{ + // Read the identifier. + uint8_t identifier[IDENTIFIER_LEN]{}; + if(!input.read(reinterpret_cast(identifier), IDENTIFIER_LEN)) + { + return "Reading the identifier failed!"; + } + + // Check if the identifier matches either the KTX 1 identifier or the KTX 2 identifier. + if(memcmp(identifier, ktx1Identifier, IDENTIFIER_LEN) == 0) + { + read_ktx_version = 1; + return readFromKTX1Stream(input, readSettings); + } + else if(memcmp(identifier, ktx2Identifier, IDENTIFIER_LEN) == 0) + { + read_ktx_version = 2; + return readFromKTX2Stream(input, readSettings); + } + + // Otherwise, + return "Not a KTX1 or KTX2 file (first 12 bytes weren't a valid identifier)."; +} + +ErrorWithText KTXImage::readFromFile(const char* filename, const ReadSettings& readSettings) +{ + std::ifstream input_stream(filename, std::ifstream::in | std::ifstream::binary); + return readFromStream(input_stream, readSettings); +} + +} // namespace nv_ktx diff --git a/nvpro_core_legacy/fileformats/nv_ktx.h b/nvpro_core_legacy/fileformats/nv_ktx.h new file mode 100644 index 0000000..48edbb6 --- /dev/null +++ b/nvpro_core_legacy/fileformats/nv_ktx.h @@ -0,0 +1,321 @@ +/* + * Copyright (c) 2021-2024, NVIDIA CORPORATION. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-FileCopyrightText: Copyright (c) 2021-2024 NVIDIA CORPORATION + * SPDX-License-Identifier: Apache-2.0 + */ + +/** @DOC_START + +> A mostly self-contained reader and writer for KTX2 files and reader for KTX1 +> files. + +Relies on Vulkan (for KTX2), GL (for KTX1), and the Khronos Data Format. + +Sample usage for reading files: + +```cpp +KTXImage image; +ErrorWithText maybe_error = image.readFromFile("data/image.ktx2", {}); +if(maybe_error.has_value()) +{ + // Do something with the error message, maybe_error.value() +} +else +{ + // Access subresources using image.subresource(...), and upload them + // to the GPU using your graphics API of choice. +} +``` + +Define `NVP_SUPPORTS_ZSTD`, `NVP_SUPPORTS_GZLIB`, and `NVP_SUPPORTS_BASISU` to +include the Zstd, Zlib, and Basis Universal headers respectively, and to +enable reading these formats. This will also enable writing Zstd and +Basis Universal-compressed formats. +If you're using this inside the nvpro-samples framework, you can add all +three quickly by adding `_add_package_KTX()` to your dependencies +in CMakeLists.txt. + +@DOC_END */ + +#ifndef __NV_KTX_H__ +#define __NV_KTX_H__ + +#include +#include +#include +#include +#include +#include +#include + +namespace nv_ktx { +// These functions return an empty std::optional if they succeeded, and a +// value with text describing the error if they failed. +using ErrorWithText = std::optional; + +// KTX files can store key/value pairs, where the key is a UTF-8 +// null-terminated string and the value is an arbitrary byte array +// (but often a null-terminated ASCII string). +using KeyValueData = std::map>; + +// Apps can define custom functions that return the size in bytes of new +// VkFormats. Functions of this type should take in the width, height, and +// depth of a format in the first 3 parameters, the VkFormat in the 4th, and +// return the size in bytes of an image with those dimensions in the last +// parameter. Passing in an image size of (1, 1, 1) should give the size of +// the smallest possible nonzero image. If the format is unknown, it should +// return a string; if it succeeds, it should return {}. +using CustomExportSizeFuncPtr = ErrorWithText (*)(size_t, size_t, size_t, VkFormat, size_t&); + +// Configurable settings for reading files. This is a struct so that it can +// be extended in the future. +struct ReadSettings +{ + // Whether to read all mips (true), or only the base mip (false). + bool mips = true; + // See docs for CustomExportSizeFuncPtr + CustomExportSizeFuncPtr custom_size_callback = nullptr; + // If true, the reader will validate that the KTX file contains at least 1 + // byte per subresource. This will involve seeking to the end of the stream + // to determine the length of the stream or file. + bool validate_input_size = true; + // Limits the maximum uncompressed image size size per mip and + // supercompression global data size in bytes; produces errors for any files + // with a larger size. This allows certain types of issues with + // supercompression to be caught before the rest of the file is loaded. If + // one wants to allow larger images, they should set this to a larger value + // (such as UINT64_MAX). + uint64_t max_resource_size_in_bytes = 1ULL << 30; + // By default, UASTC is transcoded to BC7 instead of ASTC. Setting this to + // true will transcode UASTC to ASTC. + bool device_supports_astc = false; +}; + +enum class WriteSupercompressionType +{ + NONE, // Apply no supercompression, or use the supercompression included with ETC1S. + ZSTD, // ZStandard +}; + +enum class EncodeRGBA8ToFormat +{ + NO, // Don't encode the data to a Basis Universal format. + // For the following modes, the image format must be VK_FORMAT_B8G8R8A8_SRGB + // or VK_FORMAT_B8G8R8A8_UNORM. Basis Universal will then be called to encode + // the data and write the KTX2 file. + UASTC, // Highest-quality format; RGBA data, usually decodes to ASTC or BC7. + ETC1S_RGBA, // RGBA data; usually decodes to BC7 (8bpp). + ETC1S_RGB // RGB channels only; usually decodes to BC7 (8bpp). +}; + +enum class UASTCEncodingQuality +{ + FASTEST = 0, + FASTER = 1, + DEFAULT = 2, + SLOWER = 3, + VERYSLOW = 4 +}; + +// Configurable settings for writing files. This is a struct so that it can +// be extended in the future. +struct WriteSettings +{ + // Type of supercompression to apply if any + WriteSupercompressionType supercompression = WriteSupercompressionType::NONE; + // Supercompression quality level for Zstandard, which is supported by all + // formats other than ETC1s. This ranges from ZSTD_minCLevel() to + // ZSTD_maxCLevel(). + // Higher levels are slower. + int supercompression_level = 0; + // See docs for CustomExportSizeFuncPtr + CustomExportSizeFuncPtr custom_size_callback = nullptr; + // Whether to encode the data to a Basis format. If not NO, the image format + // must be VK_FORMAT_B8G8R8A8_SRGB or VK_FORMAT_B8G8R8A8_UNORM. + EncodeRGBA8ToFormat encode_rgba8_to_format = EncodeRGBA8ToFormat::NO; + // Applies when encoding RGBA8 to UASTC. Corresponds to cPackUASTCLevel in Basis. + UASTCEncodingQuality uastc_encoding_quality = UASTCEncodingQuality::DEFAULT; + // Applies when encoding RGBA8 to ETC1S. Ranges from 0 to BASISU_MAX_COMPRESSION_LEVEL. + // Higher levels are slower. + int etc1s_encoding_level = 3; + // Lambda for UASTC Rate-Distortion Optimization, from 0 to 50. Higher numbers + // compress more at lower quality. + float rdo_lambda = 10.0f; + // Enables Rate-Distortion Optimization for ETC1S. + bool rdo_etc1s = true; +}; + +// An enum for each of the possible elements in a ktxSwizzle value. +enum class KTX_SWIZZLE +{ + ZERO = 0, + ONE, + R, + G, + B, + A +}; + +// Represents the inflated contents of a KTX or KTX2 file. This includes: +// - the VkFormat of the image data, +// - the formatted (i.e. encoded/compressed) image data for +// each element, mip level, and face, +// - and the table of key/value pairs. +// The stored data is not supercompressed, as we supercompress and inflate when +// writing and reading to and from KTX files. +struct KTXImage +{ +public: + // Clears, then sets up storage for an image with the given dimensions. These + // can be set to 0 instead of 1 along each dimension to indicate different + // texture types, such as 1D or 2D. See table 4.1 in the KTX 2.0 + // specification, or the comments on these variables below. + // + // Width, height, depth, and VkFormat should be set manually using the + // member variables. This does not allocate the encoded subresources. + // This can fail e.g. if the parameters are so large that the app runs out of + // memory when allocating space. + ErrorWithText allocate( + // The number of mips (levels) in the image, including the base mip. + uint32_t _num_mips = 1, + // The number of array elements (layers) in the image. 0 for a non-array + // texture (this has meaning in OpenGL, but not in Vulkan). + // If representing an incomplete cube map (i.e. a cube map where not all + // faces are stored), this is + // (faces per cube map) * (number of cube maps) + // and _num_faces is 1. + uint32_t _num_layers = 0, + // The number of faces in the image (1 for a 2D texture, 6 for a cube map) + uint32_t _num_faces = 1); + + // Clears all stored image and table data. + void clear(); + + // Determines the VkImageType corresponding to this KTXImage based on the + // dimensions, according to Table 4.1 of the KTX 2.0 specification. + // In the invalid case where mip_0_width == 0, returns VK_IMAGE_TYPE_1D. + VkImageType getImageType() const; + + // Returns whether the loaded file was a KTX1 (1) or KTX2 (2) file. + uint32_t getKTXVersion() const; + + // Mutably accesses the subresource at the given mip, layer, and face. If the + // given indices are out of range, throws an std::out_of_range exception. + std::vector& subresource(uint32_t mip = 0, uint32_t layer = 0, uint32_t face = 0); + + // Reads this structure from a KTX stream, advancing the stream as well. + // Returns an optional error message if the read failed. + ErrorWithText readFromStream(std::istream& input, // The input stream, at the start of the KTX data + const ReadSettings& readSettings); // Settings for the reader + + // Wrapper for readFromStream for a filename. + ErrorWithText readFromFile(const char* filename, // The .ktx or .ktx2 file to read from. + const ReadSettings& readSettings); // Settings for the reader + + // Writes this structure in KTX2 format to a stream. + ErrorWithText writeKTX2Stream(std::ostream& output, // The output stream, at the point to start writing + const WriteSettings& writeSettings); // Settings for the writer + + // Wrapper for writeKTX2Stream for a filename. Customarily, the filename ends + // in .ktx2. + ErrorWithText writeKTX2File(const char* filename, // The output stream, at the point to start writing + const WriteSettings& writeSettings); // Settings for the writer + +public: + // These members can be freely modified. + + // The format of the data in this image. When reading a KTX1 file (which + // specifies a GL format), we automatically convert to a VkFormat. + VkFormat format = VK_FORMAT_UNDEFINED; + // The width in pixels of the largest mip. Must be > 0. + uint32_t mip_0_width = 1; + // The height in pixels of the largest mip. 0 for a 1D texture. + uint32_t mip_0_height = 0; + // The depth in pixels of the largest mip. 0 for a 1D or 2D texture. + uint32_t mip_0_depth = 0; + // The number of mips (levels) in the image, including the base mip. Always + // greater than or equal to 1. + uint32_t num_mips = 1; + // The number of array elements (layers) in the image. 0 for a non-array + // texture (this has meaning in OpenGL, but not in Vulkan). + // If representing an incomplete cube map (i.e. a cube map where not all + // faces are stored), this is + // (faces per cube map) * (number of cube maps) + // and _num_faces is 1. + uint32_t num_layers_possibly_0 = 0; + // The number of faces in the image (1 for a 2D texture, 6 for a cube map) + uint32_t num_faces = 0; + // This file's key/value table. Note that for the ktxSwizzle key, one should + // use the swizzle element instead! + KeyValueData key_value_data{}; + + // KTX files can set the number of mips to 0 to indicate that + // the application should generate a full mip chain. + bool app_should_generate_mips = false; + + // Whether this data represents an image with premultiplied alpha + // (generally, storing (r*a, g*a, b*a, a) instead of (r, g, b, a)). + // This is used when writing the Data Format Descriptor in KTX2. + bool is_premultiplied = false; + + // Whether the Data Format Descriptor transferFunction for this data is + // KHR_DF_TRANSFER_SRGB. (Otherwise, it is KHR_DF_TRANSFER_LINEAR.) + // More informally, says "when a GPU accesses this texture, should it perform + // sRGB-to-linear conversion". For instance, this is usually true for color + // textures, and false for normal maps and depth maps. Validation requires + // this to match the VkFormat - except in special cases such as Basis UASTC + // and Universal. + bool is_srgb = true; + + // Specifies how the red, green, blue, and alpha channels should be sampled + // from the source data. For instance, {R, G, ZERO, ONE} means the red and + // green channels should be sampled from the red and green texture components + // respectively, the blue channel is sampled as 0, and the alpha channel is + // sampled as 1. + // Note that values here should be read in lieu of the key_value_data's + // ktxSwizzle key! This is to make Basis Universal usage easier in the future. + std::array swizzle = {KTX_SWIZZLE::R, KTX_SWIZZLE::G, KTX_SWIZZLE::B, KTX_SWIZZLE::A}; + + // The loader will transcode supercompressed files to an appropriate format + // when supercompression libraries are available, so a loaded supercompressed + // file typically looks like a regular BC4, BC7 or ASTC file. One can read + // this field to determine what the original supercompressed format was. + enum class InputSupercompression + { + eNone, + eBasisUASTC, + eBasisETC1S + } input_supercompression = InputSupercompression::eNone; + +private: + // Private functions used by readFromStream after it determines whether the + // stream is a KTX1 or KTX2 stream. + ErrorWithText readFromKTX1Stream(std::istream& input, const ReadSettings& readSettings); + ErrorWithText readFromKTX2Stream(std::istream& input, const ReadSettings& readSettings); + + // Whether the loaded file was a KTX1 (1) or KTX2 (2) file. + uint32_t read_ktx_version = 1; + +private: + // A structure containing all the image's encoded, non-supercompressed + // image data. We store this in a buffer with an entry per subresource, and + // provide accessors to it. + std::vector> data; +}; + +} // namespace nv_ktx + +#endif diff --git a/nvpro_core_legacy/fileformats/texture_formats.cpp b/nvpro_core_legacy/fileformats/texture_formats.cpp new file mode 100644 index 0000000..e1069c2 --- /dev/null +++ b/nvpro_core_legacy/fileformats/texture_formats.cpp @@ -0,0 +1,728 @@ +/* + * Copyright (c) 2024, NVIDIA CORPORATION. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION + * SPDX-License-Identifier: Apache-2.0 + */ + +// We'll use the X macro (https://en.wikipedia.org/wiki/X_macro) +// strategy here; because we have some duplicate formats -- multiple GL format +// combinations can correspond to the same DXGI or Vulkan format, for instance +// -- we'll build tables the first time they're requested. +// In cases where + +#include "texture_formats.h" + +#include "dxgiformat.h" // Included in nvpro_core's dxh subproject + +#include // For std::hash +#include +#include +#include +#include + +// Custom hash for OpenGLFormat +template <> +struct std::hash +{ + size_t operator()(const texture_formats::OpenGLFormat& c) const + { + return std::hash()(c.internalFormat ^ std::hash()(c.format ^ std::hash()(c.type))); + } +}; + +namespace texture_formats { + +// GL enums, included here so that we don't have to include the OpenGL headers, +// since the include path for these may depend on the place in which this is included. +#define NV_GL_BYTE 0x1400 +#define NV_GL_UNSIGNED_BYTE 0x1401 +#define NV_GL_SHORT 0x1402 +#define NV_GL_UNSIGNED_SHORT 0x1403 +#define NV_GL_INT 0x1404 +#define NV_GL_UNSIGNED_INT 0x1405 +#define NV_GL_FLOAT 0x1406 +#define NV_GL_HALF_FLOAT 0x140B +#define NV_GL_STENCIL_INDEX 0x1901 +#define NV_GL_DEPTH_COMPONENT 0x1902 +#define NV_GL_RED 0x1903 +#define NV_GL_GREEN 0x1904 +#define NV_GL_BLUE 0x1905 +#define NV_GL_ALPHA 0x1906 +#define NV_GL_RGB 0x1907 +#define NV_GL_RGBA 0x1908 +#define NV_GL_LUMINANCE 0x1909 +#define NV_GL_LUMINANCE_ALPHA 0x190A +#define NV_GL_UNSIGNED_SHORT_4_4_4_4 0x8033 +#define NV_GL_UNSIGNED_SHORT_5_5_5_1 0x8034 +#define NV_GL_ALPHA8 0x803C +#define NV_GL_LUMINANCE8 0x8040 +#define NV_GL_LUMINANCE8_ALPHA8 0x8045 +#define NV_GL_RGB8 0x8051 +#define NV_GL_RGB16 0x8054 +#define NV_GL_RGBA4 0x8056 +#define NV_GL_RGB5_A1 0x8057 +#define NV_GL_RGBA8 0x8058 +#define NV_GL_RGB10_A2 0x8059 +#define NV_GL_RGBA16 0x805B +#define NV_GL_BGR 0x80E0 +#define NV_GL_BGRA 0x80E1 +#define NV_GL_DEPTH_COMPONENT16 0x81A5 +#define NV_GL_DEPTH_COMPONENT24 0x81A6 +#define NV_GL_DEPTH_COMPONENT32 0x81A7 +#define NV_GL_R8 0x8229 +#define NV_GL_R16 0x822A +#define NV_GL_RG8 0x822B +#define NV_GL_RG16 0x822C +#define NV_GL_R16F 0x822D +#define NV_GL_R32F 0x822E +#define NV_GL_RG16F 0x822F +#define NV_GL_RG32F 0x8230 +#define NV_GL_RG 0x8227 +#define NV_GL_RG_INTEGER 0x8228 +#define NV_GL_R8 0x8229 +#define NV_GL_R16 0x822A +#define NV_GL_RG8 0x822B +#define NV_GL_RG16 0x822C +#define NV_GL_R16F 0x822D +#define NV_GL_R32F 0x822E +#define NV_GL_RG16F 0x822F +#define NV_GL_RG32F 0x8230 +#define NV_GL_R8I 0x8231 +#define NV_GL_R8UI 0x8232 +#define NV_GL_R16I 0x8233 +#define NV_GL_R16UI 0x8234 +#define NV_GL_R32I 0x8235 +#define NV_GL_R32UI 0x8236 +#define NV_GL_RG8I 0x8237 +#define NV_GL_RG8UI 0x8238 +#define NV_GL_RG16I 0x8239 +#define NV_GL_RG16UI 0x823A +#define NV_GL_RG32I 0x823B +#define NV_GL_RG32UI 0x823C +#define NV_GL_UNSIGNED_SHORT_5_6_5 0x8363 +#define NV_GL_UNSIGNED_SHORT_5_6_5_REV 0x8364 +#define NV_GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366 +#define NV_GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 +#define NV_GL_COMPRESSED_RGB_S3TC_DXT1_EXT 0x83F0 +#define NV_GL_COMPRESSED_RGBA_S3TC_DXT1_EXT 0x83F1 +#define NV_GL_COMPRESSED_RGBA_S3TC_DXT3_EXT 0x83F2 +#define NV_GL_COMPRESSED_RGBA_S3TC_DXT5_EXT 0x83F3 +#define NV_GL_DEPTH_STENCIL 0x84F9 +#define NV_GL_UNSIGNED_INT_24_8 0x84FA +#define NV_GL_RGBA32F 0x8814 +#define NV_GL_RGB32F 0x8815 +#define NV_GL_RGBA16F 0x881A +#define NV_GL_RGB16F 0x881B +#define NV_GL_DEPTH24_STENCIL8 0x88F0 +#define NV_GL_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT 0x8A54 +#define NV_GL_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT 0x8A55 +#define NV_GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT 0x8A56 +#define NV_GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT 0x8A57 +#define NV_GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG 0x8C00 +#define NV_GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG 0x8C01 +#define NV_GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG 0x8C02 +#define NV_GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG 0x8C03 +#define NV_GL_R11F_G11F_B10F 0x8C3A +#define NV_GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B +#define NV_GL_RGB9_E5 0x8C3D +#define NV_GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E +#define NV_GL_SRGB8 0x8C41 +#define NV_GL_SRGB_ALPHA 0x8C42 +#define NV_GL_SRGB8_ALPHA8 0x8C43 +#define NV_GL_COMPRESSED_SRGB_S3TC_DXT1_EXT 0x8C4C +#define NV_GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT 0x8C4D +#define NV_GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT 0x8C4E +#define NV_GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT 0x8C4F +#define NV_GL_DEPTH_COMPONENT32F 0x8CAC +#define NV_GL_DEPTH32F_STENCIL8 0x8CAD +#define NV_GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD +#define NV_GL_STENCIL_INDEX8 0x8D48 +#define NV_GL_RGB565 0x8D62 +#define NV_GL_RGBA32UI 0x8D70 +#define NV_GL_RGB32UI 0x8D71 +#define NV_GL_RGBA16UI 0x8D76 +#define NV_GL_RGB16UI 0x8D77 +#define NV_GL_RGBA8UI 0x8D7C +#define NV_GL_RGB8UI 0x8D7D +#define NV_GL_RGBA32I 0x8D82 +#define NV_GL_RGB32I 0x8D83 +#define NV_GL_RGBA16I 0x8D88 +#define NV_GL_RGB16I 0x8D89 +#define NV_GL_RGBA8I 0x8D8E +#define NV_GL_RGB8I 0x8D8F +#define NV_GL_RED_INTEGER 0x8D94 +#define NV_GL_RGB_INTEGER 0x8D98 +#define NV_GL_RGBA_INTEGER 0x8D99 +#define NV_GL_BGR_INTEGER 0x8D9A +#define NV_GL_BGRA_INTEGER 0x8D9B +#define NV_GL_COMPRESSED_RED_RGTC1_EXT 0x8DBB +#define NV_GL_COMPRESSED_SIGNED_RED_RGTC1_EXT 0x8DBC +#define NV_GL_COMPRESSED_RED_GREEN_RGTC2_EXT 0x8DBD +#define NV_GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT 0x8DBE +#define NV_GL_COMPRESSED_RGBA_BPTC_UNORM_ARB 0x8E8C +#define NV_GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB 0x8E8D +#define NV_GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB 0x8E8E +#define NV_GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB 0x8E8F +#define NV_GL_R8_SNORM 0x8F94 +#define NV_GL_RG8_SNORM 0x8F95 +#define NV_GL_RGB8_SNORM 0x8F96 +#define NV_GL_RGBA8_SNORM 0x8F97 +#define NV_GL_R16_SNORM 0x8F98 +#define NV_GL_RG16_SNORM 0x8F99 +#define NV_GL_RGB16_SNORM 0x8F9A +#define NV_GL_RGBA16_SNORM 0x8F9B +#define NV_GL_SR8_EXT 0x8FBD +#define NV_GL_SRG8_EXT 0x8FBE +#define NV_GL_RGB10_A2UI 0x906F +#define NV_GL_COMPRESSED_RGBA_PVRTC_2BPPV2_IMG 0x9137 +#define NV_GL_COMPRESSED_RGBA_PVRTC_4BPPV2_IMG 0x9138 +#define NV_GL_COMPRESSED_R11_EAC 0x9270 +#define NV_GL_COMPRESSED_SIGNED_R11_EAC 0x9271 +#define NV_GL_COMPRESSED_RG11_EAC 0x9272 +#define NV_GL_COMPRESSED_SIGNED_RG11_EAC 0x9273 +#define NV_GL_COMPRESSED_RGB8_ETC2 0x9274 +#define NV_GL_COMPRESSED_SRGB8_ETC2 0x9275 +#define NV_GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 0x9276 +#define NV_GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 0x9277 +#define NV_GL_COMPRESSED_RGBA8_ETC2_EAC 0x9278 +#define NV_GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC 0x9279 +#define NV_GL_COMPRESSED_RGBA_ASTC_4x4_KHR 0x93B0 +#define NV_GL_COMPRESSED_RGBA_ASTC_5x4_KHR 0x93B1 +#define NV_GL_COMPRESSED_RGBA_ASTC_5x5_KHR 0x93B2 +#define NV_GL_COMPRESSED_RGBA_ASTC_6x5_KHR 0x93B3 +#define NV_GL_COMPRESSED_RGBA_ASTC_6x6_KHR 0x93B4 +#define NV_GL_COMPRESSED_RGBA_ASTC_8x5_KHR 0x93B5 +#define NV_GL_COMPRESSED_RGBA_ASTC_8x6_KHR 0x93B6 +#define NV_GL_COMPRESSED_RGBA_ASTC_8x8_KHR 0x93B7 +#define NV_GL_COMPRESSED_RGBA_ASTC_10x5_KHR 0x93B8 +#define NV_GL_COMPRESSED_RGBA_ASTC_10x6_KHR 0x93B9 +#define NV_GL_COMPRESSED_RGBA_ASTC_10x8_KHR 0x93BA +#define NV_GL_COMPRESSED_RGBA_ASTC_10x10_KHR 0x93BB +#define NV_GL_COMPRESSED_RGBA_ASTC_12x10_KHR 0x93BC +#define NV_GL_COMPRESSED_RGBA_ASTC_12x12_KHR 0x93BD +#define NV_GL_COMPRESSED_RGBA_ASTC_3x3x3_OES 0x93C0 +#define NV_GL_COMPRESSED_RGBA_ASTC_4x3x3_OES 0x93C1 +#define NV_GL_COMPRESSED_RGBA_ASTC_4x4x3_OES 0x93C2 +#define NV_GL_COMPRESSED_RGBA_ASTC_4x4x4_OES 0x93C3 +#define NV_GL_COMPRESSED_RGBA_ASTC_5x4x4_OES 0x93C4 +#define NV_GL_COMPRESSED_RGBA_ASTC_5x5x4_OES 0x93C5 +#define NV_GL_COMPRESSED_RGBA_ASTC_5x5x5_OES 0x93C6 +#define NV_GL_COMPRESSED_RGBA_ASTC_6x5x5_OES 0x93C7 +#define NV_GL_COMPRESSED_RGBA_ASTC_6x6x5_OES 0x93C8 +#define NV_GL_COMPRESSED_RGBA_ASTC_6x6x6_OES 0x93C9 +#define NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR 0x93D0 +#define NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR 0x93D1 +#define NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR 0x93D2 +#define NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR 0x93D3 +#define NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR 0x93D4 +#define NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR 0x93D5 +#define NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR 0x93D6 +#define NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR 0x93D7 +#define NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR 0x93D8 +#define NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR 0x93D9 +#define NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR 0x93DA +#define NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR 0x93DB +#define NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR 0x93DC +#define NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR 0x93DD +#define NV_GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV2_IMG 0x93F0 +#define NV_GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV2_IMG 0x93F1 + +// A table of every combination we handle, in +// (DXGI, VK, glInternalFormat, glFormat, glType) order. +// Since multiple OpenGL formats can map to the same DXGI or Vulkan format: +// - REPVK will be called for repeated Vulkan formats +// - REPBOTH will be called if both repeat +#define FOR_EACH_FORMAT(DO, REPVK, REPBOTH) \ + DO(DXGI_FORMAT_A8_UNORM, VK_FORMAT_S8_UINT, NV_GL_STENCIL_INDEX8, NV_GL_STENCIL_INDEX, NV_GL_UNSIGNED_BYTE) \ + DO(DXGI_FORMAT_ASTC_10X10_UNORM, VK_FORMAT_ASTC_10x10_UNORM_BLOCK, NV_GL_COMPRESSED_RGBA_ASTC_10x10_KHR, 0, 0) \ + DO(DXGI_FORMAT_ASTC_10X10_UNORM_SRGB, VK_FORMAT_ASTC_10x10_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, 0, 0) \ + REPVK(DXGI_FORMAT_ASTC_10X10_TYPELESS, VK_FORMAT_ASTC_10x10_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, 0, 0) \ + DO(DXGI_FORMAT_ASTC_10X5_UNORM, VK_FORMAT_ASTC_10x5_UNORM_BLOCK, NV_GL_COMPRESSED_RGBA_ASTC_10x5_KHR, 0, 0) \ + DO(DXGI_FORMAT_ASTC_10X5_UNORM_SRGB, VK_FORMAT_ASTC_10x5_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR, 0, 0) \ + REPVK(DXGI_FORMAT_ASTC_10X5_TYPELESS, VK_FORMAT_ASTC_10x5_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR, 0, 0) \ + DO(DXGI_FORMAT_ASTC_10X6_UNORM, VK_FORMAT_ASTC_10x6_UNORM_BLOCK, NV_GL_COMPRESSED_RGBA_ASTC_10x6_KHR, 0, 0) \ + DO(DXGI_FORMAT_ASTC_10X6_UNORM_SRGB, VK_FORMAT_ASTC_10x6_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR, 0, 0) \ + REPVK(DXGI_FORMAT_ASTC_10X6_TYPELESS, VK_FORMAT_ASTC_10x6_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR, 0, 0) \ + DO(DXGI_FORMAT_ASTC_10X8_UNORM, VK_FORMAT_ASTC_10x8_UNORM_BLOCK, NV_GL_COMPRESSED_RGBA_ASTC_10x8_KHR, 0, 0) \ + DO(DXGI_FORMAT_ASTC_10X8_UNORM_SRGB, VK_FORMAT_ASTC_10x8_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR, 0, 0) \ + REPVK(DXGI_FORMAT_ASTC_10X8_TYPELESS, VK_FORMAT_ASTC_10x8_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR, 0, 0) \ + DO(DXGI_FORMAT_ASTC_12X10_UNORM, VK_FORMAT_ASTC_12x10_UNORM_BLOCK, NV_GL_COMPRESSED_RGBA_ASTC_12x10_KHR, 0, 0) \ + DO(DXGI_FORMAT_ASTC_12X10_UNORM_SRGB, VK_FORMAT_ASTC_12x10_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR, 0, 0) \ + REPVK(DXGI_FORMAT_ASTC_12X10_TYPELESS, VK_FORMAT_ASTC_12x10_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR, 0, 0) \ + DO(DXGI_FORMAT_ASTC_12X12_UNORM, VK_FORMAT_ASTC_12x12_UNORM_BLOCK, NV_GL_COMPRESSED_RGBA_ASTC_12x12_KHR, 0, 0) \ + DO(DXGI_FORMAT_ASTC_12X12_UNORM_SRGB, VK_FORMAT_ASTC_12x12_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR, 0, 0) \ + REPVK(DXGI_FORMAT_ASTC_12X12_TYPELESS, VK_FORMAT_ASTC_12x12_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR, 0, 0) \ + DO(DXGI_FORMAT_ASTC_4X4_UNORM, VK_FORMAT_ASTC_4x4_UNORM_BLOCK, NV_GL_COMPRESSED_RGBA_ASTC_4x4_KHR, 0, 0) \ + DO(DXGI_FORMAT_ASTC_4X4_UNORM_SRGB, VK_FORMAT_ASTC_4x4_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR, 0, 0) \ + REPVK(DXGI_FORMAT_ASTC_4X4_TYPELESS, VK_FORMAT_ASTC_4x4_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR, 0, 0) \ + DO(DXGI_FORMAT_ASTC_5X4_UNORM, VK_FORMAT_ASTC_5x4_UNORM_BLOCK, NV_GL_COMPRESSED_RGBA_ASTC_5x4_KHR, 0, 0) \ + DO(DXGI_FORMAT_ASTC_5X4_UNORM_SRGB, VK_FORMAT_ASTC_5x4_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR, 0, 0) \ + REPVK(DXGI_FORMAT_ASTC_5X4_TYPELESS, VK_FORMAT_ASTC_5x4_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR, 0, 0) \ + DO(DXGI_FORMAT_ASTC_5X5_UNORM, VK_FORMAT_ASTC_5x5_UNORM_BLOCK, NV_GL_COMPRESSED_RGBA_ASTC_5x5_KHR, 0, 0) \ + DO(DXGI_FORMAT_ASTC_5X5_UNORM_SRGB, VK_FORMAT_ASTC_5x5_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR, 0, 0) \ + REPVK(DXGI_FORMAT_ASTC_5X5_TYPELESS, VK_FORMAT_ASTC_5x5_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR, 0, 0) \ + DO(DXGI_FORMAT_ASTC_6X5_UNORM, VK_FORMAT_ASTC_6x5_UNORM_BLOCK, NV_GL_COMPRESSED_RGBA_ASTC_6x5_KHR, 0, 0) \ + DO(DXGI_FORMAT_ASTC_6X5_UNORM_SRGB, VK_FORMAT_ASTC_6x5_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR, 0, 0) \ + REPVK(DXGI_FORMAT_ASTC_6X5_TYPELESS, VK_FORMAT_ASTC_6x5_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR, 0, 0) \ + DO(DXGI_FORMAT_ASTC_6X6_UNORM, VK_FORMAT_ASTC_6x6_UNORM_BLOCK, NV_GL_COMPRESSED_RGBA_ASTC_6x6_KHR, 0, 0) \ + DO(DXGI_FORMAT_ASTC_6X6_UNORM_SRGB, VK_FORMAT_ASTC_6x6_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR, 0, 0) \ + REPVK(DXGI_FORMAT_ASTC_6X6_TYPELESS, VK_FORMAT_ASTC_6x6_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR, 0, 0) \ + DO(DXGI_FORMAT_ASTC_8X5_UNORM, VK_FORMAT_ASTC_8x5_UNORM_BLOCK, NV_GL_COMPRESSED_RGBA_ASTC_8x5_KHR, 0, 0) \ + DO(DXGI_FORMAT_ASTC_8X5_UNORM_SRGB, VK_FORMAT_ASTC_8x5_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR, 0, 0) \ + REPVK(DXGI_FORMAT_ASTC_8X5_TYPELESS, VK_FORMAT_ASTC_8x5_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR, 0, 0) \ + DO(DXGI_FORMAT_ASTC_8X6_UNORM, VK_FORMAT_ASTC_8x6_UNORM_BLOCK, NV_GL_COMPRESSED_RGBA_ASTC_8x6_KHR, 0, 0) \ + DO(DXGI_FORMAT_ASTC_8X6_UNORM_SRGB, VK_FORMAT_ASTC_8x6_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR, 0, 0) \ + REPVK(DXGI_FORMAT_ASTC_8X6_TYPELESS, VK_FORMAT_ASTC_8x6_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR, 0, 0) \ + DO(DXGI_FORMAT_ASTC_8X8_UNORM, VK_FORMAT_ASTC_8x8_UNORM_BLOCK, NV_GL_COMPRESSED_RGBA_ASTC_8x8_KHR, 0, 0) \ + DO(DXGI_FORMAT_ASTC_8X8_UNORM_SRGB, VK_FORMAT_ASTC_8x8_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR, 0, 0) \ + REPVK(DXGI_FORMAT_ASTC_8X8_TYPELESS, VK_FORMAT_ASTC_8x8_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR, 0, 0) \ + DO(DXGI_FORMAT_B5G5R5A1_UNORM, VK_FORMAT_R5G5B5A1_UNORM_PACK16, NV_GL_RGB5_A1, NV_GL_RGBA, NV_GL_UNSIGNED_SHORT_5_5_5_1) \ + DO(DXGI_FORMAT_B5G6R5_UNORM, VK_FORMAT_R5G6B5_UNORM_PACK16, NV_GL_RGB565, NV_GL_RGB, NV_GL_UNSIGNED_SHORT_5_6_5) \ + REPVK(DXGI_FORMAT_B8G8R8A8_TYPELESS, VK_FORMAT_B8G8R8A8_SRGB, NV_GL_SRGB8_ALPHA8, NV_GL_BGRA, NV_GL_UNSIGNED_BYTE) \ + DO(DXGI_FORMAT_B8G8R8A8_UNORM, VK_FORMAT_B8G8R8A8_UNORM, NV_GL_RGBA8, NV_GL_BGRA, NV_GL_UNSIGNED_BYTE) \ + DO(DXGI_FORMAT_B8G8R8A8_UNORM_SRGB, VK_FORMAT_B8G8R8A8_SRGB, NV_GL_SRGB8_ALPHA8, NV_GL_BGRA, NV_GL_UNSIGNED_BYTE) \ + REPVK(DXGI_FORMAT_B8G8R8X8_UNORM, VK_FORMAT_B8G8R8A8_UNORM, NV_GL_RGBA8, NV_GL_BGRA, NV_GL_UNSIGNED_BYTE) \ + DO(DXGI_FORMAT_BC1_UNORM, VK_FORMAT_BC1_RGBA_UNORM_BLOCK, NV_GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, 0, 0) \ + DO(DXGI_FORMAT_BC1_UNORM_SRGB, VK_FORMAT_BC1_RGBA_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, 0, 0) \ + REPVK(DXGI_FORMAT_BC1_TYPELESS, VK_FORMAT_BC1_RGBA_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, 0, 0) \ + DO(DXGI_FORMAT_BC2_UNORM, VK_FORMAT_BC2_UNORM_BLOCK, NV_GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, 0, 0) \ + DO(DXGI_FORMAT_BC2_UNORM_SRGB, VK_FORMAT_BC2_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, 0, 0) \ + REPVK(DXGI_FORMAT_BC2_TYPELESS, VK_FORMAT_BC2_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, 0, 0) \ + DO(DXGI_FORMAT_BC3_UNORM, VK_FORMAT_BC3_UNORM_BLOCK, NV_GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, 0, 0) \ + DO(DXGI_FORMAT_BC3_UNORM_SRGB, VK_FORMAT_BC3_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, 0, 0) \ + REPVK(DXGI_FORMAT_BC3_TYPELESS, VK_FORMAT_BC3_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, 0, 0) \ + DO(DXGI_FORMAT_BC4_SNORM, VK_FORMAT_BC4_SNORM_BLOCK, NV_GL_COMPRESSED_SIGNED_RED_RGTC1_EXT, 0, 0) \ + DO(DXGI_FORMAT_BC4_UNORM, VK_FORMAT_BC4_UNORM_BLOCK, NV_GL_COMPRESSED_RED_RGTC1_EXT, 0, 0) \ + REPVK(DXGI_FORMAT_BC4_TYPELESS, VK_FORMAT_BC4_UNORM_BLOCK, NV_GL_COMPRESSED_RED_RGTC1_EXT, 0, 0) \ + DO(DXGI_FORMAT_BC5_SNORM, VK_FORMAT_BC5_SNORM_BLOCK, NV_GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT, 0, 0) \ + DO(DXGI_FORMAT_BC5_UNORM, VK_FORMAT_BC5_UNORM_BLOCK, NV_GL_COMPRESSED_RED_GREEN_RGTC2_EXT, 0, 0) \ + REPVK(DXGI_FORMAT_BC5_TYPELESS, VK_FORMAT_BC5_UNORM_BLOCK, NV_GL_COMPRESSED_RED_GREEN_RGTC2_EXT, 0, 0) \ + DO(DXGI_FORMAT_BC6H_SF16, VK_FORMAT_BC6H_SFLOAT_BLOCK, NV_GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB, 0, 0) \ + DO(DXGI_FORMAT_BC6H_UF16, VK_FORMAT_BC6H_UFLOAT_BLOCK, NV_GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB, 0, 0) \ + REPVK(DXGI_FORMAT_BC6H_TYPELESS, VK_FORMAT_BC6H_UFLOAT_BLOCK, NV_GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB, 0, 0) \ + DO(DXGI_FORMAT_BC7_UNORM, VK_FORMAT_BC7_UNORM_BLOCK, NV_GL_COMPRESSED_RGBA_BPTC_UNORM_ARB, 0, 0) \ + DO(DXGI_FORMAT_BC7_UNORM_SRGB, VK_FORMAT_BC7_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB, 0, 0) \ + REPVK(DXGI_FORMAT_BC7_TYPELESS, VK_FORMAT_BC7_SRGB_BLOCK, NV_GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB, 0, 0) \ + DO(DXGI_FORMAT_D16_UNORM, VK_FORMAT_D16_UNORM, NV_GL_DEPTH_COMPONENT16, NV_GL_DEPTH_COMPONENT, NV_GL_UNSIGNED_SHORT) \ + DO(DXGI_FORMAT_D24_UNORM_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT, NV_GL_DEPTH24_STENCIL8, NV_GL_DEPTH_STENCIL, NV_GL_UNSIGNED_INT_24_8) \ + REPVK(DXGI_FORMAT_R24G8_TYPELESS, VK_FORMAT_D24_UNORM_S8_UINT, NV_GL_DEPTH24_STENCIL8, NV_GL_DEPTH_STENCIL, NV_GL_UNSIGNED_INT_24_8) \ + REPVK(DXGI_FORMAT_R24_UNORM_X8_TYPELESS, VK_FORMAT_D24_UNORM_S8_UINT, NV_GL_DEPTH24_STENCIL8, NV_GL_DEPTH_STENCIL, NV_GL_UNSIGNED_INT_24_8) \ + REPVK(DXGI_FORMAT_X24_TYPELESS_G8_UINT, VK_FORMAT_D24_UNORM_S8_UINT, NV_GL_DEPTH24_STENCIL8, NV_GL_DEPTH_STENCIL, NV_GL_UNSIGNED_INT_24_8) \ + DO(DXGI_FORMAT_D32_FLOAT, VK_FORMAT_D32_SFLOAT, NV_GL_DEPTH_COMPONENT32F, NV_GL_DEPTH_COMPONENT, NV_GL_FLOAT) \ + DO(DXGI_FORMAT_D32_FLOAT_S8X24_UINT, VK_FORMAT_D32_SFLOAT_S8_UINT, NV_GL_DEPTH32F_STENCIL8, NV_GL_DEPTH_STENCIL, \ + NV_GL_FLOAT_32_UNSIGNED_INT_24_8_REV) \ + REPVK(DXGI_FORMAT_R32G8X24_TYPELESS, VK_FORMAT_D32_SFLOAT_S8_UINT, NV_GL_DEPTH32F_STENCIL8, NV_GL_DEPTH_STENCIL, \ + NV_GL_FLOAT_32_UNSIGNED_INT_24_8_REV) \ + REPVK(DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS, VK_FORMAT_D32_SFLOAT_S8_UINT, NV_GL_DEPTH32F_STENCIL8, \ + NV_GL_DEPTH_STENCIL, NV_GL_FLOAT_32_UNSIGNED_INT_24_8_REV) \ + REPVK(DXGI_FORMAT_X32_TYPELESS_G8X24_UINT, VK_FORMAT_D32_SFLOAT_S8_UINT, NV_GL_DEPTH32F_STENCIL8, \ + NV_GL_DEPTH_STENCIL, NV_GL_FLOAT_32_UNSIGNED_INT_24_8_REV) \ + DO(DXGI_FORMAT_R10G10B10A2_UINT, VK_FORMAT_A2B10G10R10_UINT_PACK32, NV_GL_RGB10_A2UI, NV_GL_RGBA_INTEGER, NV_GL_UNSIGNED_INT_2_10_10_10_REV) \ + DO(DXGI_FORMAT_R10G10B10A2_UNORM, VK_FORMAT_A2B10G10R10_UNORM_PACK32, NV_GL_RGB10_A2, NV_GL_RGBA, NV_GL_UNSIGNED_INT_2_10_10_10_REV) \ + REPVK(DXGI_FORMAT_R10G10B10A2_TYPELESS, VK_FORMAT_A2B10G10R10_UNORM_PACK32, NV_GL_RGB10_A2, NV_GL_RGBA, NV_GL_UNSIGNED_INT_2_10_10_10_REV) \ + DO(DXGI_FORMAT_R11G11B10_FLOAT, VK_FORMAT_B10G11R11_UFLOAT_PACK32, NV_GL_R11F_G11F_B10F, NV_GL_RGB, NV_GL_UNSIGNED_INT_10F_11F_11F_REV) \ + DO(DXGI_FORMAT_R16G16B16A16_FLOAT, VK_FORMAT_R16G16B16A16_SFLOAT, NV_GL_RGBA16F, NV_GL_RGBA, NV_GL_HALF_FLOAT) \ + DO(DXGI_FORMAT_R16G16B16A16_SINT, VK_FORMAT_R16G16B16A16_SINT, NV_GL_RGBA16I, NV_GL_RGBA_INTEGER, NV_GL_SHORT) \ + DO(DXGI_FORMAT_R16G16B16A16_SNORM, VK_FORMAT_R16G16B16A16_SNORM, NV_GL_RGBA16_SNORM, NV_GL_RGBA, NV_GL_SHORT) \ + DO(DXGI_FORMAT_R16G16B16A16_UINT, VK_FORMAT_R16G16B16A16_UINT, NV_GL_RGBA16UI, NV_GL_RGBA_INTEGER, NV_GL_UNSIGNED_SHORT) \ + DO(DXGI_FORMAT_R16G16B16A16_UNORM, VK_FORMAT_R16G16B16A16_UNORM, NV_GL_RGBA16, NV_GL_RGBA, NV_GL_UNSIGNED_SHORT) \ + REPVK(DXGI_FORMAT_R16G16B16A16_TYPELESS, VK_FORMAT_R16G16B16A16_SFLOAT, NV_GL_RGBA16F, NV_GL_RGBA, NV_GL_HALF_FLOAT) \ + DO(DXGI_FORMAT_R16G16_FLOAT, VK_FORMAT_R16G16_SFLOAT, NV_GL_RG16F, NV_GL_RG, NV_GL_HALF_FLOAT) \ + DO(DXGI_FORMAT_R16G16_SINT, VK_FORMAT_R16G16_SINT, NV_GL_RG16I, NV_GL_RG_INTEGER, NV_GL_SHORT) \ + DO(DXGI_FORMAT_R16G16_SNORM, VK_FORMAT_R16G16_SNORM, NV_GL_RG16_SNORM, NV_GL_RG, NV_GL_SHORT) \ + REPVK(DXGI_FORMAT_R16G16_TYPELESS, VK_FORMAT_R16G16_SFLOAT, NV_GL_RG16F, NV_GL_RG, NV_GL_HALF_FLOAT) \ + DO(DXGI_FORMAT_R16G16_UINT, VK_FORMAT_R16G16_UINT, NV_GL_RG16UI, NV_GL_RG_INTEGER, NV_GL_UNSIGNED_SHORT) \ + DO(DXGI_FORMAT_R16G16_UNORM, VK_FORMAT_R16G16_UNORM, NV_GL_RG16, NV_GL_RG, NV_GL_UNSIGNED_SHORT) \ + DO(DXGI_FORMAT_R16_FLOAT, VK_FORMAT_R16_SFLOAT, NV_GL_R16F, NV_GL_RED, NV_GL_HALF_FLOAT) \ + DO(DXGI_FORMAT_R16_SINT, VK_FORMAT_R16_SINT, NV_GL_R16I, NV_GL_RED_INTEGER, NV_GL_SHORT) \ + DO(DXGI_FORMAT_R16_SNORM, VK_FORMAT_R16_SNORM, NV_GL_R16_SNORM, NV_GL_RED, NV_GL_SHORT) \ + REPVK(DXGI_FORMAT_R16_TYPELESS, VK_FORMAT_R16_SFLOAT, NV_GL_R16F, NV_GL_RED, NV_GL_HALF_FLOAT) \ + DO(DXGI_FORMAT_R16_UINT, VK_FORMAT_R16_UINT, NV_GL_R16UI, NV_GL_RED_INTEGER, NV_GL_UNSIGNED_SHORT) \ + DO(DXGI_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, NV_GL_R16, NV_GL_RED, NV_GL_UNSIGNED_SHORT) \ + DO(DXGI_FORMAT_R32G32B32A32_FLOAT, VK_FORMAT_R32G32B32A32_SFLOAT, NV_GL_RGBA32F, NV_GL_RGBA, NV_GL_FLOAT) \ + DO(DXGI_FORMAT_R32G32B32A32_SINT, VK_FORMAT_R32G32B32A32_SINT, NV_GL_RGBA32I, NV_GL_RGBA_INTEGER, NV_GL_INT) \ + DO(DXGI_FORMAT_R32G32B32A32_UINT, VK_FORMAT_R32G32B32A32_UINT, NV_GL_RGBA32UI, NV_GL_RGBA_INTEGER, NV_GL_UNSIGNED_INT) \ + REPVK(DXGI_FORMAT_R32G32B32A32_TYPELESS, VK_FORMAT_R32G32B32A32_SFLOAT, NV_GL_RGBA32F, NV_GL_RGBA, NV_GL_FLOAT) \ + DO(DXGI_FORMAT_R32G32B32_FLOAT, VK_FORMAT_R32G32B32_SFLOAT, NV_GL_RGB32F, NV_GL_RGB, NV_GL_FLOAT) \ + DO(DXGI_FORMAT_R32G32B32_SINT, VK_FORMAT_R32G32B32_SINT, NV_GL_RGB32I, NV_GL_RGB_INTEGER, NV_GL_INT) \ + DO(DXGI_FORMAT_R32G32B32_UINT, VK_FORMAT_R32G32B32_UINT, NV_GL_RGB32UI, NV_GL_RGB_INTEGER, NV_GL_UNSIGNED_INT) \ + REPVK(DXGI_FORMAT_R32G32B32_TYPELESS, VK_FORMAT_R32G32B32_SFLOAT, NV_GL_RGB32F, NV_GL_RGB, NV_GL_FLOAT) \ + DO(DXGI_FORMAT_R32G32_FLOAT, VK_FORMAT_R32G32_SFLOAT, NV_GL_RG32F, NV_GL_RG, NV_GL_FLOAT) \ + DO(DXGI_FORMAT_R32G32_SINT, VK_FORMAT_R32G32_SINT, NV_GL_RG32I, NV_GL_RG_INTEGER, NV_GL_INT) \ + DO(DXGI_FORMAT_R32G32_UINT, VK_FORMAT_R32G32_UINT, NV_GL_RG32UI, NV_GL_RG_INTEGER, NV_GL_UNSIGNED_INT) \ + REPVK(DXGI_FORMAT_R32G32_TYPELESS, VK_FORMAT_R32G32_SFLOAT, NV_GL_RG32F, NV_GL_RG, NV_GL_FLOAT) \ + DO(DXGI_FORMAT_R32_FLOAT, VK_FORMAT_R32_SFLOAT, NV_GL_R32F, NV_GL_RED, NV_GL_FLOAT) \ + DO(DXGI_FORMAT_R32_SINT, VK_FORMAT_R32_SINT, NV_GL_R32I, NV_GL_RED_INTEGER, NV_GL_INT) \ + DO(DXGI_FORMAT_R32_UINT, VK_FORMAT_R32_UINT, NV_GL_R32UI, NV_GL_RED_INTEGER, NV_GL_UNSIGNED_INT) \ + REPVK(DXGI_FORMAT_R32_TYPELESS, VK_FORMAT_R32_SFLOAT, NV_GL_R32F, NV_GL_RED, NV_GL_FLOAT) \ + DO(DXGI_FORMAT_R8G8B8A8_SINT, VK_FORMAT_R8G8B8A8_SINT, NV_GL_RGBA8I, NV_GL_RGBA_INTEGER, NV_GL_BYTE) \ + DO(DXGI_FORMAT_R8G8B8A8_SNORM, VK_FORMAT_R8G8B8A8_SNORM, NV_GL_RGBA8_SNORM, NV_GL_RGBA, NV_GL_BYTE) \ + DO(DXGI_FORMAT_R8G8B8A8_UINT, VK_FORMAT_R8G8B8A8_UINT, NV_GL_RGBA8UI, NV_GL_RGBA_INTEGER, NV_GL_UNSIGNED_BYTE) \ + DO(DXGI_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_R8G8B8A8_UNORM, NV_GL_RGBA8, NV_GL_RGBA, NV_GL_UNSIGNED_BYTE) \ + DO(DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, VK_FORMAT_R8G8B8A8_SRGB, NV_GL_SRGB8_ALPHA8, NV_GL_RGBA, NV_GL_UNSIGNED_BYTE) \ + REPVK(DXGI_FORMAT_R8G8B8A8_TYPELESS, VK_FORMAT_R8G8B8A8_SRGB, NV_GL_SRGB8_ALPHA8, NV_GL_RGBA, NV_GL_UNSIGNED_BYTE) \ + DO(DXGI_FORMAT_R8G8_SINT, VK_FORMAT_R8G8_SINT, NV_GL_RG8I, NV_GL_RG_INTEGER, NV_GL_BYTE) \ + DO(DXGI_FORMAT_R8G8_SNORM, VK_FORMAT_R8G8_SNORM, NV_GL_RG8_SNORM, NV_GL_RG, NV_GL_BYTE) \ + DO(DXGI_FORMAT_R8G8_TYPELESS, VK_FORMAT_R8G8_SRGB, NV_GL_SRG8_EXT, NV_GL_RG, NV_GL_UNSIGNED_BYTE) \ + DO(DXGI_FORMAT_R8G8_UINT, VK_FORMAT_R8G8_UINT, NV_GL_RG8UI, NV_GL_RG_INTEGER, NV_GL_UNSIGNED_BYTE) \ + DO(DXGI_FORMAT_R8G8_UNORM, VK_FORMAT_R8G8_UNORM, NV_GL_LUMINANCE8_ALPHA8, NV_GL_LUMINANCE_ALPHA, NV_GL_UNSIGNED_BYTE) \ + REPBOTH(DXGI_FORMAT_R8G8_UNORM, VK_FORMAT_R8G8_UNORM, NV_GL_RG8, NV_GL_RG, NV_GL_UNSIGNED_BYTE) \ + DO(DXGI_FORMAT_R8_SINT, VK_FORMAT_R8_SINT, NV_GL_R8I, NV_GL_RED_INTEGER, NV_GL_BYTE) \ + DO(DXGI_FORMAT_R8_SNORM, VK_FORMAT_R8_SNORM, NV_GL_R8_SNORM, NV_GL_RED, NV_GL_BYTE) \ + DO(DXGI_FORMAT_R8_TYPELESS, VK_FORMAT_R8_SRGB, NV_GL_SR8_EXT, NV_GL_RED, NV_GL_UNSIGNED_BYTE) \ + DO(DXGI_FORMAT_R8_UINT, VK_FORMAT_R8_UINT, NV_GL_R8UI, NV_GL_RED_INTEGER, NV_GL_UNSIGNED_BYTE) \ + DO(DXGI_FORMAT_R8_UNORM, VK_FORMAT_R8_UNORM, NV_GL_ALPHA8, NV_GL_ALPHA, NV_GL_UNSIGNED_BYTE) \ + REPBOTH(DXGI_FORMAT_R8_UNORM, VK_FORMAT_R8_UNORM, NV_GL_LUMINANCE8, NV_GL_LUMINANCE, NV_GL_UNSIGNED_BYTE) \ + REPBOTH(DXGI_FORMAT_R8_UNORM, VK_FORMAT_R8_UNORM, NV_GL_R8, NV_GL_RED, NV_GL_UNSIGNED_BYTE) \ + DO(DXGI_FORMAT_R9G9B9E5_SHAREDEXP, VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, NV_GL_RGB9_E5, NV_GL_RGB, NV_GL_UNSIGNED_INT_5_9_9_9_REV) \ + DO(DXGI_FORMAT_R8G8_B8G8_UNORM, VK_FORMAT_G8B8G8R8_422_UNORM, 0, 0, 0) \ + DO(DXGI_FORMAT_G8R8_G8B8_UNORM, VK_FORMAT_B8G8R8G8_422_UNORM, 0, 0, 0) \ + REPVK(DXGI_FORMAT_YUY2, VK_FORMAT_G8B8G8R8_422_UNORM, 0, 0, 0) \ + DO(DXGI_FORMAT_NV12, VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, 0, 0, 0) \ + DO(DXGI_FORMAT_P010, VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, 0, 0, 0) \ + DO(DXGI_FORMAT_P016, VK_FORMAT_G16_B16R16_2PLANE_420_UNORM, 0, 0, 0) \ + DO(DXGI_FORMAT_Y210, VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, 0, 0, 0) \ + DO(DXGI_FORMAT_Y216, VK_FORMAT_G16B16G16R16_422_UNORM, 0, 0, 0) \ + DO(DXGI_FORMAT_P208, VK_FORMAT_G8_B8R8_2PLANE_422_UNORM, 0, 0, 0) + +#define DO_NOTHING_ON_REPEAT(...) + +// Private functions for building tables. +namespace { + +std::unordered_map s_tableOpenGLToDXGI; +void addGLToDXGICombination(uint32_t dxgiFormat, uint32_t glInternalFormat, uint32_t glFormat, uint32_t glType) +{ + const OpenGLFormat glStruct = {glInternalFormat, glFormat, glType}; + if(glStruct == OpenGLFormat{}) + { + return; // Avoid adding unknown GL formats + } + + if(0 == s_tableOpenGLToDXGI.count(glStruct)) + { + s_tableOpenGLToDXGI[glStruct] = dxgiFormat; + } +} + +#ifdef NVP_SUPPORTS_VULKANSDK +std::unordered_map s_tableOpenGLToVulkan; +void addGLToVulkanCombination(VkFormat vkFormat, uint32_t glInternalFormat, uint32_t glFormat, uint32_t glType) +{ + const OpenGLFormat glStruct = {glInternalFormat, glFormat, glType}; + if(glStruct == OpenGLFormat{}) + { + return; // Avoid adding unknown GL formats + } + + if(0 == s_tableOpenGLToVulkan.count(glStruct)) + { + s_tableOpenGLToVulkan[glStruct] = vkFormat; + } +} +#endif +// Only build the tables once, even if these functions are called from multiple +// threads. +std::once_flag s_tablesBuilt; + +void buildTables() +{ +#define ADD_COMBINATION(dxgi, vk, ...) addGLToDXGICombination(dxgi, __VA_ARGS__); + FOR_EACH_FORMAT(ADD_COMBINATION, ADD_COMBINATION, ADD_COMBINATION); +#undef ADD_COMBINATION + +#ifdef NVP_SUPPORTS_VULKANSDK +#define ADD_COMBINATION(dxgi, vk, ...) addGLToVulkanCombination(vk, __VA_ARGS__); + FOR_EACH_FORMAT(ADD_COMBINATION, ADD_COMBINATION, ADD_COMBINATION); +#undef ADD_COMBINATION +#endif +} + +} // namespace + +OpenGLFormat dxgiToOpenGL(uint32_t dxgiFormat) +{ + switch(dxgiFormat) + { +#define ON_DXGI_RETURN_OPENGL(dxgi, vk, glInternalFormat, glFormat, glType) \ + case dxgi: \ + return {glInternalFormat, glFormat, glType}; + + FOR_EACH_FORMAT(ON_DXGI_RETURN_OPENGL, ON_DXGI_RETURN_OPENGL, DO_NOTHING_ON_REPEAT) +#undef ON_DXGI_RETURN_OPENGL + default: + return {}; + } +} + +uint32_t openGLToDXGI(const OpenGLFormat& glFormat) +{ + std::call_once(s_tablesBuilt, buildTables); + const auto& findResult = s_tableOpenGLToDXGI.find(glFormat); + if(findResult == s_tableOpenGLToDXGI.end()) + { + return {}; + } + return findResult->second; +} + +#ifdef NVP_SUPPORTS_VULKANSDK +VkFormat dxgiToVulkan(uint32_t dxgiFormat) +{ + switch(dxgiFormat) + { +#define ON_DXGI_RETURN_VK(dxgi, vk, glInternalFormat, glFormat, glType) \ + case dxgi: \ + return vk; + + FOR_EACH_FORMAT(ON_DXGI_RETURN_VK, ON_DXGI_RETURN_VK, DO_NOTHING_ON_REPEAT) +#undef ON_DXGI_RETURN_VK + default: + return VK_FORMAT_UNDEFINED; + } +} + +VkFormat openGLToVulkan(const OpenGLFormat& glFormat) +{ + std::call_once(s_tablesBuilt, buildTables); + const auto& findResult = s_tableOpenGLToVulkan.find(glFormat); + if(findResult == s_tableOpenGLToVulkan.end()) + { + return {}; + } + return findResult->second; +} + +uint32_t vulkanToDXGI(VkFormat vkFormat) +{ + switch(vkFormat) + { +#define ON_VK_RETURN_DXGI(dxgi, vk, glInternalFormat, glFormat, glType) \ + case vk: \ + return dxgi; + + FOR_EACH_FORMAT(ON_VK_RETURN_DXGI, DO_NOTHING_ON_REPEAT, DO_NOTHING_ON_REPEAT) +#undef ON_VK_RETURN_DXGI + default: + return {}; + } +} + +OpenGLFormat vulkanToOpenGL(VkFormat vkFormat) +{ + switch(vkFormat) + { +#define ON_VK_RETURN_OPENGL(dxgi, vk, glInternalFormat, glFormat, glType) \ + case vk: \ + return {glInternalFormat, glFormat, glType}; + + FOR_EACH_FORMAT(ON_VK_RETURN_OPENGL, DO_NOTHING_ON_REPEAT, DO_NOTHING_ON_REPEAT) +#undef ON_VK_RETURN_OPENGL + default: + return {}; + } +} +#endif + +const char* getDXGIFormatName(uint32_t dxgiFormat) +{ + switch(dxgiFormat) + { +#define RETURN_DXGI_FORMAT_NAME(dxgi, vk, glInternalFormat, glFormat, glType) \ + case dxgi: \ + return #dxgi; + + FOR_EACH_FORMAT(RETURN_DXGI_FORMAT_NAME, RETURN_DXGI_FORMAT_NAME, DO_NOTHING_ON_REPEAT) +#undef RETURN_DXGI_FORMAT_NAME + default: + return nullptr; + } +} + +#ifdef NVP_SUPPORTS_VULKANSDK +const char* getVkFormatName(VkFormat vkFormat) +{ + switch(vkFormat) + { +#define RETURN_VK_FORMAT_NAME(dxgi, vk, glInternalFormat, glFormat, glType) \ + case vk: \ + return #vk; + + FOR_EACH_FORMAT(RETURN_VK_FORMAT_NAME, DO_NOTHING_ON_REPEAT, DO_NOTHING_ON_REPEAT) +#undef RETURN_VK_FORMAT_JNAME + default: + return nullptr; + } +} +#endif + +// The transfer function functions work on tables of pairs of (non-sRGB, sRGB) +// formats. +#define FOR_EACH_DXGI_SRGB_PAIR(DO) \ + DO(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_R8G8B8A8_UNORM_SRGB) \ + DO(DXGI_FORMAT_BC1_UNORM, DXGI_FORMAT_BC1_UNORM_SRGB) \ + DO(DXGI_FORMAT_BC2_UNORM, DXGI_FORMAT_BC2_UNORM_SRGB) \ + DO(DXGI_FORMAT_BC3_UNORM, DXGI_FORMAT_BC3_UNORM_SRGB) \ + DO(DXGI_FORMAT_B8G8R8A8_UNORM, DXGI_FORMAT_B8G8R8A8_UNORM_SRGB) \ + DO(DXGI_FORMAT_B8G8R8X8_UNORM, DXGI_FORMAT_B8G8R8X8_UNORM_SRGB) \ + DO(DXGI_FORMAT_ASTC_4X4_UNORM, DXGI_FORMAT_ASTC_4X4_UNORM_SRGB) \ + DO(DXGI_FORMAT_ASTC_5X4_UNORM, DXGI_FORMAT_ASTC_5X4_UNORM_SRGB) \ + DO(DXGI_FORMAT_ASTC_5X5_UNORM, DXGI_FORMAT_ASTC_5X5_UNORM_SRGB) \ + DO(DXGI_FORMAT_ASTC_6X5_UNORM, DXGI_FORMAT_ASTC_6X5_UNORM_SRGB) \ + DO(DXGI_FORMAT_ASTC_6X6_UNORM, DXGI_FORMAT_ASTC_6X6_UNORM_SRGB) \ + DO(DXGI_FORMAT_ASTC_8X5_UNORM, DXGI_FORMAT_ASTC_8X5_UNORM_SRGB) \ + DO(DXGI_FORMAT_ASTC_8X6_UNORM, DXGI_FORMAT_ASTC_8X6_UNORM_SRGB) \ + DO(DXGI_FORMAT_ASTC_8X8_UNORM, DXGI_FORMAT_ASTC_8X8_UNORM_SRGB) \ + DO(DXGI_FORMAT_ASTC_10X5_UNORM, DXGI_FORMAT_ASTC_10X5_UNORM_SRGB) \ + DO(DXGI_FORMAT_ASTC_10X6_UNORM, DXGI_FORMAT_ASTC_10X6_UNORM_SRGB) \ + DO(DXGI_FORMAT_ASTC_10X8_UNORM, DXGI_FORMAT_ASTC_10X8_UNORM_SRGB) \ + DO(DXGI_FORMAT_ASTC_10X10_UNORM, DXGI_FORMAT_ASTC_10X10_UNORM_SRGB) \ + DO(DXGI_FORMAT_ASTC_12X10_UNORM, DXGI_FORMAT_ASTC_12X10_UNORM_SRGB) \ + DO(DXGI_FORMAT_ASTC_12X12_UNORM, DXGI_FORMAT_ASTC_12X12_UNORM_SRGB) + +bool isDXGIFormatSRGB(uint32_t dxgiFormat) +{ + switch(dxgiFormat) + { +#define SRGB_CASE(nonSRGBFormat, srgbFormat) \ + case srgbFormat: \ + return true; + + FOR_EACH_DXGI_SRGB_PAIR(SRGB_CASE) +#undef SRGB_CASE + default: + return false; + } +} + +uint32_t tryForceDXGIFormatTransferFunction(uint32_t dxgiFormat, bool srgb) +{ + if(srgb) + { + switch(dxgiFormat) + { +#define TO_SRGB(nonSRGBFormat, srgbFormat) \ + case nonSRGBFormat: \ + return srgbFormat; + + FOR_EACH_DXGI_SRGB_PAIR(TO_SRGB) +#undef TO_SRGB + default: + return dxgiFormat; + } + } + else + { + switch(dxgiFormat) + { +#define TO_NON_SRGB(nonSRGBFormat, srgbFormat) \ + case srgbFormat: \ + return nonSRGBFormat; + + FOR_EACH_DXGI_SRGB_PAIR(TO_NON_SRGB) +#undef TO_NON_SRGB + default: + return dxgiFormat; + } + } +} + +#ifdef NVP_SUPPORTS_VULKANSDK +#define FOR_EACH_VK_SRGB_PAIR(DO) \ + DO(VK_FORMAT_R8_UNORM, VK_FORMAT_R8_SRGB) \ + DO(VK_FORMAT_R8G8_UNORM, VK_FORMAT_R8G8_SRGB) \ + DO(VK_FORMAT_R8G8B8_UNORM, VK_FORMAT_R8G8B8_SRGB) \ + DO(VK_FORMAT_B8G8R8_UNORM, VK_FORMAT_B8G8R8_SRGB) \ + DO(VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_R8G8B8A8_SRGB) \ + DO(VK_FORMAT_B8G8R8A8_UNORM, VK_FORMAT_B8G8R8A8_SRGB) \ + DO(VK_FORMAT_A8B8G8R8_UNORM_PACK32, VK_FORMAT_A8B8G8R8_SRGB_PACK32) \ + DO(VK_FORMAT_BC1_RGB_UNORM_BLOCK, VK_FORMAT_BC1_RGB_SRGB_BLOCK) \ + DO(VK_FORMAT_BC1_RGBA_UNORM_BLOCK, VK_FORMAT_BC1_RGBA_SRGB_BLOCK) \ + DO(VK_FORMAT_BC2_UNORM_BLOCK, VK_FORMAT_BC2_SRGB_BLOCK) \ + DO(VK_FORMAT_BC3_UNORM_BLOCK, VK_FORMAT_BC3_SRGB_BLOCK) \ + DO(VK_FORMAT_BC7_UNORM_BLOCK, VK_FORMAT_BC7_SRGB_BLOCK) \ + DO(VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK) \ + DO(VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK) \ + DO(VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK) \ + DO(VK_FORMAT_ASTC_4x4_UNORM_BLOCK, VK_FORMAT_ASTC_4x4_SRGB_BLOCK) \ + DO(VK_FORMAT_ASTC_5x4_UNORM_BLOCK, VK_FORMAT_ASTC_5x4_SRGB_BLOCK) \ + DO(VK_FORMAT_ASTC_5x5_UNORM_BLOCK, VK_FORMAT_ASTC_5x5_SRGB_BLOCK) \ + DO(VK_FORMAT_ASTC_6x5_UNORM_BLOCK, VK_FORMAT_ASTC_6x5_SRGB_BLOCK) \ + DO(VK_FORMAT_ASTC_6x6_UNORM_BLOCK, VK_FORMAT_ASTC_6x6_SRGB_BLOCK) \ + DO(VK_FORMAT_ASTC_8x5_UNORM_BLOCK, VK_FORMAT_ASTC_8x5_SRGB_BLOCK) \ + DO(VK_FORMAT_ASTC_8x6_UNORM_BLOCK, VK_FORMAT_ASTC_8x6_SRGB_BLOCK) \ + DO(VK_FORMAT_ASTC_8x8_UNORM_BLOCK, VK_FORMAT_ASTC_8x8_SRGB_BLOCK) \ + DO(VK_FORMAT_ASTC_10x5_UNORM_BLOCK, VK_FORMAT_ASTC_10x5_SRGB_BLOCK) \ + DO(VK_FORMAT_ASTC_10x6_UNORM_BLOCK, VK_FORMAT_ASTC_10x6_SRGB_BLOCK) \ + DO(VK_FORMAT_ASTC_10x8_UNORM_BLOCK, VK_FORMAT_ASTC_10x8_SRGB_BLOCK) \ + DO(VK_FORMAT_ASTC_10x10_UNORM_BLOCK, VK_FORMAT_ASTC_10x10_SRGB_BLOCK) \ + DO(VK_FORMAT_ASTC_12x10_UNORM_BLOCK, VK_FORMAT_ASTC_12x10_SRGB_BLOCK) \ + DO(VK_FORMAT_ASTC_12x12_UNORM_BLOCK, VK_FORMAT_ASTC_12x12_SRGB_BLOCK) \ + DO(VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG, VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG) \ + DO(VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG, VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG) \ + DO(VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG, VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG) \ + DO(VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG, VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG) + +bool isVkFormatSRGB(VkFormat vkFormat) +{ + switch(vkFormat) + { +#define SRGB_CASE(nonSRGBFormat, srgbFormat) \ + case srgbFormat: \ + return true; + + FOR_EACH_VK_SRGB_PAIR(SRGB_CASE) +#undef SRGB_CASE + default: + return false; + } +} + +VkFormat tryForceVkFormatTransferFunction(VkFormat vkFormat, bool srgb) +{ + if(srgb) + { + switch(vkFormat) + { +#define TO_SRGB(nonSRGBFormat, srgbFormat) \ + case nonSRGBFormat: \ + return srgbFormat; + + FOR_EACH_VK_SRGB_PAIR(TO_SRGB) +#undef TO_SRGB + default: + return vkFormat; + } + } + else + { + switch(vkFormat) + { +#define TO_NON_SRGB(nonSRGBFormat, srgbFormat) \ + case srgbFormat: \ + return nonSRGBFormat; + + FOR_EACH_VK_SRGB_PAIR(TO_NON_SRGB) +#undef TO_NON_SRGB + default: + return vkFormat; + } + } +} + +#endif + +} // namespace texture_formats diff --git a/nvpro_core_legacy/fileformats/texture_formats.h b/nvpro_core_legacy/fileformats/texture_formats.h new file mode 100644 index 0000000..647bab1 --- /dev/null +++ b/nvpro_core_legacy/fileformats/texture_formats.h @@ -0,0 +1,212 @@ +/* + * Copyright (c) 2024, NVIDIA CORPORATION. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION + * SPDX-License-Identifier: Apache-2.0 + */ + +/** @DOC_START + +Provides: +* Methods for translating texture format names between DirectX, Vulkan, and +OpenGL. +* A method for getting the size of a Vulkan subresource using linear tiling. +* The extended ASTC values for DXGI_FORMAT. + +-- @DOC_END */ + +#pragma once +#include +#include + +#ifdef NVP_SUPPORTS_VULKANSDK +#include // For VkFormat +#endif + +namespace texture_formats { + +struct OpenGLFormat +{ + uint32_t internalFormat = 0; + // Unused if using a compressed format; otherwise, specifies the format of + // client pixel data. + uint32_t format = 0; + // Unused (0) if using a compressed format; otherwise, specifies the OpenGL + // data type of client pixel data. + uint32_t type = 0; + + bool operator==(const OpenGLFormat& b) const + { + return (internalFormat == b.internalFormat) && (format == b.format) && (type == b.type); + } +}; + +// API texture format name translation functions. +// Each of these returns an "unknown" format -- 0 -- if it couldn't figure out +// what the corresponding format was. +OpenGLFormat dxgiToOpenGL(uint32_t dxgiFormat); +uint32_t openGLToDXGI(const OpenGLFormat& glFormat); +#ifdef NVP_SUPPORTS_VULKANSDK +VkFormat dxgiToVulkan(uint32_t dxgiFormat); +VkFormat openGLToVulkan(const OpenGLFormat& glFormat); +uint32_t vulkanToDXGI(VkFormat vkFormat); +OpenGLFormat vulkanToOpenGL(VkFormat vkFormat); +#endif + +// Returns the enum name of a DXGI format. If the name isn't contained in +// texture_format's tables, returns nullptr. +const char* getDXGIFormatName(uint32_t dxgiFormat); + +#ifdef NVP_SUPPORTS_VULKANSDK +// Returns the enum name of a VkFormat. If the name isn't contained in +// texture_format's tables, returns nullptr. +const char* getVkFormatName(VkFormat vkFormat); +#endif + +// Returns whether the given DXGI format ends in _SRGB, i.e. whether the GPU +// automatically performs sRGB-to-linear conversion when sampling it. +bool isDXGIFormatSRGB(uint32_t dxgiFormat); +// Tries to change the given DXGI format to another one that uses the given +// transfer function, if it exists. Otherwise, returns the input. +// For instance, tryForceDXGITransferFunction(DXGI_FORMAT_BC2_UNORM, true) +// returns DXGI_FORMAT_BC2_UNORM_SRGB, while +// tryForceDXGITransferFunction(DXGI_FORMAT_BC4_UNORM, true) returns +// DXGI_FORMAT_BC4_UNORM, since there is no DXGI_FORMAT_BC4_UNORM_SRGB. +// This is useful because by convention, both UNORM and UNORM_SRGB DDS files +// typically contain sRGB data, but the engine usually knows whether it wants +// the GPU to perform automatic sRGB-to-linear conversion. +uint32_t tryForceDXGIFormatTransferFunction(uint32_t dxgiFormat, bool srgb); + +#ifdef NVP_SUPPORTS_VULKANSDK +// Returns whether the given VkFormat includes _SRGB, i.e. whether the GPU +// automatically performs sRGB-to-linear conversion when sampling it. +bool isVkFormatSRGB(VkFormat vkFormat); +// Tries to change the given VkFormat to another one that uses the given +// transfer function, if it exists. Otherwise, returns the input. +VkFormat tryForceVkFormatTransferFunction(VkFormat vkFormat, bool srgb); +#endif + + +// DXGI ASTC extension +// According to Fei Yang, these once appeared in an MS document, then disappeared. +// We filled in DXGI_FORMAT_ASTC_4X4_TYPELESS, which was missing, +// using https://gli.g-truc.net/0.6.1/api/a00001.html. +const uint32_t DXGI_FORMAT_ASTC_4X4_TYPELESS = 133; +const uint32_t DXGI_FORMAT_ASTC_4X4_UNORM = 134; +const uint32_t DXGI_FORMAT_ASTC_4X4_UNORM_SRGB = 135; +const uint32_t DXGI_FORMAT_ASTC_5X4_TYPELESS = 137; +const uint32_t DXGI_FORMAT_ASTC_5X4_UNORM = 138; +const uint32_t DXGI_FORMAT_ASTC_5X4_UNORM_SRGB = 139; +const uint32_t DXGI_FORMAT_ASTC_5X5_TYPELESS = 141; +const uint32_t DXGI_FORMAT_ASTC_5X5_UNORM = 142; +const uint32_t DXGI_FORMAT_ASTC_5X5_UNORM_SRGB = 143; +const uint32_t DXGI_FORMAT_ASTC_6X5_TYPELESS = 145; +const uint32_t DXGI_FORMAT_ASTC_6X5_UNORM = 146; +const uint32_t DXGI_FORMAT_ASTC_6X5_UNORM_SRGB = 147; +const uint32_t DXGI_FORMAT_ASTC_6X6_TYPELESS = 149; +const uint32_t DXGI_FORMAT_ASTC_6X6_UNORM = 150; +const uint32_t DXGI_FORMAT_ASTC_6X6_UNORM_SRGB = 151; +const uint32_t DXGI_FORMAT_ASTC_8X5_TYPELESS = 153; +const uint32_t DXGI_FORMAT_ASTC_8X5_UNORM = 154; +const uint32_t DXGI_FORMAT_ASTC_8X5_UNORM_SRGB = 155; +const uint32_t DXGI_FORMAT_ASTC_8X6_TYPELESS = 157; +const uint32_t DXGI_FORMAT_ASTC_8X6_UNORM = 158; +const uint32_t DXGI_FORMAT_ASTC_8X6_UNORM_SRGB = 159; +const uint32_t DXGI_FORMAT_ASTC_8X8_TYPELESS = 161; +const uint32_t DXGI_FORMAT_ASTC_8X8_UNORM = 162; +const uint32_t DXGI_FORMAT_ASTC_8X8_UNORM_SRGB = 163; +const uint32_t DXGI_FORMAT_ASTC_10X5_TYPELESS = 165; +const uint32_t DXGI_FORMAT_ASTC_10X5_UNORM = 166; +const uint32_t DXGI_FORMAT_ASTC_10X5_UNORM_SRGB = 167; +const uint32_t DXGI_FORMAT_ASTC_10X6_TYPELESS = 169; +const uint32_t DXGI_FORMAT_ASTC_10X6_UNORM = 170; +const uint32_t DXGI_FORMAT_ASTC_10X6_UNORM_SRGB = 171; +const uint32_t DXGI_FORMAT_ASTC_10X8_TYPELESS = 173; +const uint32_t DXGI_FORMAT_ASTC_10X8_UNORM = 174; +const uint32_t DXGI_FORMAT_ASTC_10X8_UNORM_SRGB = 175; +const uint32_t DXGI_FORMAT_ASTC_10X10_TYPELESS = 177; +const uint32_t DXGI_FORMAT_ASTC_10X10_UNORM = 178; +const uint32_t DXGI_FORMAT_ASTC_10X10_UNORM_SRGB = 179; +const uint32_t DXGI_FORMAT_ASTC_12X10_TYPELESS = 181; +const uint32_t DXGI_FORMAT_ASTC_12X10_UNORM = 182; +const uint32_t DXGI_FORMAT_ASTC_12X10_UNORM_SRGB = 183; +const uint32_t DXGI_FORMAT_ASTC_12X12_TYPELESS = 185; +const uint32_t DXGI_FORMAT_ASTC_12X12_UNORM = 186; +const uint32_t DXGI_FORMAT_ASTC_12X12_UNORM_SRGB = 187; + +}; // namespace texture_formats + +namespace checked_math { + +// Multiplies two values, returning false if the calculation would overflow. +inline bool mul2(size_t a, size_t b, size_t& out) +{ + if((a != 0) && (b > SIZE_MAX / a)) // Safe way of checking a * b > SIZE_MAX + { + return false; + } + out = a * b; + return true; +} + +// Multiplies three values, returning false if the calculation would overflow. +inline bool mul3(size_t a, size_t b, size_t c, size_t& out) +{ + // a * b * 0 is always OK, even if a * b overflows. + if(c == 0) + { + out = 0; + return true; + } + if(!mul2(a, b, out)) + return false; + if(!mul2(c, out, out)) + return false; + return true; +} + +// Multiplies four values, returning false if the calculation would overflow. +inline bool mul4(size_t a, size_t b, size_t c, size_t d, size_t& out) +{ + // a * b * c * 0 is always OK, even if a * b * c overflows. + if(d == 0) + { + out = 0; + return true; + } + if(!mul3(a, b, c, out)) + return false; + if(!mul2(d, out, out)) + return false; + return true; +} + +// Multiplies five values, returning false if the calculation would overflow. +inline bool mul5(size_t a, size_t b, size_t c, size_t d, size_t e, size_t& out) +{ + // a * b * c * d * 0 is always OK, even if a * b * c * d overflows. + if(e == 0) + { + out = 0; + return true; + } + if(!mul4(a, b, c, d, out)) + return false; + if(!mul2(e, out, out)) + return false; + return true; +} + +}; // namespace checked_math diff --git a/nvpro_core_legacy/imgui/imgui_icon.cpp b/nvpro_core_legacy/imgui/imgui_icon.cpp new file mode 100644 index 0000000..6b882e7 --- /dev/null +++ b/nvpro_core_legacy/imgui/imgui_icon.cpp @@ -0,0 +1,242 @@ +/* + * Copyright (c) 2023, NVIDIA CORPORATION. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-FileCopyrightText: Copyright (c) 2023, NVIDIA CORPORATION. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include "imgui_icon.h" + +// clang-format off +const char* getOpenIconicFontCompressedBase85TTF() +{ + // TTF font data for OpenIconic font TTF + + // SIL OPEN FONT LICENSE Version 1.1 + // https://github.com/iconic/open-iconic/blob/master/FONT-LICENSE + + // The MIT License(MIT) + // https://github.com/iconic/open-iconic/blob/master/ICON-LICENSE + // + // Copyright(c) 2014 Waybury + // + // Permission is hereby granted, free of charge, to any person obtaining a copy + // of this softwareand associated documentation files(the "Software"), to deal + // in the Software without restriction, including without limitation the rights + // to use, copy, modify, merge, publish, distribute, sublicense, and /or sell + // copies of the Software, and to permit persons to whom the Software is + // furnished to do so, subject to the following conditions : + // + // The above copyright noticeand this permission notice shall be included in + // all copies or substantial portions of the Software. + // + // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE + // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + // THE SOFTWARE. + + // File: 'open-iconic.ttf' (28028 bytes) + // Exported using binary_to_compressed_c.cpp + static const char openIconic_compressed_data_base85[25385 + 1] = + "7])#######cl1xJ'/###W),##2(V$#Q6>##u@;*>#ovW#&6)=-'OE/1gZn426mL&=1->>#JqEn/aNV=B28=#/;pu&V3dW.;h^`IwBAA+k%HL2WF')No6Qpfe->#G:%&#P$;-GItJ1kmO31#r$pBABLTsL:+:%/-p5m6#aJ_&FZ;#jL-gF%N55YueXZV$l`+W%G'7*.p+AGM%rs.Lx0KfLwF6##_OB`N1^*bNYU$##.,<6C" + "pYw:#[MW;-$_C2:01XMCH]/F%@oj>-Wmf*%%q8.$F`7@'.B.;6_Du'&hF;;$63Mk+MS:;$l9r&lW+>>#YvEuu=m*.-H####Y4+GMQrus-Su[fLK=6##'DbA#bFw8'tB6##Lhdk%Nb#d)" + "-l68%C&8FB-#@'$.8mwiL" + "KO2EOR.tB-1N5$hiPchu,MLY5;-]Xo34camA#@YqlLLxQ2MIMh1MB2tuLjV;;$" + "PE)B4-Mc##=(V$#3JRN'GRes$-M:;$eN;hLGSrhL)kL)Nv$Q;-h8Ee#OYLxL/qPW-+l*hcw3Tt:K=/g)&QD.$s@o6<40)V;=6axT1F[x@A1P&,;nl8IW*Yn36=b/(G*8FW.KkqrUgt]_uR0.g>Z>,%&$),##50ED#" + ";EFEaP]UkIJ1P*nO(@nBD3gp/Ys%*c,/Wp`IhM]^'/B67gL0mM<%9@RS%EE.<$(iNn0&DJ1(*O13(0&Ws%C8I6oF'XMon(BW#Ej5/1#iK#$V@pgL5W=huZXAwR'qAZPH(QWGMU'MHME]sFr" + "$#bIh$ErFrtE)Xu*S.GMsFZY#xx'&(-hBD3O4g]uc_.08/tf2`_^7I-PK7I-dn6]-TYwTM9en9M3*-&4%lQDO]H1[MO@YoPM8,,MU#CoeY9C3[-CuBu[*$#xYr#2w@P#3(CJ#G*2GMlH^v-KV;;?BT_c)lH*20%'%<&DI$,*DiY##=Z[0)jiWI)qV6C#2-#Q/8bCE4" + "d.fZ$aSIWABTgk0;-LD?7L1a#d:+d4.:L^u@Ft%,O27>>$/Ib%@s@8:JrksLPQuP=Wj&2XY'f*.W>%H?Jo*50D@N'6@:&&6Mj;5:[G>',%/5##sIkA#?V)2/9(V$#rA+KWNVB.*0Zc8/" + "_YWF3p;:R/g;2.I07b2CAZAb4hLY['IR(<)[8UCCx5B58Xatm'Dn35&+^L-M&J_P8H79v-P>/B#9]SfLYWY95F5kWo[iJdo7PFa[Nk9:P^-R`E7+Ru=NxH#6J8I&tS?.&(w?w%M&CJ#nxkT9HoMs%Ri,#:fs0c7fGA_#kSuIUZ42G`#?#,2'ti21;ix+MG3gF4`cJ,3)_Aj0cI9F*jpB:%cn4[$UJ,G4" + "[uUv-?]d8/hJL:%+SN/2X,n.)1Yl>#4a&m%;Bjo*G6'j0DTnr6>vl[P^Su>#D5UlSjXT)5er^)%7R2=-kL)APvV/isSi)XSf_4Kj+5A3/mCW-nm>#8EQJ(6uv9.nXAouu[XO%s[?>#p?_&#aJxjt^;>_/^1[d+=7B_4s7En3+I@X-vu/+*X0fX-]p*P(&,]]4qio05A@N@,.>T@,(r?5/" + "=KeA?u>kB,pSaIhUT%/2.dOCjA/#2C7CA5//`Nw$*jnA#abDE-)aDE-/MXZ/8N9R//G/JdTa+W-@Isp^Z_?##EdS2^4;5##af[^$/6fX-m'4]-7^9Z-HLQ;-.`6/1xq7t%uR$w#tPR6D" + "CIm,&=G4?Is8K%#fd0'#$sb&,`X2$#p%c00gEW@,QFVC,732m$ic``3t<7f3I.=h>K7)qiFe8V8CwBB#'8:$6-^J6atvN@,P;I80eF&b*l-AU+Q1(`.JLR$&cIqH1Vec<066V9CIBkp%" + ",<$'85fK>?uxwV.fE4g)Een2B,R(f)o77<.hp?d)BiaF3iEo8%Z_G)4@O'>.g:S_#OJ,G4oHl2Eq<@12u)Yx#IM6u?b%]=YnAv6Jex/U%ZRQ;-P2>.3hC7),'BW6sG)'J3W#[]4n&;[qu$0FLS:/.r%,&@ed)$QlvG@5uj)Oi3+3G0Z**uJMk'^@3B6.xl$,eAru51Qkp'&.-,*dLW)3.,RW%EUu^$sZG0(pS4=-JvW@,8PQc4RT8,*IPgf)3;N#5G&MP0" + "U`2p/Qkf34,N_2:o76HN7.7W$]YO@,_NG/(,a'W$%'N50ohYgL_IGG,<;:v-2@`[,=bT]$?/5##'AlY#ID(7#Fww%#QYmq%WqRJ1`tC.33Tlk0[IBN(3pm;%`ni?#A=M8.cc``3eN:;?" + "AWw8@k%#s-00J,;4YIQ0&Z?X('P7G`C)j-&JPciuqvC)*#BU3(UH5/(omLgL0G5gLMQ(]$Y$3$#E@%%#Uqn%#fKb&#Rp8X-@[v(+vuRL(QknW$-xNn0WTP$KC[/Q/:%xC#)vsI33E0N(" + "H1:)N]*WZ#1H(0aVHt1':Z/GM%7Q;-%#h3&F'Bq%n1Goub&]:.CCK?d$SF&#T=P#$b,`tL)V[*._1x+MPr@X-Uokl8JJK/)$8h9MO4G^#P^.3M>7(#&S:A2CmEx>dOI5r%:^iqM&_V;:" + "i51g*lBel/a)12'oon60Jn))+`'fJ1`tC.3?l0x5oSEU-a1M9.F)E`#dDp;-JY#<-GOH&%H0B^^<5=E$`Ge,Mu%2&7&bsZ5oYAA,?J>#B$k>dKV;;?/addFXh)v#`._f#q%KoMhC?>#[CNJMf:-##-Q-E0rB%;QaVS;-#'e32tYg59ZF;s%BOP]uA_$'Q)uCt/OKkA#Bua1uiRJF-[d'-%q%5kO" + "vfP&#(K6(#=3CR0*_S[#:H%O(xNUA$6*YA#Fr/l'V::8._%NT/-K?C#ued;-1rru$JMQF%'1u.)M[4;dv<[5/H5_T%:='d)/OTF&*j`B4')?N#]_h[,>eq/3l;pNM1'A5/rM?R&*dgAt" + "UZg6&7NF*+?jTx=EIIW-@NSKug0pTV.52G`4CNP&?&3-&?A/'H2Bx9.^1tM(b,sFrjv'Q/'ZedubwtBC/:CB#jI:0C6CBh5E8I/(dcT5',m?T%eee@#.N?C#qw6u68AB-QI`_M:lpZEP" + "sTK^P9?%RPLu6j:kmQEPKF^w'?7%-3KV;;?J(WqgNt#`40+nDS2BI4=E&=h>]^'Q/Z9V;-YOho." + "MZu]8+-;]kFF#'''k0[gX7IMhIw#Ri3+3OgqpfnQQ%" + "e/0i)(@n5/6a=a;KfZ_#4p#g[oEkCWnP%3:)puH;f3Yn*q=jg.:KVK2HR+8&5R&/1t.b8/mRXR-Oh#L/lYWI)*^iF=t%'Z--nii/S;3,)s#^XL@,709JSBlvuQ#sj?>drN+3Pr3&7b&WF=b'4fur>gf)?N=v-=Kjr7wv#K)LVsQNXSlwPPaE<%%H>[01lXI)YAOZ6#FPcMnGkIdt'e'Jh)MUdPco=d`X@>d_d?]/" + "NX.i)Oi3+3AS.n/DEaP]ZkIJ1Bd]N/:2Cv-6I7lLg%J#/Lcp77DsXu-=Fn8%$t)Z$a03c7uQOP]'RsxS@B+w<2C" + "$eXw,3d]'R]'^F-LvKl3WU'^#87>##;(V$#QJZ6&0;5##@%Yw2(k^#$BUW:.eAgI*074D#;9ovektS9Ce*loL*uLp.2w@P#gO:1#/s#t-AQWjLA1(?-G-ml$c#[]4bQXA#`&ID*bQs?#" + "(LA8%]CAC#kHSP/GI0P:?fHC#4(=(,wB3r&PC:*31Nw+33Ij,WxMvuJ3)WVRh5l?-mO4Z-Nv4wgwMPT.,GY##TFk3.je'dMT,AX-<0niLBpID>e9+@nf*,s/aNP;dextBCY?:@-[x%d=G2DLKV6dl5D<" + "-WQ@k(4tFA#K;gF4C'+W-`+[^Z2UkD#A.xJ1u3YD#o]d8/@jQv$0/D_&(C=m/H,Bf3Pv@+4*ZKW$RbZV-:'ihLO`6<.`6?8C&)$?\?Yo-x6KZn^43YAA,4&huG" + "]g&i)#VWECnp@A,Be//1?`wA,4lW0R8MnA-kvjS8ln3B,mbX9CkF:@-bI`t-[I?M93+s20jbP;-3xqr$4FG>#l7Fb3js&i)I>Cv-s$gM'OcO4]O^>r%3^lSdq_adthV#fnG688MFAu.Zo?NosS9C+Wq-$,kq0Y5rJ&vJao,;#(C7'I]>c*ed^6&Y'fJ1`=K,3cX.f$^#lP9TAu`4/I#H28)qj&s8Kf'clnP'IEPR&-`:%J#G:.]L3]-kDsI3d,ID*dkS9C(8_33L#v20_gB_u(%x)$>m;U)Y12mLS2sFr,bdt(LF.[B_Tr22kHe##IXI%#.^Q(#" + "Z=sd2PC:J)KF.<$U^nVoVB:=%iZeF4uP2)3i%7V87:Y)4/D-HN<&iM'Fvnb0O)cB,4&Jw#R>iO'Q'4$6Ga7#%-DDJ:j'VhLirMP0v$C>$lD.gL*kC80AYlN9qjTn/3`($#Fg99%OT(]$" + "K1>u%$CZV-1q//13RgIh(17I$E/8QX]u.d*X8AI]v$d>f;%XtRb%]:75)Vi-]-(^&@93_V;-YG^e6J7ws-f$L-MDMYGM_0SX-(=.p.n5UQ/D/)GuI/15AV?96/3BZ=Yxo[F:HQXLs" + "Yw2$#/h>%.HvC;?'*Zg)n.rv-dh.T%ve#`4lYWI)QNv)4%ZFW#o(p^[2I(I#-l*#7Y<2.Is;#eoQOuf[c%q=?;5T[8`6gM=>-Q2iiO2G`K[VV$7Rjl&FnfL))?[s&bvY3'CI[s$Y-oJ1" + "E=R<_2pDs%*$[g)mBmGMN?H)47p&;Q;GB0uwRE2CsIkA#NKX_$>aKs-8(P6MjL1_%D&###aMwFrsqou5P']m,'fNn0]_OF3JIV@,M$g://]v.4i'mG*e4B>,j^Aj0H&Ul68%=jQK%r$'et1-;hLRZ/@#$#bIhP$+W-U9:wpx215M" + "t'918/Tbk4tJ*B.^,QJ(29'.$Xd`#$XoI08&s9B#Lu@P#h(>(.p9_hLxT?R&=.:%/bfQv$&tc05&1=]-6C_B#6GuulY@)$U:r$#7Yvh-t'YKj*$&],+3j'%j7o]4apCg%q]WF3;X^:/oNv)4QdPw-L%O;9`H[n[ww:v/,FeB,tKO@,ep3$6vqf5'nBI(R>Nuf[" + "4:#mFxCEZuG5EC=S*cB,vj%.MMJ$291i9^#q1:kFNMY>#=5^s%2H`hLf%f^$2om8.]^C8#Qnh9VLVUV$i8SC#(<0/1$J@;?p/W;-jWGouR7Fv/Pb./1<)sFr^n-q$NsLB:K(Hg)$%nhM" + "0U.Pd/A:.$b)g;-w#Sv&R+no%:x,W%6oiu$/%@p./6tM(.@wq$tTQ^#+r0Pds@O]u@#pG&i435&.>c5g)NEFs-_gPS@:;xp&FI2Pd=1.AMUV7>S" + "un$W`w5V9CQ7T&#h-7m%qnrr$>i7@%PBBN*#DRv$t0;W-wod;%m^D.3Coh8._V_Z->-w)4D.7x67gurBK[3Ib(/&,;MV0?)<-OBkvmYf>e_VX^m'1,)0D>;+1H:q#`63.5($(U1roT3<" + "IA]C@PGd2CKoxEI.*nMjpg&%#6x5U7n+oh(qe)<-]VsR'e)ahLKZP8.$ed19p_v;-Bviu$vj4N9G'Z'?>IKC-#_@S/j;1g:?@(XS_?tor#($o@g:1gF>d_[i5r_A-$$LYu##" + "FdS2^Crl##9H%O(J%1N(m`0i)x1tM(Zk_a4U&>;?`04]<%&g&p%#&dZ(#:efX.mqD$#*crB#AY>v,YLU8.Od5,2]AtJ:cT3T@D&Du$@]WF3cb(f)" + "0Zc8/xS#8RJ40:95nkp%;Omb>igZKN>P9L(44'k1K_K6MYsslW)aog(:_i[,p)IG=X13G`O39Z70$Qn&D.4x71Y=)-G@-u6KU4x-aSDe$)D([,.rbi(jEelL+iZY#kSuIU^CMc`j*io." + ".Y=W.9offL&(tu5kiE.3[Z*G4AMbI)#R6.Mp?Uv-&cUNtQ/TP/>;gF4See@#v2=v#RD.l'ncgQK=SHt7prgf)3lW`uE=AX#TVGe)B[0DLu33G`))[#8xf8qJSKOW',rKJ)=CEL#FRGE7" + "tql?,Du5]MwY1f+TRQ##XmWF.4MG##Z.n#nW(hh&fK8<-]Cex-Ap/kLfQAa+pNq12nS.d)a5eD*jE7f3EsmC#2RQv$KVM_&:OQ^+IL>n0/[?U&FF76/5vai26bZIMaWPv.5Kuw'#h^>$" + "jP$ND.cTs9FnNp1ZN%q/7kgv7[RiXu>['jC<;v<-OH(5'YsrQN,GkWSF&oO(:76g).CwX-DrS9CYI[i.51Gou46E/%GVD3Cnn(ju%'DC8oA5>d" + "Kn6mA^I6Z$(rQ-HmA4K3,0fX-H_$gL*]d8/sRh`.N-v7$hXWY$+w<2C)+r772=hf)qx8;-UsgY>FPaJ2tKZt.'fNn0=R(f)YsHd)7>1p$V>%&4&=(u(7_Aj0Y$n;'&QVA.OGg+4GF[?\?" + "]g8P133'#*)LwLM@/2&74jj6/id1*3URQ;-8khh;$p8?,%>2e;pFNPM&+*#7;Lo0:X(Z<-8,pL:8PQv$2+:wg%&>s6t++E*$C;W-NZAX-ia&;QK=S?SF5nNSkko@SbCNJMYI(q7.uR_8" + "`4`v#(iNn0)+niM^uQ2MgN&;Qi2_$9,lO]uKmWnLQE%q&=M.>>6oA9=AZ$B=`82t.$5K+*X:Ls-4h&K1`1[s$q[2Q/$8^F*rHNh#S5WF3NP,G4hO=j1HZU&$ZktD#5>PjL=`n]4pqi?#" + "H&,J*/]&E#AIwZ&#sE(1;>'SD*kZdh2`Dxu,mpP3',XTE#8O*t$5`tFb2_Nv#nI3p%YPw)*k9ob%$XA=1ruVs%a7kI)@=.<$kGiE#" + "N4GD4RSE**[haR8;0h:%71#m'N1gT&f;m7&Ze7W$TmLg(ZHj@&W+2?#Mp:4'M9=x#%Sdi&ZFNP&DTo&Cft9B#jPD<%TbsJ1'<1^#_-:CHc*qsJ<-hHFg$?:fpg2-RAOi-5.Vx^WR%.eY9C%mD('cFM<-;^TV-'i)56tB," + "M(w'&xOO]uW?DX-2'B(&-C$_#wkjf)-pQ@,2W>W-u/KF%3.(B#j_n.M8=kf-XLL-Q%]L-QbiT-Q8n@.*u^Op.jAqB#aU%LGDF,gL>fxd;]Fl)4fc5bsDdQ]/$'Cn)'<)iHRp)IHIgdsL" + "T;I]MOjNg=aupbu,6^gL5D6wJ>%r;-Jr+G-Lq;Y0`qIJ1tveF4Y0%.MiMC:%HeolWDgC5/^%AluJT&;Q7CNEdqDDe#b?^6$" + "w71Pd(l*3ia0E$#JepeF9HAX-*V3D#?Kaa4o4P;-uYZ9Cj)?2COqf5/ZQdduCLk%Mew%bO>x2$#u'B?.CfP##$#d;-=5ZX$[aoI*]kbF3]%p-)F53.)62m'=WlK#$U=#-ML(i%MOA#I#" + "nPj#$A4f:d&?-9.;M7%#o&U'#,]ZZ-^L)$#du@cI3,o(NE#Po'&^)T1Mf;*i29Q4;7c'(E#ANp;-PwNn/" + "MgAa5balSVO>.Q/P0_C6AWae36C(C&G/5###oKB#,DF&#'EEjL?YqU%Y]J3%;cLs-aSV)3ig'u$?S<+3FLRLMIU8f3w<7f3owsM0`0S(6]u&)GiLYsI3NY&E#Z%#Gr1qD)Wv^m).Hx&;%Nx<2CFm70C?\?1(q2:d*7#Xc2:Ti>g)6sLlMl0.q$e6AwY2^P[PAa;;?enPE>" + "(cS,&01em8Q``'8(8F`S<3KV;0M#S)oShe#s%gvs4/C:12,2>Bfq1%%).M%DYcMWg;;?[75;-CdU&," + ",h:_A2bAW-HXKZf?dnO(/,-J*AeL`$/DZ;$x,rFrXkuT:X^d4C`,LEdTCYG,qA6FS2=hf)qq[d#GiVAt96R&e^B,jvOA#b`vn&JCf*)R)cB,]7s^oQ>uu#eBF&#Od0'#oLXs50>cQ1=G5##=Z[0)okY)4:Z]F4" + "(cK+*x_OcM&t'E#x.<9/8C)X-fpPA[Rp7jL&c6lL#0E.35MI[')J+gL2a+c43Fa$72r.DC*Pr+M>Up_4X(';S+RM@,FQTA#&$_f+Q6@iL^^Q-3cF@q%J(oQ-5W:V%sa;e33a_`5a<=DC" + "tT3>dE-lV$8wMfW*+n@,OuH6S'8_],G(hKMb#;gF4`m]Ku[+'b?fo+G4X_giBJ[lS/" + "ctMm'P[cQsYx6W-VU>qrSK;^#X]J$pm2>w&]3FX$jt$A,bs(k'.e3.NO6Q$,UG(.3AV)d*m0V@,kY[-).UwHNd$jV=YDmZW-?kWX1RLg+uKI%>Qx$EM-+61d/IIvu#3wFQ#K%9g1oqP;-K#adun,f%ut1c98B[X&#-,K9iW*+T.ElY##>]&(10ImO(" + "ij@+4auRv$#@F,4Mk5.I=Jr@Cn=#AdU_iM=M&CJ#':Po(P1T9ChDUO&9&:Xo)sLh$+6)Z-hfDu$kDjB#'1Lc5wo&vHYA,C8v4(_5-+7f=-YV(ZW4a?>^qD<%=5gF4c?1DR$u$%&WO;-BjTP&B[RS%RmrZ#(iNn0" + "q3P,MRT8f3Y8mA#r8oQWXg^R/eJ0Pd#gL*6p)M*MM4N*MZNt1'-2O$Mq&T9C[PbIh3^Ps-L5k+MHH6uulhP;-`U18.>gQ#-%ua-?=7H,*jPe)*ow3c%=CAC#DOi8.'U&@#J29f30d%H)" + "*t%s--sxs$7)(=6@rFq&6lpUHh,^26O07+20C1#kjLC^GrHoV_'R;FG&#,0,t-#L$iL0;hLs,Jd))afF4EZ$@'vKCo0o+`^#D.Cv$X>a(66hQ;-XV>=lFcof)f$Y=Yo8Yg$LiY,Kh=+9/" + "DX=r/e0P[$snP;-f.vS%mH-ZtImO(.@cS#GJ(p#Enk$/uw(##TQj-$cehZfWq;?#UZZ;?n_oF.Roqr$W`qP8" + "Q@dV[Q]Th#2B0[M^eDJ'$Gb;?pFqB#W@.@#$'CJ#HSGJ?e]O&#b=Pk%Wg@?$*;YY#S1U;0e%l0M+b;;?Vs9:2rvKLNOUZ##EtTs'1-;hL6aA@#`r(kkv9L(ARc`:2mLm]ODknO($o%2'" + ";6jl?&G4Aucr?T-d$EE%4ctM(Ev>X$;FV@.PV?B=b/'Z-cpfZ0]Xj=.1(^S#FBlo>q/#+%/6B2#T++,MkeP;-:ar;?EdkfGUJK_%/XSHc91lQMS'wIU@WK`apr.;6;hV/2;s,t$w]B.*" + "]-'u$Un0a#Mq?jBP2QK)4(7]6gH7lL$KMG)sN_hLREfX-u3YD#aUp+M=)/)*HH3$6puxl1ULY>#=,jBhb=>?l132=hf)" + "'RMx(q@K60,YpBX;s13aJ:?>#gxqs--d0)W]$h)*e)adwKP$.5nWHgsKPm7m=G" + "sOY-QUt'3$AB(7#,Fil%BY6W-j9uBA#f+D#0sqYXG-Xpf%SN/Tc#Pv7CU`UI%k9xLI%###wF5s-e/O$MrQrhLhn(-M3uID*ov@+4Nf,lL$k3Q/UP5W-jkx<(v:+5A7uMvL/xocMa:2G`" + "-DR'OK?CU9o][A,%fQ2(4b/O(0Zc8/HjE.3%q]8%MM?O(3dO;-SuMD?=[o[u.26(&io3=?N_W;-=KeA?:3js%#5L^uLJ76/%3uM'OKIIMBt;fUld%_]U8JwB8@bqg?4aY$+%^=7Kwr?#" + "0S<+3MPsD#+IA8%J#ID*,+:^#Ka`6N_j5D#PRC16bR2o.W;LpA&H$9%KlKAt%1@A,+lbOoi0%f3hgv;Hq9XDs#)LA,/0_LpO6*f3W4OrLMhgKm" + "/2`$#>@<9..Sl##/It/1jH3Q/fU:8.&N1Dd/NYS._J@5$Ii5<-+2)2'$RCG)lNEM0%'%<&A+Cf)EcG##+crB#%1]5/?29f3^*6,MgTdP.e4B>,7u>X(>&<+3G@oT%5H8f3k?jv6,:tG+" + "o;An1//DH?Rk)d#S>1?dn3A+`O#N$.+4J30c#HMXRpRQ0`o=8CQr,[H7uw97%3)6:wAi$>'vus-fR(dOg.:atqFrSO9MB:s79&b7m3'h`)fO=2:Z-F9B+%RS/H2oW&B)%RM1)6kjNL]PMP0^SY%&dfv1'GZWCj$kuY>fx;[$Hm$)*L4:$)G.Vv#n6+T.-E?A4)T9s$4fMB#?3Gg19[oC#^RS[u" + "4rpl/Zw2mQi;8/(LrsGhfhQ;-D7_J#11F7)tZp(fW?A3g2IK9JCao3%C;Dk#ID(7#UEaP]&(;]/2[9&$,CTm/_R(f).73Q/W:`e$@DUv-?]d8/[Xxw#iN%;Q2=hf)t_6$6[1+51[(J80" + "lL&s$X#c]#bcHs-I;:--(7,h%6ImO(4`%b/XRG)4:AK?dU]Op@P@Wt(29:N0XDF&#D-4&#@Y:l95Y^-6" + ".p[D*MkJv$&O(02qNh'HVIR8/OM>c4o6T9Ci#:9AM68p3/bc;/wwpouVuP$7U2t(Gd$tn=GR)Bq%.sV=Yp/R['?T3>dw]I7nr2)0i)#f[w#*CAu$l%W4'AWio0lV?;%*HW8$rN$ENF%mW-1h;N,fW2^#Soq68;vv$v`=At#a(U'#fdS2^7XW$#" + ";Z[0)1RL9Mc%g<$D.Y)4#,]]4(R7f3_Jp5AYFn8%CP,G4L#G:.l@h&6]?wG*^Tbp%Pp$[-YJ.d)@LR8%gTl&>bdh:%Zj::86k@e#S0P%?ZhN_,$(Q,*@:Z(+ZhEC,U;rG)cxN**5'A*+" + "ZfrL1G9=:8ej_<9w5-%-H?[i96V22'dA4P;Ar3X.oCt$%4dChN,ZGg1AG+jLs:Rv$0DHb%/W8f3wQO(g^$/N]O(*X/A,7PGkl*B,91Jh_" + "1rtA#n-[F69bi=-)Y8#%%9ve,mE&#*;a%=d]d`oA&a:%I-rY<-YwhQ8mAT;.>v:Q/xrZ&4nQXA#mJvJ1'LA8%55%&4iCAC#o4/B7@N<$6GM1Ddh10H[" + "&..Pd1MBDXp&r3C*cF1$:40@-C3A/2e:88SWq,IfiBj*%Isn#AkdodG%I9mqlKtE`?W(H0IV0:(Lf+hB'IWR#S&#C(,)b[18.%'%<&5ckI)A]G##=Z[0),VCs?>/>uo1NXFb329$C#mS=`uM*cB," + "oWG80=W3$6DC5-2hX6#6lrfs)n$wBt[_:$624L^#XX=)#o_d;-L=2e$'a8>,PkVT+BSYY#39Ks-5seC>h/>)47?v20BsZ&4vBo8%6VA1;`I,;Q'_>]u.ob318q.PdYkZ:([v'k#Ohv1'" + "FdwY7el.[7?R:F#C(ZCj^0v.3r^>r%xkkf,8>b:=AW[128wZ7-eaCo@OWe>^DKd#-sOQ-H7q/W-,hrR8[,lA#G[+Y$)?PF%Q0'#A[/_#$0CpFCUxTdg2N#$Df(T.3tuFrpD5T'd:35&CEcf(%'%<&[WpQ&Nhi2M@mnO(cFGH3L#G:.#&%Q/1r7DCUeRUdRY0[K20Biu`4+Aux$jrF;,$eko_g1<++pE@#DSq;;S?>d" + "DA-D-FdC>8lpBmVREIU7IKh;I@^2<%-xNn0,Mp+'$,-J*)vsI3>I9]$,'30;PcD218NY7I_iq&5(p(;QX4;f$00O$M$R>L8k-=2C:L3>dw8_+$R8La<6w9B#r]i,)Lx$m/:j8>CZkTIC" + "o:gV-ks*6L5[.Pdo_A8#.+SaExR?T.jd0'#4pm(#T%T*#(pkn8bVTf3w4eW.6itI)KF.<$/(On0xJ0s$-Q'<-)noH;HBIT*#7=.-F3OZ0O)cB,VR,W-lS#+%)[txW+=2.Itn@&FBD4Au" + "qCxfM@fP;-tNpA,tC`e$$jE_&uh1vH?JreMiMrtOo3NK:Som_#XDF&#E@%%#S,Gj^pVr0(.j^s$uS52=34pL($A(s-R&SF4#':Z'WO2?u^GwM0GbN?k(C.>6:0niLPJ=jLiK/[#oxBI;" + "9rS,3:wd3`g-I##BdS2^4D>##9H%O(03HA47FUhL&5oC#D6&tu&VZTIcm'^uY+'U#3CU9'Gs0&=S8-?\?1435&[,mQWh0bT%bvD#$@@.H3Q7qo.GXuS/L-YG%d:ThxM>rmh'*,pu,%'%<&eWAW-]VT49m:ge?M$nDNLt2.(Aa2.IRjjrq@)#)>/Gj.(Vf9vHuDPn*w9m1[u##EdS2^wVvw$t4e;%VRG)48'lA#DX_a4%#q3C" + "]DwFrwxxa#_Em=G8PL6MLnx,VR#O=(F`Aq^c93$#IL7%#`bkh(Z`#&)&*nD3BnPu%F*kp%^/p5S'9]9:KO1/1U)6<-+].:.tW`-#6,NH2KEaP]_kIJ1@16g)w*gm0dG`9&wgx9..FE:." + "_r0%6kUlf)L6#53kw*B0_CQ;-NKxCug1uV$T$n#6PEpOMB[vY#'`87.qjQiLX5P=$Tr[fL(%seh(5qUJ)v>^c30C%X-cl^',K[J6_r=G:1PG-[Hof$9REM0`:t;.2VJfLG7SX-1(:+*]R?tJec]+4wVp.*4+h$[N_j=.(0rC$G,^w6%4^S#QFD.*[h3LDVCi2Rva)re&YiPZSMuFrt^#l'**Lq%" + "S>4G`HYET%41*I-1O/72D1IE5704mQ-Xuw#@awX)0@lm'L?^<8mIgZf^gO9%)O$]%I>mA#2K4L#5m;;?[iZ=YBul=G$jV=YAC" + "$ed19avj=GAWD80$tn=G`9#j=w[)_f-u13Vm^3$#^Kb&#B`gT7?v+B,^wnW$*oNn0]K)%%Zd*P(d+8`&3,7`&5ptNFd/<-&vX0^#0W5W-6q3+%TEKNrWtvYuT(;?#HYYF%mZ&ZulT7U." + "a0j=GTu_H-'NA[9j=%a+0QSn0ji),)$S'41TH8&,2xg%%_c^-Q2i:8.AKwUMe8nqMST3F.?FYI)Q#P)4XIVp.`8i;dd*3I$PUSCMbV0K-Ag=,/xZ6/&n=ge$f>s-&/>i,MfER$&V)f;d" + "'41@'_imp%Pcd/:q;h^#87>##9hVr7Fa,[-njTq%-M:;$eN;hLq[3r725Ld4ukP;-n-cp0,s$&4oLc'&*rB^#?PH$8^+Na,AX,hL(-[pgPGE,#PSuD%`=K,39sZ]4]52T/&@Rq$rUFb3" + ",asFrbduvuMvLjmS@#+.,59+SJ=%dhLS._,$h.^LVZ#)lNn0-%.+5V`v[-kT&],Enn8%O=Y)4wHuD#v.<9/tgOU%U`G>#'6h/N7l5/1PcvsK*=4s-hNO'gL/m/C2$).P`YP/CTCRr8RMB58uVZ?\?Mn78%:CRS%366Q8]`O_J>,guC(pH@9SZK<-Oe/;%>H&7WT4T&#HYTd'&fB9rp`UWf<;DD3/?ID*;^9Z-f(]]4" + "s@&d)hJu-$6LhF=V765/.?Gu>V465/F`R9C-1niLpXn'=D(`4)-U%Zu33GouI(*kNmv2*M$tv##'X6iL%pO.)jH_Lj+wn5/Ak3Q/`W]I*=sG,*Z96a3mtIpYRxed]@86M?DrZ4:Tw/I4" + "(cKs$l=i@@=R[euf5*523C)-::KF&#qt)W-1;b9D5DPV-T9om,NcYY#TCTfL<,OF3*wRa$)+&s$rTZd3b@u)4+Rw.:XJa`#0LQ3B9978R9j._u?5?,,,i:8..pK+`Y+Xj$::h0,CjTJD" + "P*U@k$1P]>;>WJ2GkZ,r2Gg1Y5#kkf^#;/+gOxtq6:].3fWiCR;dc.J>V@uP<[:t9KCR#Gv8h=Ed[x+:[K#Qw3l-,SUY$dp2QD-*/Zp%" + "7L[Q''fNn0RsMhL(mUD34WFL#jL3]-``1I3(Ci;nJj+ru$,_^u=W/+%JTW;-9Ib2C(q0Pd[Ln;-`b(g@`CrT/am45&O[l^,tGn,Z.s_A*[L2*m%],G4$L[+4p/0i)NIHg))wZ)4Gt%s-" + "*^JW$tK(m-2hPZwO3C#-grec;uC$K8wp@aST/D420kL2Hf'R/ogJ*v:P^?f,Q_/P%5p@Qk(T/uxmQWl/]VW,c5g)QO*e.k*_^uV9RH.jZA>#ma;C#aOk9&" + "I5ts'alVP&/.=X(,3cv*0NcT.m=V0$V_`=-Wwnf$P####'>uu#4#Z3#v6QtLUOvu#AbW3M1ilS.&?F&#D+2t-[.JfLf:qV-6680-XEM_&5xkA#R&+>.F.$##ejZF%Bk60Hi^u-$&m_#C" + "NpaR3U)'#_rvg=MHu)?7]f`;Y8NkfMB8O?R4IsJ%JImQWHqPF%5lQ78Kqe`];>%RP@q44N$en]-3I^l4[1ivPx:K-MF1:x&mp`gL)7GcMZaA%#r&3aaaBV,#4e53#wDmV#*OGF#fejL#" + "Q$bT#*1rZ#,8W`#/B=e#0@gi#5Iuu#JBr($iT<5$&IR<$ULaH$jx%T$Vl;[$uAXa$Lvc3%R)=&%*TT:%tJ%H%bCUn%Qj,V%+XAa%+%wg%8/]l%<v(>+^2)([g^)VflN)@+'#*l*qf)5@=m)" + "B7B>*$h)-*d235*[:B>*q^vG*Wv#c*i62<+efC,+8cl3+(FD<+=u_G+uFNT+XExX+Z_p^+e(%d+hp;h+um9n+Lxsx+A3?,,9Ss5,wv%A,N$4M,[rds,meEa,PaBj,h4<9-ObL,-csjA-" + ")#NL-N^'R-uibY-T#-g-dfv4.oKp#.RTT+.pd(S.h.QG.f(Wl.o>D[.#//e..qL4/rmj&/;fDL/e>V>#]F[0>M3o-$.(1B#L[+VdYY.JCYG?mv1BujNe$#t7;-T-]tn92gdMk++I2GDYo'?H#-QY5+v4L#" + "[Z'x0_6qw0>j^uG9T9X1lrIk4+-E/#:,BP8&dCEHp4`PB;^5o1a:XG<2/_oDCt7FHbmndFgkqdF-4%F-)G@@-G3FGH,C%12AMM=-H1F7/Y1Vq1CTnrL'Ch*#D):@/5d:J:W-xrv9)iaV-#Cv#O-iBGO-aqdT-$GqS-'?Z-.;9^kLJ*xU.,3h'#WG5s-^2TkLcU$lLp6mp3Ai0JF7DmlE>FK@-1CUO1?6[L28V7ZQpRC`Nn4$##+0A'.6sarLNf=rL]3oiLPVZ-N" + ">2oiL?Z/eG38vLF%fCkL-:Mt-0aErLc_4rL0)Uk.,gpKF,r0o-T?*1#u<*1#rENvPWpT(MT)rR#(AcY#,VC;$0o$s$41[S%8I<5&tU^l8Ym@M9^/x.:$sul&@$TM'D<5/(HTlf(LmLG)" + "P/.)*TGe`*X`EA+]x&#,a:^Y,eR>;-ikur-m-VS.qE75/u^nl/#wNM0'90/1+Qgf1/jGG23,))37D``3;]@A4?uwx4C7XY5GO9;6Khpr6O*QS7SB258WZil8[sIM9`5+/:dMbf:hfBG;" + "l($)*L4;?.ekr?2'LS@6?-5A:WdlA>pDMBB2&/CFJ]fCJc=GDN%u(ER=U`EVU6AFZnmxF_0NYGcH/;HgafrHk#GSIo;(5JsS_lJwl?MK%/w.L)GWfL-`8GM" + "1xo(N5:P`N9R1AO=khxOA-IYPEE*;QI^arQMvASRQ8#5SUPYlSYi:MT^+r.UbCRfUf[3GVjtj(Wn6K`WrN,AXvgcxXot*GV&6`uY*N@VZ.gw7[2)Xo[6A9P]:Yp1^>rPi^B42J_FLi+`" + "JeIc`N'+DaR?b%bVWB]bZp#>c_2ZuccJ;Vdgcr7ek%Soeo=4PfsUk1gwnKig%1-Jh)Id+i-bDciu&FS()Foc2cblh25Lx_#f/mc2k0.+49eF`#j;mc2sTEC5eh#e#?inc2t/-4Ci*He#" + "D(4)3dhuh26Ox_#h82)3l67+4:hF`#lD2)3tZNC5fk#e#Ar3)3u564Cj-He#F1OD3en(i27Rx_#jAMD3m<@+4;kF`#nMMD3uaWC5gn#e#C%OD3v;?4Ck0He#H:k`3ft1i28Ux_#lJi`3" + "nBI+4tF`#tiIA4xssC5" + "jw#e#I@KA4#NZ4Cn9He#NUg]4i0Mi2;_x_#rfe]4qTe+4?wF`#vre]4#$'D5k$$e#KIg]4$Td4Co5k<`i2=ex_#vxE>5saw+4A'G`#$/F>5%09D5m*$e#O[G>5&av4CqBHe#&'32B=.wm2f2$`#q712BER804jJH`#uC12BMwOH5?N%e#Jq22BNQ79CDmRe#p7LMB@=E33h;-`#tCLMB" + "Hb]K4lSQ`#xOLMBx;D-`#vLhiBIhfK4mVQ`#$YhiB#BM>#hda1#mPh5#vTg5#pHf^?ht^6_#2S4;2ZR%@&g6c+aq-vA4rkL>S=*p.F.s##GM.tB:oHY-N]IV?:K=?.Ao.R]DlGQ8d*RH=q1a;.B'hI?\?C-i<8F4g7ioQV[b+MT..lbD-Lx'<.m7T)0KNI@'F]+Z2.HZV[#9U<.WKXD-1*6EO`ZwG&Y_bpLx;4/MAbl,M[kQ1MW6ErAQ.r`?IO,Q#$1_A.'$VC?" + "i6oS1#Yp?-=$)N$hpjHQ;E/_UOj$lM5/Mis]Z0'f:Z[$tOZ[IVxiLkEBB-0_3uL8;5Z2)[S4=Gs2f+3QUD?=5Ok+1KtC?Nx%a+t9_eH7TDj$" + "Jk2Q8XO`Y#_0>?84I1gLq.h88mTg5#EmM^[I@'_[0c._J*'#N04El/18x7F/8o99_b`qpL7]2..KU=5Ma1tv8%N+X%jv>Q&C8H<8ng,ND,K#01`SY<-o*t^-TM@tLL_K?pewI59RNSE-" + "7lS?-H-^V[uL+Z2@vv>-qZXv7rR)W[%)^5Bp&aE-$44^-Z,g34B3lV7G),^O[^>01hM8;]+o>290h';.>X&[-:jL01tQ5293Y)w8;pU01Z,[?-C3aQ8oaT`<*#DT.=cMv[,>^;-0`uS." + "d>N:.fIY`1)d7Q#xiD^[oV(HOtxa*I_P_;.oYs_&XZ*.-Wdi^#iB;a'J8voL,v&nLXJ4tAm`/aYx*RV[A)eU%Z:)##N`DZ[nih5#lLM>#`0>?8@8.11,L`Y#qmQ][c<9B-GbE9.C[<9." + "wh;?8Ou*[K08o0(2xL$#=;B%BnYAj07v7b+'#vW[h6mh/?BtW[m26Q#<)d,*1=(,M;PM11c.5F%gI-" + "nWeI-mWeI-'-@:MC8xiLVQ#<-)-@:MED4jLVQ#<-+-@:MGPFjLVQ#<---@:MI]XjLVQ#<-/-@:MT'G311^-Q#6N3a0KJco.LeiS8PF%U.>=*p.Cb_&4Ht$[-Xt^31/5bW[U?tW[g5Y>-" + ":E%HF:/^5B)/HDO9[4h-3bqY?p=Vt7/ChB#@h0R0pXQI2Ok5R*sIZj)NQx:.)I?)4J;gJ2@_lA#lL$^(xmoi0WLq-MtS%)*[;w0#ENh>.=`EC#O5`P-Qmm*MmfC12x@HP8EktW[r89I*" + "qI(W3lYnV[M0'qLCKV41BG$)*bf-@->u68.==*p.t2Gx9h:_5B+ktpLK&-Q#o?;W3NYWI),p,*4lS*)**SEjLLYDm0KYmp0em-=.*$GGOG[[D4bhb>-nQ=v-%=ufL]hev6ONjj<7C4g7" + "-#fm#,7%a+W+$$$qi-<8uG@g%>^3uLVPq%/HsD^[*8WW/>+KE-vLg?-e0WE-$$esA_$d2$'#6k<+vlW--?D_&]A[][djPS3e,K*R&RW5/&;7-5Eai?B9KJ9io/vERAcM>CQ@#B#sg([K" + ">0]3FwNEp.DxvuP$.0oLGD7p._FOe$E50HbJ3jU16rwZ55R/N-AqYhL,?(&&GWEjL" + "nkHq9ohN)Y-Z9T(_eMs7]:^;.*dKK-0:%I-S;m)/u7%N-]_Bil[TXp.#Hu>-*D,XCBWkC?]<3p1kbMG)iEsM62Qsc6=Yf88F&eG.@XmP8" + "Z(-kLE]o;8+dUv@[V[,&cHV].&,*=.V=SF/JsIg%&w+<8LV'HOK0Y<8hbxV[GQF9B&0:?6fDGY-?)1pprsqY?_?u88aQHo05nw;-a2gr-Skt)#U7[uNRdamL9dWR8O8S9]:?hc))U&X[" + "]?tW[>3:o/G*q5#Q`0U[tgt;.&PCs3j-C2:ebE-*/D+j17uqF.IiF<%$BlW[AS2Z[uBtW[L0$6#D@Ib%o_Ib%%0Pb%r]L9]/:)=-*2#HM%HgnLK1(588pWG<$]bA#u&sc-wS,<-%V,<-CIrIM,sPoL6:)=-7u@Y-_1(F.%.Jb%%0Pb%8)4O+2>hY?CHNX(:/4O+`OVmLDA2pL%+p+M*G;pLH:)=-:2#HM5SMpLHl+87HUaSA$]bA#/c%pAU)OX(" + "/LJb%>LxPB#%]u7k'xlB/HZV[2KL@-5a5<-e(MT.f$h5#UT=Z-JZa$'4DmW[1E(@-IMGHM^L4RMa0nlLQR=RMR>_<.N(wP5b,RGEb6L[0=-#(&_>3)Fd(nY6lxjDFndXfNanX7MS&c?-" + "Aa5<-x9]>-P5g,Mg&5;1;k(Z#tco;6Ij@g%a:nS.Hi/Q#@oi'#Ebl:d+d7Q#hw]][rwB`$nLs5#rlq5#/YHF%4s1G%VR)##mINX(=3<%$=cDg.VndC?J7VI?+FAw86$/@':bc/Li+kS7" + ";8JoLHF_l8.V&,2a>]N0c3X(NmpL(]jh8*#1J>lLR[+##"; + + return openIconic_compressed_data_base85; +} +// clang-format on diff --git a/nvpro_core_legacy/imgui/imgui_icon.h b/nvpro_core_legacy/imgui/imgui_icon.h new file mode 100644 index 0000000..8f70693 --- /dev/null +++ b/nvpro_core_legacy/imgui/imgui_icon.h @@ -0,0 +1,256 @@ +/* + * Copyright (c) 2023-2024, NVIDIA CORPORATION. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-FileCopyrightText: Copyright (c) 2023-2024, NVIDIA CORPORATION. + * SPDX-License-Identifier: Apache-2.0 + */ + +/// @DOC_SKIP + +#pragma once +#include + +// Expose the OpenIconic font data +const char* getOpenIconicFontCompressedBase85TTF(); + +namespace OpenIconic { + +// Icon constants for OpenIconic font (Unicode range 0xE000 - 0xE0DF) + +[[maybe_unused]] static const char* icon_account_login = (char*)u8"\ue000"; +[[maybe_unused]] static const char* icon_account_logout = (char*)u8"\ue001"; +[[maybe_unused]] static const char* icon_action_redo = (char*)u8"\ue002"; +[[maybe_unused]] static const char* icon_action_undo = (char*)u8"\ue003"; +[[maybe_unused]] static const char* icon_align_center = (char*)u8"\ue004"; +[[maybe_unused]] static const char* icon_align_left = (char*)u8"\ue005"; +[[maybe_unused]] static const char* icon_align_right = (char*)u8"\ue006"; +[[maybe_unused]] static const char* icon_aperture = (char*)u8"\ue007"; +[[maybe_unused]] static const char* icon_arrow_bottom = (char*)u8"\ue008"; +[[maybe_unused]] static const char* icon_arrow_circle_bottom = (char*)u8"\ue009"; +[[maybe_unused]] static const char* icon_arrow_circle_left = (char*)u8"\ue00A"; +[[maybe_unused]] static const char* icon_arrow_circle_right = (char*)u8"\ue00B"; +[[maybe_unused]] static const char* icon_arrow_circle_top = (char*)u8"\ue00C"; +[[maybe_unused]] static const char* icon_arrow_left = (char*)u8"\ue00D"; +[[maybe_unused]] static const char* icon_arrow_right = (char*)u8"\ue00E"; +[[maybe_unused]] static const char* icon_arrow_thick_bottom = (char*)u8"\ue00F"; +[[maybe_unused]] static const char* icon_arrow_thick_left = (char*)u8"\ue010"; +[[maybe_unused]] static const char* icon_arrow_thick_right = (char*)u8"\ue011"; +[[maybe_unused]] static const char* icon_arrow_thick_top = (char*)u8"\ue012"; +[[maybe_unused]] static const char* icon_arrow_top = (char*)u8"\ue013"; +[[maybe_unused]] static const char* icon_audio = (char*)u8"\ue014"; +[[maybe_unused]] static const char* icon_audio_spectrum = (char*)u8"\ue015"; +[[maybe_unused]] static const char* icon_badge = (char*)u8"\ue016"; +[[maybe_unused]] static const char* icon_ban = (char*)u8"\ue017"; +[[maybe_unused]] static const char* icon_bar_chart = (char*)u8"\ue018"; +[[maybe_unused]] static const char* icon_basket = (char*)u8"\ue019"; +[[maybe_unused]] static const char* icon_battery_empty = (char*)u8"\ue01A"; +[[maybe_unused]] static const char* icon_battery_full = (char*)u8"\ue01B"; +[[maybe_unused]] static const char* icon_beaker = (char*)u8"\ue01C"; +[[maybe_unused]] static const char* icon_bell = (char*)u8"\ue01D"; +[[maybe_unused]] static const char* icon_bluetooth = (char*)u8"\ue01E"; +[[maybe_unused]] static const char* icon_bold = (char*)u8"\ue01F"; +[[maybe_unused]] static const char* icon_bolt = (char*)u8"\ue020"; +[[maybe_unused]] static const char* icon_book = (char*)u8"\ue021"; +[[maybe_unused]] static const char* icon_bookmark = (char*)u8"\ue022"; +[[maybe_unused]] static const char* icon_box = (char*)u8"\ue023"; +[[maybe_unused]] static const char* icon_briefcase = (char*)u8"\ue024"; +[[maybe_unused]] static const char* icon_british_pound = (char*)u8"\ue025"; +[[maybe_unused]] static const char* icon_browser = (char*)u8"\ue026"; +[[maybe_unused]] static const char* icon_brush = (char*)u8"\ue027"; +[[maybe_unused]] static const char* icon_bug = (char*)u8"\ue028"; +[[maybe_unused]] static const char* icon_bullhorn = (char*)u8"\ue029"; +[[maybe_unused]] static const char* icon_calculator = (char*)u8"\ue02A"; +[[maybe_unused]] static const char* icon_calendar = (char*)u8"\ue02B"; +[[maybe_unused]] static const char* icon_camera_slr = (char*)u8"\ue02C"; +[[maybe_unused]] static const char* icon_caret_bottom = (char*)u8"\ue02D"; +[[maybe_unused]] static const char* icon_caret_left = (char*)u8"\ue02E"; +[[maybe_unused]] static const char* icon_caret_right = (char*)u8"\ue02F"; +[[maybe_unused]] static const char* icon_caret_top = (char*)u8"\ue030"; +[[maybe_unused]] static const char* icon_cart = (char*)u8"\ue031"; +[[maybe_unused]] static const char* icon_chat = (char*)u8"\ue032"; +[[maybe_unused]] static const char* icon_check = (char*)u8"\ue033"; +[[maybe_unused]] static const char* icon_chevron_bottom = (char*)u8"\ue034"; +[[maybe_unused]] static const char* icon_chevron_left = (char*)u8"\ue035"; +[[maybe_unused]] static const char* icon_chevron_right = (char*)u8"\ue036"; +[[maybe_unused]] static const char* icon_chevron_top = (char*)u8"\ue037"; +[[maybe_unused]] static const char* icon_circle_check = (char*)u8"\ue038"; +[[maybe_unused]] static const char* icon_circle_x = (char*)u8"\ue039"; +[[maybe_unused]] static const char* icon_clipboard = (char*)u8"\ue03A"; +[[maybe_unused]] static const char* icon_clock = (char*)u8"\ue03B"; +[[maybe_unused]] static const char* icon_cloud_download = (char*)u8"\ue03C"; +[[maybe_unused]] static const char* icon_cloud_upload = (char*)u8"\ue03D"; +[[maybe_unused]] static const char* icon_cloud = (char*)u8"\ue03E"; +[[maybe_unused]] static const char* icon_cloudy = (char*)u8"\ue03F"; +[[maybe_unused]] static const char* icon_code = (char*)u8"\ue040"; +[[maybe_unused]] static const char* icon_cog = (char*)u8"\ue041"; +[[maybe_unused]] static const char* icon_collapse_down = (char*)u8"\ue042"; +[[maybe_unused]] static const char* icon_collapse_left = (char*)u8"\ue043"; +[[maybe_unused]] static const char* icon_collapse_right = (char*)u8"\ue044"; +[[maybe_unused]] static const char* icon_collapse_up = (char*)u8"\ue045"; +[[maybe_unused]] static const char* icon_command = (char*)u8"\ue046"; +[[maybe_unused]] static const char* icon_comment_square = (char*)u8"\ue047"; +[[maybe_unused]] static const char* icon_compass = (char*)u8"\ue048"; +[[maybe_unused]] static const char* icon_contrast = (char*)u8"\ue049"; +[[maybe_unused]] static const char* icon_copywriting = (char*)u8"\ue04A"; +[[maybe_unused]] static const char* icon_credit_card = (char*)u8"\ue04B"; +[[maybe_unused]] static const char* icon_crop = (char*)u8"\ue04C"; +[[maybe_unused]] static const char* icon_dashboard = (char*)u8"\ue04D"; +[[maybe_unused]] static const char* icon_data_transfer_download = (char*)u8"\ue04E"; +[[maybe_unused]] static const char* icon_data_transfer_upload = (char*)u8"\ue04F"; +[[maybe_unused]] static const char* icon_delete = (char*)u8"\ue050"; +[[maybe_unused]] static const char* icon_dial = (char*)u8"\ue051"; +[[maybe_unused]] static const char* icon_document = (char*)u8"\ue052"; +[[maybe_unused]] static const char* icon_dollar = (char*)u8"\ue053"; +[[maybe_unused]] static const char* icon_double_quote_sans_left = (char*)u8"\ue054"; +[[maybe_unused]] static const char* icon_double_quote_sans_right = (char*)u8"\ue055"; +[[maybe_unused]] static const char* icon_double_quote_serif_left = (char*)u8"\ue056"; +[[maybe_unused]] static const char* icon_double_quote_serif_right = (char*)u8"\ue057"; +[[maybe_unused]] static const char* icon_droplet = (char*)u8"\ue058"; +[[maybe_unused]] static const char* icon_eject = (char*)u8"\ue059"; +[[maybe_unused]] static const char* icon_elevator = (char*)u8"\ue05A"; +[[maybe_unused]] static const char* icon_ellipses = (char*)u8"\ue05B"; +[[maybe_unused]] static const char* icon_envelope_closed = (char*)u8"\ue05C"; +[[maybe_unused]] static const char* icon_envelope_open = (char*)u8"\ue05D"; +[[maybe_unused]] static const char* icon_euro = (char*)u8"\ue05E"; +[[maybe_unused]] static const char* icon_excerpt = (char*)u8"\ue05F"; +[[maybe_unused]] static const char* icon_expend_down = (char*)u8"\ue060"; +[[maybe_unused]] static const char* icon_expend_left = (char*)u8"\ue061"; +[[maybe_unused]] static const char* icon_expend_right = (char*)u8"\ue062"; +[[maybe_unused]] static const char* icon_expend_up = (char*)u8"\ue063"; +[[maybe_unused]] static const char* icon_external_link = (char*)u8"\ue064"; +[[maybe_unused]] static const char* icon_eye = (char*)u8"\ue065"; +[[maybe_unused]] static const char* icon_eyedropper = (char*)u8"\ue066"; +[[maybe_unused]] static const char* icon_file = (char*)u8"\ue067"; +[[maybe_unused]] static const char* icon_fire = (char*)u8"\ue068"; +[[maybe_unused]] static const char* icon_flag = (char*)u8"\ue069"; +[[maybe_unused]] static const char* icon_flash = (char*)u8"\ue06A"; +[[maybe_unused]] static const char* icon_folder = (char*)u8"\ue06B"; +[[maybe_unused]] static const char* icon_fork = (char*)u8"\ue06C"; +[[maybe_unused]] static const char* icon_fullscreen_enter = (char*)u8"\ue06D"; +[[maybe_unused]] static const char* icon_fullscreen_exit = (char*)u8"\ue06E"; +[[maybe_unused]] static const char* icon_globe = (char*)u8"\ue06F"; +[[maybe_unused]] static const char* icon_graph = (char*)u8"\ue070"; +[[maybe_unused]] static const char* icon_grid_four_up = (char*)u8"\ue071"; +[[maybe_unused]] static const char* icon_grid_three_up = (char*)u8"\ue072"; +[[maybe_unused]] static const char* icon_grid_two_up = (char*)u8"\ue073"; +[[maybe_unused]] static const char* icon_hard_drive = (char*)u8"\ue074"; +[[maybe_unused]] static const char* icon_header = (char*)u8"\ue075"; +[[maybe_unused]] static const char* icon_headphones = (char*)u8"\ue076"; +[[maybe_unused]] static const char* icon_heart = (char*)u8"\ue077"; +[[maybe_unused]] static const char* icon_home = (char*)u8"\ue078"; +[[maybe_unused]] static const char* icon_image = (char*)u8"\ue079"; +[[maybe_unused]] static const char* icon_inbox = (char*)u8"\ue07A"; +[[maybe_unused]] static const char* icon_infinity = (char*)u8"\ue07B"; +[[maybe_unused]] static const char* icon_info = (char*)u8"\ue07C"; +[[maybe_unused]] static const char* icon_italic = (char*)u8"\ue07D"; +[[maybe_unused]] static const char* icon_justify_center = (char*)u8"\ue07E"; +[[maybe_unused]] static const char* icon_justify_left = (char*)u8"\ue07F"; +[[maybe_unused]] static const char* icon_justify_right = (char*)u8"\ue080"; +[[maybe_unused]] static const char* icon_key = (char*)u8"\ue081"; +[[maybe_unused]] static const char* icon_laptop = (char*)u8"\ue082"; +[[maybe_unused]] static const char* icon_layers = (char*)u8"\ue083"; +[[maybe_unused]] static const char* icon_lightbulb = (char*)u8"\ue084"; +[[maybe_unused]] static const char* icon_link_broken = (char*)u8"\ue085"; +[[maybe_unused]] static const char* icon_link_intact = (char*)u8"\ue086"; +[[maybe_unused]] static const char* icon_list = (char*)u8"\ue087"; +[[maybe_unused]] static const char* icon_list_rich = (char*)u8"\ue088"; +[[maybe_unused]] static const char* icon_location = (char*)u8"\ue089"; +[[maybe_unused]] static const char* icon_lock_locked = (char*)u8"\ue08A"; +[[maybe_unused]] static const char* icon_lock_unlocked = (char*)u8"\ue08B"; +[[maybe_unused]] static const char* icon_loop_circular = (char*)u8"\ue08C"; +[[maybe_unused]] static const char* icon_loop_square = (char*)u8"\ue08D"; +[[maybe_unused]] static const char* icon_loop = (char*)u8"\ue08E"; +[[maybe_unused]] static const char* icon_magnifying_glass = (char*)u8"\ue08F"; +[[maybe_unused]] static const char* icon_map = (char*)u8"\ue090"; +[[maybe_unused]] static const char* icon_map_marquer = (char*)u8"\ue091"; +[[maybe_unused]] static const char* icon_media_pause = (char*)u8"\ue092"; +[[maybe_unused]] static const char* icon_media_play = (char*)u8"\ue093"; +[[maybe_unused]] static const char* icon_media_record = (char*)u8"\ue094"; +[[maybe_unused]] static const char* icon_media_skip_backward = (char*)u8"\ue095"; +[[maybe_unused]] static const char* icon_media_skip_forward = (char*)u8"\ue096"; +[[maybe_unused]] static const char* icon_media_step_backward = (char*)u8"\ue097"; +[[maybe_unused]] static const char* icon_media_step_forward = (char*)u8"\ue098"; +[[maybe_unused]] static const char* icon_media_stop = (char*)u8"\ue099"; +[[maybe_unused]] static const char* icon_medical_cross = (char*)u8"\ue09A"; +[[maybe_unused]] static const char* icon_menu = (char*)u8"\ue09B"; +[[maybe_unused]] static const char* icon_microphone = (char*)u8"\ue09C"; +[[maybe_unused]] static const char* icon_minus = (char*)u8"\ue09D"; +[[maybe_unused]] static const char* icon_monitor = (char*)u8"\ue09E"; +[[maybe_unused]] static const char* icon_moon = (char*)u8"\ue09F"; +[[maybe_unused]] static const char* icon_move = (char*)u8"\ue0A0"; +[[maybe_unused]] static const char* icon_musical_note = (char*)u8"\ue0A1"; +[[maybe_unused]] static const char* icon_paperclip = (char*)u8"\ue0A2"; +[[maybe_unused]] static const char* icon_pencil = (char*)u8"\ue0A3"; +[[maybe_unused]] static const char* icon_people = (char*)u8"\ue0A4"; +[[maybe_unused]] static const char* icon_person = (char*)u8"\ue0A5"; +[[maybe_unused]] static const char* icon_phone = (char*)u8"\ue0A6"; +[[maybe_unused]] static const char* icon_pie_chart = (char*)u8"\ue0A7"; +[[maybe_unused]] static const char* icon_pin = (char*)u8"\ue0A8"; +[[maybe_unused]] static const char* icon_play_circle = (char*)u8"\ue0A9"; +[[maybe_unused]] static const char* icon_plus = (char*)u8"\ue0AA"; +[[maybe_unused]] static const char* icon_power_standby = (char*)u8"\ue0AB"; +[[maybe_unused]] static const char* icon_print = (char*)u8"\ue0AC"; +[[maybe_unused]] static const char* icon_project = (char*)u8"\ue0AD"; +[[maybe_unused]] static const char* icon_pulse = (char*)u8"\ue0AE"; +[[maybe_unused]] static const char* icon_puzzle_piece = (char*)u8"\ue0AF"; +[[maybe_unused]] static const char* icon_question_mark = (char*)u8"\ue0B0"; +[[maybe_unused]] static const char* icon_rain = (char*)u8"\ue0B1"; +[[maybe_unused]] static const char* icon_random = (char*)u8"\ue0B2"; +[[maybe_unused]] static const char* icon_reload = (char*)u8"\ue0B3"; +[[maybe_unused]] static const char* icon_resize_both = (char*)u8"\ue0B4"; +[[maybe_unused]] static const char* icon_resize_height = (char*)u8"\ue0B5"; +[[maybe_unused]] static const char* icon_resize_width = (char*)u8"\ue0B6"; +[[maybe_unused]] static const char* icon_rss = (char*)u8"\ue0B7"; +[[maybe_unused]] static const char* icon_rss_alt = (char*)u8"\ue0B8"; +[[maybe_unused]] static const char* icon_script = (char*)u8"\ue0B9"; +[[maybe_unused]] static const char* icon_share = (char*)u8"\ue0BA"; +[[maybe_unused]] static const char* icon_share_boxed = (char*)u8"\ue0BB"; +[[maybe_unused]] static const char* icon_shield = (char*)u8"\ue0BC"; +[[maybe_unused]] static const char* icon_signal = (char*)u8"\ue0BD"; +[[maybe_unused]] static const char* icon_signpost = (char*)u8"\ue0BE"; +[[maybe_unused]] static const char* icon_sort_ascending = (char*)u8"\ue0BF"; +[[maybe_unused]] static const char* icon_sort_descending = (char*)u8"\ue0C0"; +[[maybe_unused]] static const char* icon_spreadsheet = (char*)u8"\ue0C1"; +[[maybe_unused]] static const char* icon_star = (char*)u8"\ue0C2"; +[[maybe_unused]] static const char* icon_sun = (char*)u8"\ue0C3"; +[[maybe_unused]] static const char* icon_tablet = (char*)u8"\ue0C4"; +[[maybe_unused]] static const char* icon_tag = (char*)u8"\ue0C5"; +[[maybe_unused]] static const char* icon_tags = (char*)u8"\ue0C6"; +[[maybe_unused]] static const char* icon_target = (char*)u8"\ue0C7"; +[[maybe_unused]] static const char* icon_task = (char*)u8"\ue0C8"; +[[maybe_unused]] static const char* icon_terminal = (char*)u8"\ue0C9"; +[[maybe_unused]] static const char* icon_text = (char*)u8"\ue0CA"; +[[maybe_unused]] static const char* icon_thumb_down = (char*)u8"\ue0CB"; +[[maybe_unused]] static const char* icon_thumb_up = (char*)u8"\ue0CC"; +[[maybe_unused]] static const char* icon_timer = (char*)u8"\ue0CD"; +[[maybe_unused]] static const char* icon_transfer = (char*)u8"\ue0CE"; +[[maybe_unused]] static const char* icon_trash = (char*)u8"\ue0CF"; +[[maybe_unused]] static const char* icon_underline = (char*)u8"\ue0D0"; +[[maybe_unused]] static const char* icon_vertical_align_bottom = (char*)u8"\ue0D1"; +[[maybe_unused]] static const char* icon_vertical_align_center = (char*)u8"\ue0D2"; +[[maybe_unused]] static const char* icon_vertical_align_top = (char*)u8"\ue0D3"; +[[maybe_unused]] static const char* icon_video = (char*)u8"\ue0D4"; +[[maybe_unused]] static const char* icon_volume_high = (char*)u8"\ue0D5"; +[[maybe_unused]] static const char* icon_volume_low = (char*)u8"\ue0D6"; +[[maybe_unused]] static const char* icon_volume_off = (char*)u8"\ue0D7"; +[[maybe_unused]] static const char* icon_warning = (char*)u8"\ue0D8"; +[[maybe_unused]] static const char* icon_wifi = (char*)u8"\ue0D9"; +[[maybe_unused]] static const char* icon_wrench = (char*)u8"\ue0DA"; +[[maybe_unused]] static const char* icon_x = (char*)u8"\ue0DB"; +[[maybe_unused]] static const char* icon_yen = (char*)u8"\ue0DC"; +[[maybe_unused]] static const char* icon_zoom_in = (char*)u8"\ue0DD"; +[[maybe_unused]] static const char* icon_zoom_out = (char*)u8"\ue0DE"; + +} // namespace OpenIconic diff --git a/nvpro_core_legacy/nvh/nsightevents.h b/nvpro_core_legacy/nvh/nsightevents.h new file mode 100644 index 0000000..63b2461 --- /dev/null +++ b/nvpro_core_legacy/nvh/nsightevents.h @@ -0,0 +1,82 @@ +#ifndef __NSIGHTEVENTS__ +#define __NSIGHTEVENTS__ + +/// @DOC_SKIP (keyword to exclude this file from automatic README.md generation) + +//----------------------------------------------------------------------------- +// NSIGHT +//----------------------------------------------------------------------------- +#ifdef NVP_SUPPORTS_NVTOOLSEXT +// NSight perf markers - using NVTX from GitHub +// Define NVTX_NO_IMPL to avoid including implementation details (we link against NVToolsExt library) +#define NVTX_NO_IMPL +#include + +typedef int(NVTX_API* nvtxRangePushEx_Pfn)(const nvtxEventAttributes_t* eventAttrib); +typedef int(NVTX_API* nvtxRangePush_Pfn)(const char* message); +typedef int(NVTX_API* nvtxRangePop_Pfn)(); +extern nvtxRangePushEx_Pfn nvtxRangePushEx_dyn; +extern nvtxRangePush_Pfn nvtxRangePush_dyn; +extern nvtxRangePop_Pfn nvtxRangePop_dyn; +extern nvtxEventAttributes_t eventAttr; + +#define NX_RANGE nvtxRangeId_t +#define NX_MARK(name) nvtxMark(name) +#define NX_RANGESTART(name) nvtxRangeStart(name) +#define NX_RANGEEND(id) nvtxRangeEnd(id) +#define NX_RANGEPUSH(name) nvtxRangePush(name) +#define NX_RANGEPUSHCOL(name, c) \ + { \ + nvtxEventAttributes_t eventAttrib = {0}; \ + eventAttrib.version = NVTX_VERSION; \ + eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE; \ + eventAttrib.colorType = NVTX_COLOR_ARGB; \ + eventAttrib.color = c; \ + eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII; \ + eventAttrib.message.ascii = name; \ + nvtxRangePushEx(&eventAttrib); \ + } +#define NX_RANGEPOP() nvtxRangePop() +struct NXProfileFunc +{ + NXProfileFunc(const char* name, uint32_t c, /*int64_t*/ uint32_t p = 0) + { + nvtxEventAttributes_t eventAttrib = {0}; + // set the version and the size information + eventAttrib.version = NVTX_VERSION; + eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE; + // configure the attributes. 0 is the default for all attributes. + eventAttrib.colorType = NVTX_COLOR_ARGB; + eventAttrib.color = c; + eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII; + eventAttrib.message.ascii = name; + eventAttrib.payloadType = NVTX_PAYLOAD_TYPE_INT64; + eventAttrib.payload.llValue = (int64_t)p; + eventAttrib.category = (uint32_t)p; + nvtxRangePushEx(&eventAttrib); + } + ~NXProfileFunc() { nvtxRangePop(); } +}; +#ifdef NXPROFILEFUNC +#undef NXPROFILEFUNC +#undef NXPROFILEFUNCCOL +#undef NXPROFILEFUNCCOL2 +#endif +#define NXPROFILEFUNC(name) NXProfileFunc nxProfileMe(name, 0xFF0000FF) +#define NXPROFILEFUNCCOL(name, c) NXProfileFunc nxProfileMe(name, c) +#define NXPROFILEFUNCCOL2(name, c, p) NXProfileFunc nxProfileMe(name, c, p) +#else +#define NX_RANGE int +#define NX_MARK(name) +#define NX_RANGESTART(name) 0 +#define NX_RANGEEND(id) +#define NX_RANGEPUSH(name) +#define NX_RANGEPUSHCOL(name, c) +#define NX_RANGEPOP() +#define NXPROFILEFUNC(name) +#define NXPROFILEFUNCCOL(name, c) +#define NXPROFILEFUNCCOL2(name, c, a) +#endif + +#endif //__NSIGHTEVENTS__ + diff --git a/nvpro_core_legacy/nvtx3/nvToolsExt.h b/nvpro_core_legacy/nvtx3/nvToolsExt.h new file mode 100644 index 0000000..d4591df --- /dev/null +++ b/nvpro_core_legacy/nvtx3/nvToolsExt.h @@ -0,0 +1,1668 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2009-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * Licensed under the Apache License v2.0 with LLVM Exceptions. + * See https://nvidia.github.io/NVTX/LICENSE.txt for license information. + */ + +/** \file nvToolsExt.h + */ + +/* ========================================================================= */ +/** \mainpage + * \tableofcontents + * \section INTRODUCTION Introduction + * + * The NVIDIA Tools Extension library is a set of functions that a + * developer can use to provide additional information to tools. + * The additional information is used by the tool to improve + * analysis and visualization of data. + * + * The library introduces close to zero overhead if no tool is + * attached to the application. The overhead when a tool is + * attached is specific to the tool. + * + * \section INITIALIZATION Initialization + * + * Typically the tool's library that plugs into NVTX is indirectly + * loaded via environmental properties that are platform specific. + * For some platform or special cases, the user may be required + * to instead explicitly initialize instead though. This can also + * be helpful to control when the API loads a tool's library instead + * of what would typically be the first function call to emit info. + * For these rare case, see \ref INITIALIZATION for additional information. + * + * \section MARKERS_AND_RANGES Markers and Ranges + * + * Markers and ranges are used to describe events at a specific time (markers) + * or over a time span (ranges) during the execution of the application + * respectively. + * + * \subsection MARKERS Markers + * + * Markers denote specific moments in time. + * + * + * See \ref DOMAINS and \ref EVENT_ATTRIBUTES for additional information on + * how to specify the domain. + * + * \subsection THREAD_RANGES Thread Ranges + * + * Thread ranges denote nested time ranges. Nesting is maintained per thread + * per domain and does not require any additional correlation mechanism. The + * duration of a thread range is defined by the corresponding pair of + * nvtxRangePush* to nvtxRangePop API calls. + * + * See \ref DOMAINS and \ref EVENT_ATTRIBUTES for additional information on + * how to specify the domain. + * + * \subsection PROCESS_RANGES Process Ranges + * + * Process ranges denote a time span that can expose arbitrary concurrency, as + * opposed to thread ranges that only support nesting. In addition the range + * start event can happen on a different thread than the end marker. For the + * correlation of a start/end pair an unique correlation ID is used that is + * returned from the start API call and needs to be passed into the end API + * call. + * + * \subsection EVENT_ATTRIBUTES Event Attributes + * + * \ref MARKERS_AND_RANGES can be annotated with various attributes to provide + * additional information for an event or to guide the tool's visualization of + * the data. Each of the attributes is optional and if left unused the + * attributes fall back to a default value. The attributes include: + * - color + * - category + * + * To specify any attribute other than the text message, the \ref + * EVENT_ATTRIBUTE_STRUCTURE "Event Attribute Structure" must be used. + * + * \section DOMAINS Domains + * + * Domains enable developers to scope annotations. By default all events and + * annotations are in the default domain. Additional domains can be registered. + * This allows developers to scope markers, ranges, and resources names to + * avoid conflicts. + * + * The function ::nvtxDomainCreateA or ::nvtxDomainCreateW is used to create + * a named domain. + * + * Each domain maintains its own + * - categories + * - thread range stacks + * - registered strings + * + * The function ::nvtxDomainDestroy marks the end of the domain. Destroying + * a domain unregisters and destroys all objects associated with it such as + * registered strings, resource objects, named categories, and started ranges. + * + * \section RESOURCE_NAMING Resource Naming + * + * This section covers calls that allow to annotate objects with user-provided + * names in order to allow for a better analysis of complex trace data. All of + * the functions take the handle or the ID of the object to name and the name. + * The functions can be called multiple times during the execution of an + * application, however, in that case it is implementation dependent which + * name will be reported by the tool. + * + * \subsection CATEGORY_NAMING Category Naming + * + * Some function in this library support associating an integer category + * to enable filtering and sorting. The category naming functions allow + * the application to associate a user friendly name with the integer + * category. Support for domains have been added in NVTX_VERSION_2 to + * avoid collisions when domains are developed independently. + * + * \subsection RESOURCE_OBJECTS Resource Objects + * + * Resource objects are a generic mechanism for attaching data to an application + * resource. The identifier field makes the association to a pointer or handle, + * while the type field helps provide deeper understanding of the identifier as + * well as enabling differentiation in cases where handles generated by different + * APIs may collide. The resource object may also have an associated message to + * associate with the application resource, enabling further annotation of this + * object and how it is used. + * + * The resource object was introduced in NVTX_VERSION_2 to supersede existing naming + * functions and allow the application resource identified by those functions to be + * associated to a domain. The other naming functions are still supported for backward + * compatibility but will be associated only to the default domain. + * + * \subsection RESOURCE_NAMING_OS Resource Naming + * + * Some operating system resources creation APIs do not support providing a user friendly + * name, such as some OS thread creation APIs. This API support resource naming though + * both through resource objects and functions following the pattern + * nvtxName[RESOURCE_TYPE][A|W](identifier, name). Resource objects introduced in NVTX_VERSION 2 + * supersede the other functions with a a more general method of assigning names to OS resources, + * along with associating them to domains too. The older nvtxName* functions are only associated + * with the default domain. + * \section EXTENSIONS Optional Extensions + * Optional extensions will either appear within the existing sections the extend or appear + * in the "Related Pages" when they introduce new concepts. + */ + + /** + * Tools Extension API version + */ +#if defined(NVTX_VERSION) && NVTX_VERSION < 3 +#error "Trying to #include NVTX version 3 in a source file where an older NVTX version has already been included. If you are not directly using NVTX (the NVIDIA Tools Extension library), you are getting this error because libraries you are using have included different versions of NVTX. Suggested solutions are: (1) reorder #includes so the newest NVTX version is included first, (2) avoid using the conflicting libraries in the same .c/.cpp file, or (3) update the library using the older NVTX version to use the newer version instead." +#endif + +#if defined(NVTX_AS_SYSTEM_HEADER) +#if defined(__clang__) +#pragma clang system_header +#elif defined(__GNUC__) || defined(__NVCOMPILER) +#pragma GCC system_header +#elif defined(_MSC_VER) +#pragma system_header +#endif +#endif + +/* Header guard */ +#if !defined(NVTX_VERSION) +#define NVTX_VERSION 3 + +/* Platform-dependent defines: + * + * - NVTX_API - Calling conventions (only used on Windows, and only effects + * 32-bit x86 builds, i.e. callee pops stack instead of caller) + * + * - NVTX_DYNAMIC_EXPORT - Make function an exported entry point from a + * dynamic library or shared object. + * + * - NVTX_EXPORT_UNMANGLED_FUNCTION_NAME - When used inside the body of a + * function declared with NVTX_DYNAMIC_EXPORT, ensures the symbol exported + * for the function is the exact string of the function's name as written + * in the code. Name-mangling or name-decoration is disabled. Note that + * on many platforms this is not necessary, since either the function name + * is already exported verbatim, or the dynamic loader also checks for + * functions with the mangling applied. Forcing the exports to avoid any + * mangling simplifies usage across platforms and from other languages. + */ +#if defined(_WIN32) + +#define NVTX_API __stdcall + +#if defined(_MSC_VER) +#define NVTX_DYNAMIC_EXPORT __declspec(dllexport) +#else +#define NVTX_DYNAMIC_EXPORT __attribute__((visibility("default"))) __declspec(dllexport) +#endif + +#if defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_ARM64EC)) +#define NVTX_EXPORT_UNMANGLED_FUNCTION_NAME __pragma(comment(linker, "/EXPORT:" __FUNCTION__ "=" __FUNCDNAME__)) +#else +#define NVTX_EXPORT_UNMANGLED_FUNCTION_NAME +#endif + +#else /* POSIX-like platform */ + +#define NVTX_API + +#define NVTX_DYNAMIC_EXPORT __attribute__((visibility("default"))) + +#define NVTX_EXPORT_UNMANGLED_FUNCTION_NAME + +#endif /* Platform-dependent defines */ + +/* Compiler-dependent defines: + * + * - NVTX_INLINE_STATIC - Ensure function has internal linkage, and suggest + * avoiding code-gen of the function. Without this, function has external + * linkage with a strong symbol, so linker expects only one definition. + */ +#if defined(_MSC_VER) + +#define NVTX_INLINE_STATIC __inline static + +#else /* GCC-like compiler */ + +#if defined(__cplusplus) || (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) +#define NVTX_INLINE_STATIC inline static +#else +#define NVTX_INLINE_STATIC __inline__ static +#endif + +#endif /* Compiler-dependent defines */ + +#if !defined(NVTX_NULLPTR) +#if defined(__cplusplus) && __cplusplus >= 201103L +#define NVTX_NULLPTR nullptr +#else +#define NVTX_NULLPTR NULL +#endif +#endif + +#if defined(__cplusplus) +#define NVTX_STATIC_CAST(type, value) (static_cast(value)) +#define NVTX_REINTERPRET_CAST(type, value) (reinterpret_cast(value)) +#else +#define NVTX_STATIC_CAST(type, value) ((type)(value)) +#define NVTX_REINTERPRET_CAST(type, value) ((type)(value)) +#endif + + +/* API linkage/export options: + * + * - By default, the NVTX API functions are declared as "inline", with the + * implementations provided in the headers. This allows multiple .c/.cpp + * files in the same project to include NVTX headers without duplicate- + * definition linker errors. An optimizing compiler should inline these + * implementations, ensuring that the overhead of making an NVTX call is as + * low as possible, even without enabling link-time optimizations. + * + * - NVTX_NO_IMPL - Use when writing NVTX tools. If this macro is defined, + * the NVTX headers will provide all the typedefs, macros, and declarations + * of API functions (not marked inline), but no function implementations. + * + * - NVTX_EXPORT_API - NVTX is normally used in C/C++ applications by simply + * including the headers. There is no need to link with a static library, + * or to ship a dynamic library with the application (this was changed in + * NVTX v3). For other languages, it's not convenient to use a header-only + * C library. The best way to provide an idiomatic NVTX API for another + * language is a .c file that includes the NVTX headers and implements + * functions for that language using its native calling conventions and + * datatypes -- this method can allow static linking to avoid depending on + * a separate dynamic library. Alternatively, other languages may support + * using C calling conventions to directly call C functions exported from a + * dynamic library. To build such a library, write a .c file that defines + * NVTX_EXPORT_API and includes any/all of the NVTX headers. Compile this + * file as a dynamic library, and the NVTX API functions from the included + * headers will be exported with no name-mangling or decoration. Defining + * ABI-compatible NVTX struct and enum types in the other language is the + * responsibility of the user of this dynamic library. + * + * Whichever of the above modes is chosen, the following macros are defined + * appropriately below to implement that mode. These macros are only defined + * if not already defined by the user, so they may be overridden by users to + * handle advanced cases. + * + * - NVTX_DECLSPEC - Specify linkage for NVTX API functions. + * + * - NVTX_SET_NAME_MANGLING_OPTIONS - If necessary for the platform, will use + * platform-dependent syntax for ensuring function name is exported with no + * name-mangling or decoration. Certain compiler and calling-convention + * combinations will add name-mangling or decorations when exporting NVTX + * function name symbols, which makes it much harder for other languages + * to access these functions. This macro must be used inside a function's + * body because it uses built-in macros to get the current function's name. + */ +#if defined(NVTX_NO_IMPL) + +/* When omitting implementation, avoid declaring functions inline + * without definitions, since this causes compiler warnings. */ +#if !defined(NVTX_DECLSPEC) +#define NVTX_DECLSPEC +#endif +#if !defined(NVTX_SET_NAME_MANGLING_OPTIONS) +#define NVTX_SET_NAME_MANGLING_OPTIONS +#endif + +#elif defined(NVTX_EXPORT_API) + +/* Add platform-dependent declaration syntax to ensure NVTX API functions are + * exported when compiling as a dynamic library/shared object, and ensure the + * exported names are not mangled/decorated. */ +#if !defined(NVTX_DECLSPEC) +#define NVTX_DECLSPEC NVTX_DYNAMIC_EXPORT +#endif +#if !defined(NVTX_SET_NAME_MANGLING_OPTIONS) +#define NVTX_SET_NAME_MANGLING_OPTIONS NVTX_EXPORT_UNMANGLED_FUNCTION_NAME +#endif + +#else /* Normal NVTX usage */ + +/* Functions definitions are provided, and functions are declared inline to + * avoid duplicate-definition linker errors when using multiple source files. */ +#if !defined(NVTX_DECLSPEC) +#define NVTX_DECLSPEC NVTX_INLINE_STATIC +#endif +#if !defined(NVTX_SET_NAME_MANGLING_OPTIONS) +#define NVTX_SET_NAME_MANGLING_OPTIONS +#endif + +#endif + +/* Platform-dependent helpers for defining global variables in header files. + * Ensures the linker uses only one instance when multiple source files include + * the headers, avoiding duplicate-definition linker errors. */ +#include "nvtxDetail/nvtxLinkOnce.h" + +/* Macros for applying major-version-specific suffix to NVTX global symbols, so + * usage of different versions in different source files is supported without + * violating the one-definition rule. */ +#define NVTX_VERSIONED_IDENTIFIER_L3(NAME, VERSION) NAME##_v##VERSION +#define NVTX_VERSIONED_IDENTIFIER_L2(NAME, VERSION) NVTX_VERSIONED_IDENTIFIER_L3(NAME, VERSION) +#define NVTX_VERSIONED_IDENTIFIER(NAME) NVTX_VERSIONED_IDENTIFIER_L2(NAME, NVTX_VERSION) + +/** + * The NVTX library depends on stdint.h. If the build tool chain in use + * does not include stdint.h, then define NVTX_STDINT_TYPES_ALREADY_DEFINED + * and define the following types: + *
    + *
  • uint8_t + *
  • int8_t + *
  • uint16_t + *
  • int16_t + *
  • uint32_t + *
  • int32_t + *
  • uint64_t + *
  • int64_t + *
  • uintptr_t + *
  • intptr_t + *
+ * Be sure to define NVTX_STDINT_TYPES_ALREADY_DEFINED if you are using your + * own definitions instead of stdint.h. + */ +#ifndef NVTX_STDINT_TYPES_ALREADY_DEFINED +#include +#endif + +#include + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +/** +* Result Codes used for the NVTX tool loader. +*/ +#define NVTX_SUCCESS 0 +#define NVTX_FAIL 1 +#define NVTX_ERR_INIT_LOAD_PROPERTY 2 +#define NVTX_ERR_INIT_ACCESS_LIBRARY 3 +#define NVTX_ERR_INIT_LOAD_LIBRARY 4 +#define NVTX_ERR_INIT_MISSING_LIBRARY_ENTRY_POINT 5 +#define NVTX_ERR_INIT_FAILED_LIBRARY_ENTRY_POINT 6 +#define NVTX_ERR_NO_INJECTION_LIBRARY_AVAILABLE 7 + +/** + * Size of the nvtxEventAttributes_t structure. + */ +#define NVTX_EVENT_ATTRIB_STRUCT_SIZE (NVTX_STATIC_CAST(uint16_t, sizeof(nvtxEventAttributes_t))) + +#define NVTX_NO_PUSH_POP_TRACKING (NVTX_STATIC_CAST(int, -2)) + +typedef uint64_t nvtxRangeId_t; + +/* Forward declaration of opaque domain registration structure */ +struct nvtxDomainRegistration_st; +typedef struct nvtxDomainRegistration_st nvtxDomainRegistration; + +/* \brief Domain Handle Structure. +* \anchor DOMAIN_HANDLE_STRUCTURE +* +* This structure is opaque to the user and is used as a handle to reference +* a domain. This type is returned from tools when using the NVTX API to +* create a domain. +* +*/ +typedef nvtxDomainRegistration* nvtxDomainHandle_t; + +/* Forward declaration of opaque string registration structure */ +struct nvtxStringRegistration_st; +typedef struct nvtxStringRegistration_st nvtxStringRegistration; + +/* \brief Registered String Handle Structure. +* \anchor REGISTERED_STRING_HANDLE_STRUCTURE +* +* This structure is opaque to the user and is used as a handle to reference +* a registered string. This type is returned from tools when using the NVTX +* API to create a registered string. +* +*/ +typedef nvtxStringRegistration* nvtxStringHandle_t; + +/* ========================================================================= */ +/** \defgroup GENERAL General + * @{ + */ + +/** --------------------------------------------------------------------------- + * Color Types + * ------------------------------------------------------------------------- */ +typedef enum nvtxColorType_t +{ + NVTX_COLOR_UNKNOWN = 0, /**< Color attribute is unused. */ + NVTX_COLOR_ARGB = 1 /**< An ARGB color is provided. */ +} nvtxColorType_t; + +/** --------------------------------------------------------------------------- + * Message Types + * ------------------------------------------------------------------------- */ +typedef enum nvtxMessageType_t +{ + NVTX_MESSAGE_UNKNOWN = 0, /**< Message attribute is unused. */ + NVTX_MESSAGE_TYPE_ASCII = 1, /**< A character sequence is used as payload. */ + NVTX_MESSAGE_TYPE_UNICODE = 2, /**< A wide character sequence is used as payload. */ + /* NVTX_VERSION_2 */ + NVTX_MESSAGE_TYPE_REGISTERED = 3 /**< A unique string handle that was registered + with \ref nvtxDomainRegisterStringA() or + \ref nvtxDomainRegisterStringW(). */ +} nvtxMessageType_t; + +typedef union nvtxMessageValue_t +{ + const char* ascii; + const wchar_t* unicode; + /* NVTX_VERSION_2 */ + nvtxStringHandle_t registered; +} nvtxMessageValue_t; + + +/* ------------------------------------------------------------------------- */ +/** \brief Force initialization (optional) + * \anchor FORCE_INITIALIZATION +* +* Force NVTX library to initialize. The first call to any NVTX API function +* will automatically initialize the entire API. This can make the first call +* much slower than subsequent calls. In applications where the first call to +* NVTX may be in a performance-critical section, calling nvtxInitialize before +* any performance-critical sections will ensure NVTX initialization occurs at +* an acceptable time. Since nvtxInitialize takes no parameters and has no +* expected behavior besides initialization, it is convenient to add a call to +* nvtxInitialize in NVTX-instrumented applications that need to force earlier +* initialization without changing any other code. For example, if an app's +* first NVTX call is nvtxDomainCreate, and it is difficult to move that call +* earlier because the domain handle must be stored in an object only created +* at that point, adding a call to nvtxInitialize at the top of main() will +* ensure the later call to nvtxDomainCreate is as fast as possible. +* +* \version NVTX_VERSION_3 +* +* \param reserved - must be zero or NULL. +* +* @{ */ +NVTX_DECLSPEC void NVTX_API nvtxInitialize(const void* reserved); +/** @} */ + + +/** @} */ /*END defgroup*/ + +/* ========================================================================= */ +/** \defgroup EVENT_ATTRIBUTES Event Attributes +* @{ +*/ + +/** --------------------------------------------------------------------------- +* Payload Types +* ------------------------------------------------------------------------- */ +typedef enum nvtxPayloadType_t +{ + NVTX_PAYLOAD_UNKNOWN = 0, /**< Payload attribute is unused. */ + NVTX_PAYLOAD_TYPE_UNSIGNED_INT64 = 1, /**< A 64 bit unsigned integer value is used as payload. */ + NVTX_PAYLOAD_TYPE_INT64 = 2, /**< A 64 bit signed integer value is used as payload. */ + NVTX_PAYLOAD_TYPE_DOUBLE = 3, /**< A 64 bit floating point value is used as payload. */ + /* NVTX_VERSION_2 */ + NVTX_PAYLOAD_TYPE_UNSIGNED_INT32 = 4, /**< A 32 bit floating point value is used as payload. */ + NVTX_PAYLOAD_TYPE_INT32 = 5, /**< A 32 bit floating point value is used as payload. */ + NVTX_PAYLOAD_TYPE_FLOAT = 6 /**< A 32 bit floating point value is used as payload. */ +} nvtxPayloadType_t; + +/** \brief Event Attribute Structure. + * \anchor EVENT_ATTRIBUTE_STRUCTURE + * + * This structure is used to describe the attributes of an event. The layout of + * the structure is defined by a specific version of the tools extension + * library and can change between different versions of the Tools Extension + * library. + * + * \par Guidelines + * The caller should always perform the following three tasks when using + * attributes: + *
    + *
  • Zero the structure + *
  • Set the version field + *
  • Set the size field + *
+ * + * Zeroing the structure sets all the event attributes types and values + * to the default value. + * + * The version and size field are used by the Tools Extension + * implementation to handle multiple versions of the attributes structure. + * + * It is recommended that the caller use one of the following to methods + * to initialize the event attributes structure: + * + * \par Method 1 + * Initializing nvtxEventAttributes for future compatibility: + * \code + * nvtxEventAttributes_t eventAttrib = {0}; + * eventAttrib.version = NVTX_VERSION; + * eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE; + * \endcode + * + * \par Method 2 + * Initializing nvtxEventAttributes for a specific version: + * \code + * nvtxEventAttributes_t eventAttrib = {0}; + * eventAttrib.version = 1; + * eventAttrib.size = (uint16_t)(sizeof(nvtxEventAttributes_v1)); + * \endcode + * + * If the caller uses Method 1 it is critical that the entire binary + * layout of the structure be configured to 0 so that all fields + * are initialized to the default value. + * + * The caller should either use both NVTX_VERSION and + * NVTX_EVENT_ATTRIB_STRUCT_SIZE (Method 1) or use explicit values + * and a versioned type (Method 2). Using a mix of the two methods + * will likely cause either source level incompatibility or binary + * incompatibility in the future. + * + * \par Example + * Populate an attributes structure: + * \code + * // Initialize + * nvtxEventAttributes_t eventAttrib = {0}; + * eventAttrib.version = NVTX_VERSION; + * eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE; + * + * // Configure the Attributes + * eventAttrib.colorType = NVTX_COLOR_ARGB; + * eventAttrib.color = 0xFF880000; + * eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII; + * eventAttrib.message.ascii = "Example"; + * \endcode + * + * In the example the caller does not have to set the value of + * \ref ::nvtxEventAttributes_v2::category or + * \ref ::nvtxEventAttributes_v2::payload as these fields were set to + * the default value by {0}. + * \sa + * ::nvtxDomainMarkEx + * ::nvtxDomainRangeStartEx + * ::nvtxDomainRangePushEx + */ +typedef struct nvtxEventAttributes_v2 +{ + /** + * \brief Version flag of the structure. + * + * Needs to be set to NVTX_VERSION to indicate the version of NVTX APIs + * supported in this header file. This can optionally be overridden to + * another version of the tools extension library. + */ + uint16_t version; + + /** + * \brief Size of the structure. + * + * Needs to be set to the size in bytes of the event attribute + * structure used to specify the event. + */ + uint16_t size; + + /** + * \brief ID of the category the event is assigned to. + * + * A category is a user-controlled ID that can be used to group + * events. The tool may use category IDs to improve filtering or + * enable grouping of events in the same category. The functions + * \ref ::nvtxNameCategoryA or \ref ::nvtxNameCategoryW can be used + * to name a category. + * + * Default Value is 0 + */ + uint32_t category; + + /** \brief Color type specified in this attribute structure. + * + * Defines the color format of the attribute structure's \ref COLOR_FIELD + * "color" field. + * + * Default Value is NVTX_COLOR_UNKNOWN + */ + int32_t colorType; /* nvtxColorType_t */ + + /** \brief Color assigned to this event. \anchor COLOR_FIELD + * + * The color that the tool should use to visualize the event. + */ + uint32_t color; + + /** + * \brief Payload type specified in this attribute structure. + * + * Defines the payload format of the attribute structure's \ref PAYLOAD_FIELD + * "payload" field. + * + * Default Value is NVTX_PAYLOAD_UNKNOWN + */ + int32_t payloadType; /* nvtxPayloadType_t */ + + int32_t reserved0; + + /** + * \brief Payload assigned to this event. \anchor PAYLOAD_FIELD + * + * A numerical value that can be used to annotate an event. The tool could + * use the payload data to reconstruct graphs and diagrams. + */ + union payload_t + { + uint64_t ullValue; + int64_t llValue; + double dValue; + /* NVTX_VERSION_2 */ + uint32_t uiValue; + int32_t iValue; + float fValue; + } payload; + + /** \brief Message type specified in this attribute structure. + * + * Defines the message format of the attribute structure's \ref MESSAGE_FIELD + * "message" field. + * + * Default Value is NVTX_MESSAGE_UNKNOWN + */ + int32_t messageType; /* nvtxMessageType_t */ + + /** \brief Message assigned to this attribute structure. \anchor MESSAGE_FIELD + * + * The text message that is attached to an event. + */ + nvtxMessageValue_t message; + +} nvtxEventAttributes_v2; + +typedef struct nvtxEventAttributes_v2 nvtxEventAttributes_t; + +/** @} */ /*END defgroup*/ +/* ========================================================================= */ +/** \defgroup MARKERS_AND_RANGES Markers and Ranges + * + * See \ref MARKERS_AND_RANGES for more details + * + * @{ + */ + +/** \name Marker */ + +/* ------------------------------------------------------------------------- */ +/** \brief Marks an instantaneous event in the application. +* +* A marker can contain a text message or specify additional information +* using the event attributes structure. These attributes include a text +* message, color, category, and a payload. Each of the attributes is optional +* and can only be sent out using the \ref nvtxDomainMarkEx function. +* +* nvtxDomainMarkEx(NULL, event) is equivalent to calling +* nvtxMarkEx(event). +* +* \param domain - The domain of scoping the category. +* \param eventAttrib - The event attribute structure defining the marker's +* attribute types and attribute values. +* +* \sa +* ::nvtxMarkEx +* +* \version NVTX_VERSION_2 +* @{ */ +NVTX_DECLSPEC void NVTX_API nvtxDomainMarkEx(nvtxDomainHandle_t domain, const nvtxEventAttributes_t* eventAttrib); +/** @} */ + +/* ------------------------------------------------------------------------- */ +/** \brief Marks an instantaneous event in the application. + * + * A marker can contain a text message or specify additional information + * using the event attributes structure. These attributes include a text + * message, color, category, and a payload. Each of the attributes is optional + * and can only be sent out using the \ref nvtxMarkEx function. + * If \ref nvtxMarkA or \ref nvtxMarkW are used to specify the marker + * or if an attribute is unspecified then a default value will be used. + * + * \param eventAttrib - The event attribute structure defining the marker's + * attribute types and attribute values. + * + * \par Example + * Place a mark with attributes: + * \code + * // zero the structure + * nvtxEventAttributes_t eventAttrib = {0}; + * // set the version and the size information + * eventAttrib.version = NVTX_VERSION; + * eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE; + * // configure the attributes. 0 is the default for all attributes. + * eventAttrib.colorType = NVTX_COLOR_ARGB; + * eventAttrib.color = 0xFF880000; + * eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII; + * eventAttrib.message.ascii = "Example nvtxMarkEx"; + * nvtxMarkEx(&eventAttrib); + * \endcode + * + * \sa + * ::nvtxDomainMarkEx + * + * \version NVTX_VERSION_1 + * @{ */ +NVTX_DECLSPEC void NVTX_API nvtxMarkEx(const nvtxEventAttributes_t* eventAttrib); +/** @} */ + +/* ------------------------------------------------------------------------- */ +/** \brief Marks an instantaneous event in the application. + * + * A marker created using \ref nvtxMarkA or \ref nvtxMarkW contains only a + * text message. + * + * \param message - The message associated to this marker event. + * + * \par Example + * Place a mark: + * \code + * nvtxMarkA("Example nvtxMarkA"); + * nvtxMarkW(L"Example nvtxMarkW"); + * \endcode + * + * \sa + * ::nvtxDomainMarkEx + * ::nvtxMarkEx + * + * \version NVTX_VERSION_0 + * @{ */ +NVTX_DECLSPEC void NVTX_API nvtxMarkA(const char* message); +NVTX_DECLSPEC void NVTX_API nvtxMarkW(const wchar_t* message); +/** @} */ + + +/** \name Process Ranges */ + +/* ------------------------------------------------------------------------- */ +/** \brief Starts a process range in a domain. +* +* \param domain - The domain of scoping the category. +* \param eventAttrib - The event attribute structure defining the range's +* attribute types and attribute values. +* +* \return The unique ID used to correlate a pair of Start and End events. +* +* \remarks Ranges defined by Start/End can overlap. +* +* \par Example +* Start a range with attributes for a domain: +* \code +* nvtxDomainHandle_t domain = nvtxDomainCreateA("my domain"); +* nvtxEventAttributes_t eventAttrib = {0}; +* eventAttrib.version = NVTX_VERSION; +* eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE; +* eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII; +* eventAttrib.message.ascii = "my range"; +* nvtxRangeId_t rangeId = nvtxDomainRangeStartEx(domain, &eventAttrib); +* // ... +* nvtxDomainRangeEnd(domain, rangeId); +* \endcode +* +* \sa +* ::nvtxDomainRangeEnd +* +* \version NVTX_VERSION_2 +* @{ */ +NVTX_DECLSPEC nvtxRangeId_t NVTX_API nvtxDomainRangeStartEx(nvtxDomainHandle_t domain, const nvtxEventAttributes_t* eventAttrib); +/** @} */ + +/* ------------------------------------------------------------------------- */ +/** \brief Starts a process range. + * + * \param eventAttrib - The event attribute structure defining the range's + * attribute types and attribute values. + * + * \return The unique ID used to correlate a pair of Start and End events. + * + * \remarks Ranges defined by Start/End can overlap. + * + * \par Example + * Start a range with attributes: + * \code + * nvtxEventAttributes_t eventAttrib = {0}; + * eventAttrib.version = NVTX_VERSION; + * eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE; + * eventAttrib.category = 3; + * eventAttrib.colorType = NVTX_COLOR_ARGB; + * eventAttrib.color = 0xFF0088FF; + * eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII; + * eventAttrib.message.ascii = "Example Range"; + * nvtxRangeId_t rangeId = nvtxRangeStartEx(&eventAttrib); + * // ... + * nvtxRangeEnd(rangeId); + * \endcode + * + * \sa + * ::nvtxRangeEnd + * ::nvtxDomainRangeStartEx + * + * \version NVTX_VERSION_1 + * @{ */ +NVTX_DECLSPEC nvtxRangeId_t NVTX_API nvtxRangeStartEx(const nvtxEventAttributes_t* eventAttrib); +/** @} */ + +/* ------------------------------------------------------------------------- */ +/** \brief Starts a process range. + * + * \param message - The event message associated to this range event. + * + * \return The unique ID used to correlate a pair of Start and End events. + * + * \remarks Ranges defined by Start/End can overlap. + * + * \par Example + * Start a range: + * \code + * nvtxRangeId_t r1 = nvtxRangeStartA("Range 1"); + * nvtxRangeId_t r2 = nvtxRangeStartW(L"Range 2"); + * nvtxRangeEnd(r1); + * nvtxRangeEnd(r2); + * \endcode + * + * \sa + * ::nvtxRangeEnd + * ::nvtxRangeStartEx + * ::nvtxDomainRangeStartEx + * + * \version NVTX_VERSION_0 + * @{ */ +NVTX_DECLSPEC nvtxRangeId_t NVTX_API nvtxRangeStartA(const char* message); +NVTX_DECLSPEC nvtxRangeId_t NVTX_API nvtxRangeStartW(const wchar_t* message); +/** @} */ + +/* ------------------------------------------------------------------------- */ +/** \brief Ends a process range. +* +* \param domain - The domain +* \param id - The correlation ID returned from a nvtxRangeStart call. +* +* \remarks This function is offered completeness but is an alias for ::nvtxRangeEnd. +* It does not need a domain param since that is associated with the range ID at ::nvtxDomainRangeStartEx +* +* \par Example +* End a range for a domain: +* \code +* nvtxDomainHandle_t domain = nvtxDomainCreateA("my domain"); +* nvtxEventAttributes_t eventAttrib = {0}; +* eventAttrib.version = NVTX_VERSION; +* eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE; +* eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII; +* eventAttrib.message.ascii = "my range"; +* nvtxRangeId_t rangeId = nvtxDomainRangeStartEx(domain, &eventAttrib); +* // ... +* nvtxDomainRangeEnd(domain, rangeId); +* \endcode +* +* \sa +* ::nvtxDomainRangeStartEx +* +* \version NVTX_VERSION_2 +* @{ */ +NVTX_DECLSPEC void NVTX_API nvtxDomainRangeEnd(nvtxDomainHandle_t domain, nvtxRangeId_t id); +/** @} */ + +/* ------------------------------------------------------------------------- */ +/** \brief Ends a process range. + * + * \param id - The correlation ID returned from an nvtxRangeStart call. + * + * \sa + * ::nvtxDomainRangeStartEx + * ::nvtxRangeStartEx + * ::nvtxRangeStartA + * ::nvtxRangeStartW + * + * \version NVTX_VERSION_0 + * @{ */ +NVTX_DECLSPEC void NVTX_API nvtxRangeEnd(nvtxRangeId_t id); +/** @} */ + +/** \name Thread Ranges */ + +/* ------------------------------------------------------------------------- */ +/** \brief Starts a nested thread range. +* +* \param domain - The domain of scoping. +* \param eventAttrib - The event attribute structure defining the range's +* attribute types and attribute values. +* +* \return The 0 based level of range being started. This value is scoped to the domain. +* If an error occurs, a negative value is returned. +* +* \par Example +* Push a range with attributes for a domain: +* \code +* nvtxDomainHandle_t domain = nvtxDomainCreateA("example domain"); +* nvtxEventAttributes_t eventAttrib = {0}; +* eventAttrib.version = NVTX_VERSION; +* eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE; +* eventAttrib.colorType = NVTX_COLOR_ARGB; +* eventAttrib.color = 0xFFFF0000; +* eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII; +* eventAttrib.message.ascii = "Level 0"; +* nvtxDomainRangePushEx(domain, &eventAttrib); +* +* // Re-use eventAttrib +* eventAttrib.messageType = NVTX_MESSAGE_TYPE_UNICODE; +* eventAttrib.message.unicode = L"Level 1"; +* nvtxDomainRangePushEx(domain, &eventAttrib); +* +* nvtxDomainRangePop(domain); // Level 1 +* nvtxDomainRangePop(domain); // Level 0 +* \endcode +* +* \sa +* ::nvtxDomainRangePop +* +* \version NVTX_VERSION_2 +* @{ */ +NVTX_DECLSPEC int NVTX_API nvtxDomainRangePushEx(nvtxDomainHandle_t domain, const nvtxEventAttributes_t* eventAttrib); +/** @} */ + +/* ------------------------------------------------------------------------- */ +/** \brief Starts a nested thread range. + * + * \param eventAttrib - The event attribute structure defining the range's + * attribute types and attribute values. + * + * \return The 0 based level of range being started. This level is per domain. + * If an error occurs a negative value is returned. + * + * \par Example + * Push a range with attributes: + * \code + * nvtxEventAttributes_t eventAttrib = {0}; + * eventAttrib.version = NVTX_VERSION; + * eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE; + * eventAttrib.colorType = NVTX_COLOR_ARGB; + * eventAttrib.color = 0xFFFF0000; + * eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII; + * eventAttrib.message.ascii = "Level 0"; + * nvtxRangePushEx(&eventAttrib); + * + * // Re-use eventAttrib + * eventAttrib.messageType = NVTX_MESSAGE_TYPE_UNICODE; + * eventAttrib.message.unicode = L"Level 1"; + * nvtxRangePushEx(&eventAttrib); + * + * nvtxRangePop(); // Level 1 + * nvtxRangePop(); // Level 0 + * \endcode + * + * \sa + * ::nvtxDomainRangePushEx + * ::nvtxRangePop + * + * \version NVTX_VERSION_1 + * @{ */ +NVTX_DECLSPEC int NVTX_API nvtxRangePushEx(const nvtxEventAttributes_t* eventAttrib); +/** @} */ + +/* ------------------------------------------------------------------------- */ +/** \brief Starts a nested thread range. + * + * \param message - The event message associated to this range event. + * + * \return The 0 based level of range being started. If an error occurs a + * negative value is returned. + * + * \par Example + * Push a range: + * \code + * nvtxRangePushA("Level 0"); + * nvtxRangePushW(L"Level 1"); + * nvtxRangePop(); // Level 1 + * nvtxRangePop(); // Level 0 + * \endcode + * + * \sa + * ::nvtxDomainRangePushEx + * ::nvtxRangePop + * + * \version NVTX_VERSION_0 + * @{ */ +NVTX_DECLSPEC int NVTX_API nvtxRangePushA(const char* message); +NVTX_DECLSPEC int NVTX_API nvtxRangePushW(const wchar_t* message); +/** @} */ + + +/* ------------------------------------------------------------------------- */ +/** \brief Ends a nested thread range. +* +* \return The level of the range being ended. If an error occurs a negative +* value is returned on the current thread. +* +* \par Example +* Pop a range for a domain: +* \code +* nvtxDomainHandle_t domain = nvtxDomainCreateA("example domain"); +* nvtxEventAttributes_t eventAttrib = {0}; +* eventAttrib.version = NVTX_VERSION; +* eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE; +* eventAttrib.colorType = NVTX_COLOR_ARGB; +* eventAttrib.color = 0xFFFF0000; +* eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII; +* eventAttrib.message.ascii = "Level 0"; +* nvtxDomainRangePushEx(domain, &eventAttrib); +* +* // Re-use eventAttrib +* eventAttrib.messageType = NVTX_MESSAGE_TYPE_UNICODE; +* eventAttrib.message.unicode = L"Level 1"; +* nvtxDomainRangePushEx(domain, &eventAttrib); +* +* nvtxDomainRangePop(domain); // Level 1 +* nvtxDomainRangePop(domain); // Level 0 +* \endcode +* +* \sa +* ::nvtxRangePushEx +* ::nvtxRangePushA +* ::nvtxRangePushW +* +* \version NVTX_VERSION_2 +* @{ */ +NVTX_DECLSPEC int NVTX_API nvtxDomainRangePop(nvtxDomainHandle_t domain); +/** @} */ + +/* ------------------------------------------------------------------------- */ +/** \brief Ends a nested thread range. + * + * \return The level of the range being ended. If an error occurs a negative + * value is returned on the current thread. + * + * \par Example + * Pop a range: + * \code + * nvtxRangePushA("Level 0"); + * nvtxRangePushW(L"Level 1"); + * nvtxRangePop(); // Level 1 + * nvtxRangePop(); // Level 0 + * \endcode + * + * \sa + * ::nvtxRangePushEx + * ::nvtxRangePushA + * ::nvtxRangePushW + * + * \version NVTX_VERSION_0 + * @{ */ +NVTX_DECLSPEC int NVTX_API nvtxRangePop(void); +/** @} */ + + +/** @} */ /*END defgroup*/ +/* ========================================================================= */ +/** \defgroup RESOURCE_NAMING Resource Naming + * + * See \ref RESOURCE_NAMING for more details + * + * @{ + */ + + +/* ------------------------------------------------------------------------- */ +/** \name Functions for Generic Resource Naming*/ +/* ------------------------------------------------------------------------- */ + +/* ------------------------------------------------------------------------- */ +/** \cond SHOW_HIDDEN +* \brief Resource typing helpers. +* +* Classes are used to make it easy to create a series of resource types +* per API without collisions +*/ +#define NVTX_RESOURCE_MAKE_TYPE(CLASS, INDEX) (((NVTX_STATIC_CAST(uint32_t, NVTX_RESOURCE_CLASS_ ## CLASS))<<16)|(NVTX_STATIC_CAST(uint32_t, INDEX))) +#define NVTX_RESOURCE_CLASS_GENERIC 1 +/** \endcond */ + +/* ------------------------------------------------------------------------- */ +/** \brief Generic resource type for when a resource class is not available. +* +* \sa +* ::nvtxDomainResourceCreate +* +* \version NVTX_VERSION_2 +*/ +typedef enum nvtxResourceGenericType_t +{ + NVTX_RESOURCE_TYPE_UNKNOWN = 0, + NVTX_RESOURCE_TYPE_GENERIC_POINTER = NVTX_RESOURCE_MAKE_TYPE(GENERIC, 1), /**< Generic pointer assumed to have no collisions with other pointers. */ + NVTX_RESOURCE_TYPE_GENERIC_HANDLE = NVTX_RESOURCE_MAKE_TYPE(GENERIC, 2), /**< Generic handle assumed to have no collisions with other handles. */ + NVTX_RESOURCE_TYPE_GENERIC_THREAD_NATIVE = NVTX_RESOURCE_MAKE_TYPE(GENERIC, 3), /**< OS native thread identifier. */ + NVTX_RESOURCE_TYPE_GENERIC_THREAD_POSIX = NVTX_RESOURCE_MAKE_TYPE(GENERIC, 4) /**< POSIX pthread identifier. */ +} nvtxResourceGenericType_t; + + + +/** \brief Resource Attribute Structure. +* \anchor RESOURCE_ATTRIBUTE_STRUCTURE +* +* This structure is used to describe the attributes of a resource. The layout of +* the structure is defined by a specific version of the tools extension +* library and can change between different versions of the Tools Extension +* library. +* +* \par Guidelines +* The caller should always perform the following three tasks when using +* attributes: +*
    +*
  • Zero the structure +*
  • Set the version field +*
  • Set the size field +*
+* +* Zeroing the structure sets all the resource attributes types and values +* to the default value. +* +* The version and size field are used by the Tools Extension +* implementation to handle multiple versions of the attributes structure. +* +* It is recommended that the caller use one of the following to methods +* to initialize the event attributes structure: +* +* \par Method 1 +* Initializing nvtxEventAttributes for future compatibility: +* \code +* nvtxResourceAttributes_t attribs = {0}; +* attribs.version = NVTX_VERSION; +* attribs.size = NVTX_RESOURCE_ATTRIB_STRUCT_SIZE; +* \endcode +* +* \par Method 2 +* Initializing nvtxEventAttributes for a specific version: +* \code +* nvtxResourceAttributes_v0 attribs = {0}; +* attribs.version = 2; +* attribs.size = (uint16_t)(sizeof(nvtxResourceAttributes_v0)); +* \endcode +* +* If the caller uses Method 1 it is critical that the entire binary +* layout of the structure be configured to 0 so that all fields +* are initialized to the default value. +* +* The caller should either use both NVTX_VERSION and +* NVTX_RESOURCE_ATTRIB_STRUCT_SIZE (Method 1) or use explicit values +* and a versioned type (Method 2). Using a mix of the two methods +* will likely cause either source level incompatibility or binary +* incompatibility in the future. +* +* \par Example +* Register a resource and populate its attributes: +* \code +* nvtxDomainHandle_t domain = nvtxDomainCreateA("example domain"); +* +* // Initialize +* nvtxResourceAttributes_t attribs = {0}; +* attribs.version = NVTX_VERSION; +* attribs.size = NVTX_RESOURCE_ATTRIB_STRUCT_SIZE; +* +* // Configure the Attributes +* attribs.identifierType = NVTX_RESOURCE_TYPE_GENERIC_POINTER; +* attribs.identifier.pValue = (const void*)pMutex; +* attribs.messageType = NVTX_MESSAGE_TYPE_ASCII; +* attribs.message.ascii = "Single thread access to database."; +* +* nvtxResourceHandle_t handle = nvtxDomainResourceCreate(domain, &attribs); +* \endcode +* +* \sa +* ::nvtxDomainResourceCreate +*/ +typedef struct nvtxResourceAttributes_v0 +{ + /** + * \brief Version flag of the structure. + * + * Needs to be set to NVTX_VERSION to indicate the version of NVTX APIs + * supported in this header file. This can optionally be overridden to + * another version of the tools extension library. + */ + uint16_t version; + + /** + * \brief Size of the structure. + * + * Needs to be set to the size in bytes of this attribute + * structure. + */ + uint16_t size; + + /** + * \brief Identifier type specifies how to interpret the identifier field + * + * Defines the identifier format of the attribute structure's \ref RESOURCE_IDENTIFIER_FIELD + * "identifier" field. + * + * Default Value is NVTX_RESOURCE_TYPE_UNKNOWN + */ + int32_t identifierType; /* values from enums following the pattern nvtxResource[name]Type_t */ + + /** + * \brief Identifier for the resource. + * \anchor RESOURCE_IDENTIFIER_FIELD + * + * An identifier may be a pointer or a handle to an OS or middleware API object. + * The resource type will assist in avoiding collisions where handles values may collide. + */ + union identifier_t + { + const void* pValue; + uint64_t ullValue; + } identifier; + + /** \brief Message type specified in this attribute structure. + * + * Defines the message format of the attribute structure's \ref RESOURCE_MESSAGE_FIELD + * "message" field. + * + * Default Value is NVTX_MESSAGE_UNKNOWN + */ + int32_t messageType; /* nvtxMessageType_t */ + + /** \brief Message assigned to this attribute structure. \anchor RESOURCE_MESSAGE_FIELD + * + * The text message that is attached to a resource. + */ + nvtxMessageValue_t message; + +} nvtxResourceAttributes_v0; + +typedef struct nvtxResourceAttributes_v0 nvtxResourceAttributes_t; + +/* \cond SHOW_HIDDEN +* \version NVTX_VERSION_2 +*/ +#define NVTX_RESOURCE_ATTRIB_STRUCT_SIZE (NVTX_STATIC_CAST(uint16_t, sizeof(nvtxResourceAttributes_v0))) +typedef struct nvtxResourceHandle* nvtxResourceHandle_t; +/** \endcond */ + + + +/* ------------------------------------------------------------------------- */ +/** \brief Create a resource object to track and associate data with OS and middleware objects +* +* Allows users to associate an API handle or pointer with a user-provided name. +* +* +* \param domain - Domain to own the resource object +* \param attribs - Attributes to be associated with the resource +* +* \return A handle that represents the newly created resource object. +* +* \par Example +* Register a resource: +* \code +* nvtxDomainHandle_t domain = nvtxDomainCreateA("example domain"); +* nvtxResourceAttributes_t attribs = {0}; +* attribs.version = NVTX_VERSION; +* attribs.size = NVTX_RESOURCE_ATTRIB_STRUCT_SIZE; +* attribs.identifierType = NVTX_RESOURCE_TYPE_GENERIC_POINTER; +* attribs.identifier.pValue = (const void*)pMutex; +* attribs.messageType = NVTX_MESSAGE_TYPE_ASCII; +* attribs.message.ascii = "Single thread access to database."; +* nvtxResourceHandle_t handle = nvtxDomainResourceCreate(domain, &attribs); +* \endcode +* +* \sa +* ::nvtxResourceAttributes_t +* ::nvtxDomainResourceDestroy +* +* \version NVTX_VERSION_2 +* @{ */ +NVTX_DECLSPEC nvtxResourceHandle_t NVTX_API nvtxDomainResourceCreate(nvtxDomainHandle_t domain, nvtxResourceAttributes_t* attribs); +/** @} */ + +/* ------------------------------------------------------------------------- */ +/** \brief Destroy a resource object to track and associate data with OS and middleware objects +* +* Allows users to associate an API handle or pointer with a user-provided name. +* +* \param resource - Handle to the resource in which to operate. +* +* \par Example +* Unregister a resource: +* \code +* nvtxDomainHandle_t domain = nvtxDomainCreateA("example domain"); +* nvtxResourceAttributes_t attribs = {0}; +* attribs.version = NVTX_VERSION; +* attribs.size = NVTX_RESOURCE_ATTRIB_STRUCT_SIZE; +* attribs.identifierType = NVTX_RESOURCE_TYPE_GENERIC_POINTER; +* attribs.identifier.pValue = (const void*)pMutex; +* attribs.messageType = NVTX_MESSAGE_TYPE_ASCII; +* attribs.message.ascii = "Single thread access to database."; +* nvtxResourceHandle_t handle = nvtxDomainResourceCreate(domain, &attribs); +* // ... +* nvtxDomainResourceDestroy(handle); +* \endcode +* +* \sa +* ::nvtxDomainResourceCreate +* +* \version NVTX_VERSION_2 +* @{ */ +NVTX_DECLSPEC void NVTX_API nvtxDomainResourceDestroy(nvtxResourceHandle_t resource); +/** @} */ + + +/** \name Functions for NVTX Category Naming*/ + +/* ------------------------------------------------------------------------- */ +/** +* \brief Annotate an NVTX category used within a domain. +* +* Categories are used to group sets of events. Each category is identified +* through a unique ID and that ID is passed into any of the marker/range +* events to assign that event to a specific category. The nvtxDomainNameCategory +* function calls allow the user to assign a name to a category ID that is +* specific to the domain. +* +* nvtxDomainNameCategory(NULL, category, name) is equivalent to calling +* nvtxNameCategory(category, name). +* +* \param domain - The domain of scoping the category. +* \param category - The category ID to name. +* \param name - The name of the category. +* +* \remarks The category names are tracked per domain. +* +* \par Example +* Assign names to categories in a domain: +* \code +* nvtxDomainHandle_t domain = nvtxDomainCreateA("example"); +* nvtxDomainNameCategoryA(domain, 1, "Memory Allocation"); +* nvtxDomainNameCategoryW(domain, 2, L"Memory Transfer"); +* \endcode +* +* \version NVTX_VERSION_2 +* @{ */ +NVTX_DECLSPEC void NVTX_API nvtxDomainNameCategoryA(nvtxDomainHandle_t domain, uint32_t category, const char* name); +NVTX_DECLSPEC void NVTX_API nvtxDomainNameCategoryW(nvtxDomainHandle_t domain, uint32_t category, const wchar_t* name); +/** @} */ + +/** \brief Annotate an NVTX category. + * + * Categories are used to group sets of events. Each category is identified + * through a unique ID and that ID is passed into any of the marker/range + * events to assign that event to a specific category. The nvtxNameCategory + * function calls allow the user to assign a name to a category ID. + * + * \param category - The category ID to name. + * \param name - The name of the category. + * + * \remarks The category names are tracked per process. + * + * \par Example + * Assign names to categories: + * \code + * nvtxNameCategory(1, "Memory Allocation"); + * nvtxNameCategory(2, "Memory Transfer"); + * nvtxNameCategory(3, "Memory Object Lifetime"); + * \endcode + * + * \version NVTX_VERSION_1 + * @{ */ +NVTX_DECLSPEC void NVTX_API nvtxNameCategoryA(uint32_t category, const char* name); +NVTX_DECLSPEC void NVTX_API nvtxNameCategoryW(uint32_t category, const wchar_t* name); +/** @} */ + +/** \name Functions for OS Threads Naming*/ + +/* ------------------------------------------------------------------------- */ +/** \brief Annotate an OS thread. + * + * Allows the user to name an active thread of the current process. If an + * invalid thread ID is provided or a thread ID from a different process is + * used the behavior of the tool is implementation dependent. + * + * Tools expect thread ID to be a number that uniquely identifies the thread + * at the time of the call. Note that a thread's ID can be reused after + * it is destroyed. Tools may choose how to handle aliasing of thread IDs. + * + * POSIX pthread_t type returned by pthread_self() may not comply with these + * expectations. Please use OS-specific thread ID instead of pthread_t. + * + * The thread name is associated to the default domain. To support domains + * use resource objects via ::nvtxDomainResourceCreate. + * + * \param threadId - The ID of the thread to name. + * \param name - The name of the thread. + * + * \par Examples + * Name a thread based on the given operating system: + * + * Windows: + * \code + * #include + * nvtxNameOsThread(GetCurrentThreadId(), "Current thread"); + * nvtxNameOsThread(GetThreadId(SomeThreadHandle), "Other thread"); + * \endcode + * + * Android: + * \code + * #include + * nvtxNameOsThreadA(gettid(), "Current thread"); + * nvtxNameOsThreadA(getpid(), "Main thread"); + * \endcode + * + * Linux: + * \code + * #include + * nvtxNameOsThreadA(syscall(SYS_gettid), "Current thread"); + * \endcode + * \code + * #include + * nvtxNameOsThreadA(getpid(), "Main thread"); + * \endcode + * + * macOS: + * \code + * #include + * nvtxNameOsThreadA(syscall(SYS_thread_selfid), "Current thread"); + * \endcode + * \code + * #include + * __uint64_t id; + * pthread_threadid_np(pthread_self(), &id); + * nvtxNameOsThreadA(id, "Current thread"); + * pthread_threadid_np(somePThreadId, &id); + * nvtxNameOsThreadA(id, "Other thread"); + * \endcode + * + * \version NVTX_VERSION_1 + * @{ */ +NVTX_DECLSPEC void NVTX_API nvtxNameOsThreadA(uint32_t threadId, const char* name); +NVTX_DECLSPEC void NVTX_API nvtxNameOsThreadW(uint32_t threadId, const wchar_t* name); +/** @} */ + + +/** @} */ /*END defgroup*/ +/* ========================================================================= */ +/** \defgroup STRING_REGISTRATION String Registration +* +* Registered strings are intended to increase performance by lowering instrumentation +* overhead. String may be registered once and the handle may be passed in place of +* a string where an the APIs may allow. +* +* See \ref STRING_REGISTRATION for more details +* +* @{ +*/ + +/* ------------------------------------------------------------------------- */ +/** \brief Register a string. + +* Registers an immutable string with NVTX. Once registered the pointer used +* to register the domain name can be used in nvtxEventAttributes_t +* \ref MESSAGE_FIELD. This allows NVTX implementation to skip copying the +* contents of the message on each event invocation. +* +* String registration is an optimization. It is recommended to use string +* registration if the string will be passed to an event many times. +* +* String are not unregistered, except that by unregistering the entire domain +* +* \param domain - Domain handle. If NULL then the global domain is used. +* \param string - A unique pointer to a sequence of characters. +* +* \return A handle representing the registered string. +* +* \par Example +* Register a string: +* \code +* nvtxDomainHandle_t domain = nvtxDomainCreateA("com.nvidia.nvtx.example"); +* nvtxStringHandle_t message = nvtxDomainRegisterStringA(domain, "registered string"); +* nvtxEventAttributes_t eventAttrib = {0}; +* eventAttrib.version = NVTX_VERSION; +* eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE; +* eventAttrib.messageType = NVTX_MESSAGE_TYPE_REGISTERED; +* eventAttrib.message.registered = message; +* \endcode +* +* \version NVTX_VERSION_2 +* @{ */ +NVTX_DECLSPEC nvtxStringHandle_t NVTX_API nvtxDomainRegisterStringA(nvtxDomainHandle_t domain, const char* string); +NVTX_DECLSPEC nvtxStringHandle_t NVTX_API nvtxDomainRegisterStringW(nvtxDomainHandle_t domain, const wchar_t* string); +/** @} */ + +/** @} */ /*END defgroup*/ +/* ========================================================================= */ +/** \defgroup DOMAINS Domains +* +* Domains are used to group events to a developer defined scope. Middleware +* vendors may also scope their own events to avoid collisions with the +* the application developer's events, so that the application developer may +* inspect both parts and easily differentiate or filter them. By default +* all events are scoped to a global domain where NULL is provided or when +* using APIs provided b versions of NVTX below v2 +* +* Domains are intended to be typically long lived objects with the intention +* of logically separating events of large modules from each other such as +* middleware libraries from each other and the main application. +* +* See \ref DOMAINS for more details +* +* @{ +*/ + +/* ------------------------------------------------------------------------- */ +/** \brief Register a NVTX domain. +* +* Domains are used to scope annotations. All NVTX_VERSION_0 and NVTX_VERSION_1 +* annotations are scoped to the global domain. The function nvtxDomainCreate +* creates a new named domain. +* +* Each domain maintains its own nvtxRangePush and nvtxRangePop stack. +* +* \param name - A unique string representing the domain. +* +* \return A handle representing the domain. +* +* \par Example +* Create a domain: +* \code +* nvtxDomainHandle_t domain = nvtxDomainCreateA("com.nvidia.nvtx.example"); +* +* nvtxMarkA("nvtxMarkA to global domain"); +* +* nvtxEventAttributes_t eventAttrib1 = {0}; +* eventAttrib1.version = NVTX_VERSION; +* eventAttrib1.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE; +* eventAttrib1.message.ascii = "nvtxDomainMarkEx to global domain"; +* nvtxDomainMarkEx(NULL, &eventAttrib1); +* +* nvtxEventAttributes_t eventAttrib2 = {0}; +* eventAttrib2.version = NVTX_VERSION; +* eventAttrib2.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE; +* eventAttrib2.message.ascii = "nvtxDomainMarkEx to com.nvidia.nvtx.example"; +* nvtxDomainMarkEx(domain, &eventAttrib2); +* +* nvtxDomainDestroy(domain); +* \endcode +* +* \sa +* ::nvtxDomainDestroy +* +* \version NVTX_VERSION_2 +* @{ */ +NVTX_DECLSPEC nvtxDomainHandle_t NVTX_API nvtxDomainCreateA(const char* name); +NVTX_DECLSPEC nvtxDomainHandle_t NVTX_API nvtxDomainCreateW(const wchar_t* name); +/** @} */ + +/* ------------------------------------------------------------------------- */ +/** \brief Unregister a NVTX domain. +* +* Unregisters the domain handle and frees all domain specific resources. +* +* \param domain - the domain handle +* +* \par Example +* Destroy a domain: +* \code +* nvtxDomainHandle_t domain = nvtxDomainCreateA("com.nvidia.nvtx.example"); +* // ... +* nvtxDomainDestroy(domain); +* \endcode +* +* \sa +* ::nvtxDomainCreateA +* ::nvtxDomainCreateW +* +* \version NVTX_VERSION_2 +* @{ */ +NVTX_DECLSPEC void NVTX_API nvtxDomainDestroy(nvtxDomainHandle_t domain); +/** @} */ + + +/** @} */ /*END defgroup*/ +/* ========================================================================= */ +/** \cond SHOW_HIDDEN */ + +#ifdef UNICODE + #define nvtxMark nvtxMarkW + #define nvtxRangeStart nvtxRangeStartW + #define nvtxRangePush nvtxRangePushW + #define nvtxNameCategory nvtxNameCategoryW + #define nvtxNameOsThread nvtxNameOsThreadW + /* NVTX_VERSION_2 */ + #define nvtxDomainCreate nvtxDomainCreateW + #define nvtxDomainRegisterString nvtxDomainRegisterStringW + #define nvtxDomainNameCategory nvtxDomainNameCategoryW +#else + #define nvtxMark nvtxMarkA + #define nvtxRangeStart nvtxRangeStartA + #define nvtxRangePush nvtxRangePushA + #define nvtxNameCategory nvtxNameCategoryA + #define nvtxNameOsThread nvtxNameOsThreadA + /* NVTX_VERSION_2 */ + #define nvtxDomainCreate nvtxDomainCreateA + #define nvtxDomainRegisterString nvtxDomainRegisterStringA + #define nvtxDomainNameCategory nvtxDomainNameCategoryA +#endif + +/** \endcond */ + +#ifdef __cplusplus +} /* extern "C" */ +#endif /* __cplusplus */ + +#define NVTX_IMPL_GUARD /* Ensure other headers cannot be included directly */ + +#include "nvtxDetail/nvtxTypes.h" + +#ifndef NVTX_NO_IMPL +#include "nvtxDetail/nvtxImpl.h" +#endif /*NVTX_NO_IMPL*/ + +#undef NVTX_IMPL_GUARD + +#endif /* !defined(NVTX_VERSION) */ diff --git a/nvpro_core_legacy/nvtx3/nvtxDetail/nvtxLinkOnce.h b/nvpro_core_legacy/nvtx3/nvtxDetail/nvtxLinkOnce.h new file mode 100644 index 0000000..e165600 --- /dev/null +++ b/nvpro_core_legacy/nvtx3/nvtxDetail/nvtxLinkOnce.h @@ -0,0 +1,88 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2009-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * Licensed under the Apache License v2.0 with LLVM Exceptions. + * See https://nvidia.github.io/NVTX/LICENSE.txt for license information. + */ + +#if defined(NVTX_AS_SYSTEM_HEADER) +#if defined(__clang__) +#pragma clang system_header +#elif defined(__GNUC__) || defined(__NVCOMPILER) +#pragma GCC system_header +#elif defined(_MSC_VER) +#pragma system_header +#endif +#endif + +#ifndef __NVTX_LINKONCE_H__ +#define __NVTX_LINKONCE_H__ + +/* This header defines macros to permit making definitions of global variables + * and functions in C/C++ header files which may be included multiple times in + * a translation unit or linkage unit. It allows authoring header-only libraries + * which can be used by multiple other header-only libraries (either as the same + * copy or multiple copies), and does not require any build changes, such as + * adding another .c file, linking a static library, or deploying a dynamic + * library. Globals defined with these macros have the property that they have + * the same address, pointing to a single instance, for the entire linkage unit. + * It is expected but not guaranteed that each linkage unit will have a separate + * instance. + * + * In some situations it is desirable to declare a variable without initializing + * it, refer to it in code or other variables' initializers, and then initialize + * it later. Similarly, functions can be prototyped, have their address taken, + * and then have their body defined later. In such cases, use the FWDDECL macros + * when forward-declaring LINKONCE global variables without initializers and + * function prototypes, and then use the DEFINE macros when later defining them. + * Although in many cases the FWDDECL macro is equivalent to the DEFINE macro, + * following this pattern makes code maximally portable. + */ + +#if defined(_MSC_VER) /* MSVC */ + #if defined(__cplusplus) + #define NVTX_LINKONCE_DEFINE_GLOBAL extern "C" __declspec(selectany) + #define NVTX_LINKONCE_DEFINE_FUNCTION extern "C" inline + #else + #define NVTX_LINKONCE_DEFINE_GLOBAL __declspec(selectany) + #define NVTX_LINKONCE_DEFINE_FUNCTION __inline + #endif + #define NVTX_LINKONCE_FWDDECL_GLOBAL NVTX_LINKONCE_DEFINE_GLOBAL extern +#elif defined(_WIN32) || defined(__CYGWIN__) /* MinGW */ + #if defined(__cplusplus) + #define NVTX_LINKONCE_DEFINE_GLOBAL __declspec(selectany) + #define NVTX_LINKONCE_DEFINE_FUNCTION extern "C" inline + #else + #define NVTX_LINKONCE_DEFINE_GLOBAL __declspec(selectany) + #define NVTX_LINKONCE_DEFINE_FUNCTION + #endif + #define NVTX_LINKONCE_FWDDECL_GLOBAL extern +#else /* All others: Assume GCC, clang, or compatible */ + #define NVTX_LINKONCE_WEAK __attribute__((weak)) + #define NVTX_LINKONCE_HIDDEN __attribute__((visibility("hidden"))) + #if defined(__cplusplus) + #define NVTX_LINKONCE_DEFINE_GLOBAL NVTX_LINKONCE_HIDDEN NVTX_LINKONCE_WEAK + #define NVTX_LINKONCE_DEFINE_FUNCTION extern "C" NVTX_LINKONCE_HIDDEN inline + #else + #define NVTX_LINKONCE_DEFINE_GLOBAL NVTX_LINKONCE_HIDDEN NVTX_LINKONCE_WEAK + #define NVTX_LINKONCE_DEFINE_FUNCTION NVTX_LINKONCE_HIDDEN NVTX_LINKONCE_WEAK + #endif + #define NVTX_LINKONCE_FWDDECL_GLOBAL NVTX_LINKONCE_DEFINE_GLOBAL extern +#endif + +#define NVTX_LINKONCE_FWDDECL_FUNCTION NVTX_LINKONCE_DEFINE_FUNCTION + +#endif /* __NVTX_LINKONCE_H__ */ diff --git a/nvpro_core_legacy/nvtx3/nvtxDetail/nvtxTypes.h b/nvpro_core_legacy/nvtx3/nvtxDetail/nvtxTypes.h new file mode 100644 index 0000000..0edb9f4 --- /dev/null +++ b/nvpro_core_legacy/nvtx3/nvtxDetail/nvtxTypes.h @@ -0,0 +1,318 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2009-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * Licensed under the Apache License v2.0 with LLVM Exceptions. + * See https://nvidia.github.io/NVTX/LICENSE.txt for license information. + */ + +/* This header defines types which are used by the internal implementation +* of NVTX and callback subscribers. API clients do not use these types, +* so they are defined here instead of in nvToolsExt.h to clarify they are +* not part of the NVTX client API. */ + +#ifndef NVTX_IMPL_GUARD +#error Never include this file directly -- it is automatically included by nvToolsExt.h. +#endif + +#if defined(NVTX_AS_SYSTEM_HEADER) +#if defined(__clang__) +#pragma clang system_header +#elif defined(__GNUC__) || defined(__NVCOMPILER) +#pragma GCC system_header +#elif defined(_MSC_VER) +#pragma system_header +#endif +#endif + +/* ------ Dependency-free types binary-compatible with real types ------- */ + +/* In order to avoid having the NVTX core API headers depend on non-NVTX +* headers like cuda.h, NVTX defines binary-compatible types to use for +* safely making the initialization versions of all NVTX functions without +* needing to have definitions for the real types. */ + +typedef int nvtx_CUdevice; +typedef void* nvtx_CUcontext; +typedef void* nvtx_CUstream; +typedef void* nvtx_CUevent; + +typedef void* nvtx_cudaStream_t; +typedef void* nvtx_cudaEvent_t; + +typedef void* nvtx_cl_platform_id; +typedef void* nvtx_cl_device_id; +typedef void* nvtx_cl_context; +typedef void* nvtx_cl_command_queue; +typedef void* nvtx_cl_mem; +typedef void* nvtx_cl_program; +typedef void* nvtx_cl_kernel; +typedef void* nvtx_cl_event; +typedef void* nvtx_cl_sampler; + +typedef void* nvtx_nvtxSyncUser_t; +typedef void nvtx_nvtxSyncUserAttributes_t; + +/* --------- Types for function pointers (with fake API types) ---------- */ + +typedef void (NVTX_API * nvtxMarkEx_impl_fntype)(const nvtxEventAttributes_t* eventAttrib); +typedef void (NVTX_API * nvtxMarkA_impl_fntype)(const char* message); +typedef void (NVTX_API * nvtxMarkW_impl_fntype)(const wchar_t* message); +typedef nvtxRangeId_t (NVTX_API * nvtxRangeStartEx_impl_fntype)(const nvtxEventAttributes_t* eventAttrib); +typedef nvtxRangeId_t (NVTX_API * nvtxRangeStartA_impl_fntype)(const char* message); +typedef nvtxRangeId_t (NVTX_API * nvtxRangeStartW_impl_fntype)(const wchar_t* message); +typedef void (NVTX_API * nvtxRangeEnd_impl_fntype)(nvtxRangeId_t id); +typedef int (NVTX_API * nvtxRangePushEx_impl_fntype)(const nvtxEventAttributes_t* eventAttrib); +typedef int (NVTX_API * nvtxRangePushA_impl_fntype)(const char* message); +typedef int (NVTX_API * nvtxRangePushW_impl_fntype)(const wchar_t* message); +typedef int (NVTX_API * nvtxRangePop_impl_fntype)(void); +typedef void (NVTX_API * nvtxNameCategoryA_impl_fntype)(uint32_t category, const char* name); +typedef void (NVTX_API * nvtxNameCategoryW_impl_fntype)(uint32_t category, const wchar_t* name); +typedef void (NVTX_API * nvtxNameOsThreadA_impl_fntype)(uint32_t threadId, const char* name); +typedef void (NVTX_API * nvtxNameOsThreadW_impl_fntype)(uint32_t threadId, const wchar_t* name); + +/* Real impl types are defined in nvtxImplCuda_v3.h, where CUDA headers are included */ +typedef void (NVTX_API * nvtxNameCuDeviceA_fakeimpl_fntype)(nvtx_CUdevice device, const char* name); +typedef void (NVTX_API * nvtxNameCuDeviceW_fakeimpl_fntype)(nvtx_CUdevice device, const wchar_t* name); +typedef void (NVTX_API * nvtxNameCuContextA_fakeimpl_fntype)(nvtx_CUcontext context, const char* name); +typedef void (NVTX_API * nvtxNameCuContextW_fakeimpl_fntype)(nvtx_CUcontext context, const wchar_t* name); +typedef void (NVTX_API * nvtxNameCuStreamA_fakeimpl_fntype)(nvtx_CUstream stream, const char* name); +typedef void (NVTX_API * nvtxNameCuStreamW_fakeimpl_fntype)(nvtx_CUstream stream, const wchar_t* name); +typedef void (NVTX_API * nvtxNameCuEventA_fakeimpl_fntype)(nvtx_CUevent event, const char* name); +typedef void (NVTX_API * nvtxNameCuEventW_fakeimpl_fntype)(nvtx_CUevent event, const wchar_t* name); + +/* Real impl types are defined in nvtxImplOpenCL_v3.h, where OPENCL headers are included */ +typedef void (NVTX_API * nvtxNameClDeviceA_fakeimpl_fntype)(nvtx_cl_device_id device, const char* name); +typedef void (NVTX_API * nvtxNameClDeviceW_fakeimpl_fntype)(nvtx_cl_device_id device, const wchar_t* name); +typedef void (NVTX_API * nvtxNameClContextA_fakeimpl_fntype)(nvtx_cl_context context, const char* name); +typedef void (NVTX_API * nvtxNameClContextW_fakeimpl_fntype)(nvtx_cl_context context, const wchar_t* name); +typedef void (NVTX_API * nvtxNameClCommandQueueA_fakeimpl_fntype)(nvtx_cl_command_queue command_queue, const char* name); +typedef void (NVTX_API * nvtxNameClCommandQueueW_fakeimpl_fntype)(nvtx_cl_command_queue command_queue, const wchar_t* name); +typedef void (NVTX_API * nvtxNameClMemObjectA_fakeimpl_fntype)(nvtx_cl_mem memobj, const char* name); +typedef void (NVTX_API * nvtxNameClMemObjectW_fakeimpl_fntype)(nvtx_cl_mem memobj, const wchar_t* name); +typedef void (NVTX_API * nvtxNameClSamplerA_fakeimpl_fntype)(nvtx_cl_sampler sampler, const char* name); +typedef void (NVTX_API * nvtxNameClSamplerW_fakeimpl_fntype)(nvtx_cl_sampler sampler, const wchar_t* name); +typedef void (NVTX_API * nvtxNameClProgramA_fakeimpl_fntype)(nvtx_cl_program program, const char* name); +typedef void (NVTX_API * nvtxNameClProgramW_fakeimpl_fntype)(nvtx_cl_program program, const wchar_t* name); +typedef void (NVTX_API * nvtxNameClEventA_fakeimpl_fntype)(nvtx_cl_event evnt, const char* name); +typedef void (NVTX_API * nvtxNameClEventW_fakeimpl_fntype)(nvtx_cl_event evnt, const wchar_t* name); + +/* Real impl types are defined in nvtxImplCudaRt_v3.h, where CUDART headers are included */ +typedef void (NVTX_API * nvtxNameCudaDeviceA_fakeimpl_fntype)(int device, const char* name); +typedef void (NVTX_API * nvtxNameCudaDeviceW_fakeimpl_fntype)(int device, const wchar_t* name); +typedef void (NVTX_API * nvtxNameCudaStreamA_fakeimpl_fntype)(nvtx_cudaStream_t stream, const char* name); +typedef void (NVTX_API * nvtxNameCudaStreamW_fakeimpl_fntype)(nvtx_cudaStream_t stream, const wchar_t* name); +typedef void (NVTX_API * nvtxNameCudaEventA_fakeimpl_fntype)(nvtx_cudaEvent_t event, const char* name); +typedef void (NVTX_API * nvtxNameCudaEventW_fakeimpl_fntype)(nvtx_cudaEvent_t event, const wchar_t* name); + +typedef void (NVTX_API * nvtxDomainMarkEx_impl_fntype)(nvtxDomainHandle_t domain, const nvtxEventAttributes_t* eventAttrib); +typedef nvtxRangeId_t (NVTX_API * nvtxDomainRangeStartEx_impl_fntype)(nvtxDomainHandle_t domain, const nvtxEventAttributes_t* eventAttrib); +typedef void (NVTX_API * nvtxDomainRangeEnd_impl_fntype)(nvtxDomainHandle_t domain, nvtxRangeId_t id); +typedef int (NVTX_API * nvtxDomainRangePushEx_impl_fntype)(nvtxDomainHandle_t domain, const nvtxEventAttributes_t* eventAttrib); +typedef int (NVTX_API * nvtxDomainRangePop_impl_fntype)(nvtxDomainHandle_t domain); +typedef nvtxResourceHandle_t (NVTX_API * nvtxDomainResourceCreate_impl_fntype)(nvtxDomainHandle_t domain, nvtxResourceAttributes_t* attribs); +typedef void (NVTX_API * nvtxDomainResourceDestroy_impl_fntype)(nvtxResourceHandle_t resource); +typedef void (NVTX_API * nvtxDomainNameCategoryA_impl_fntype)(nvtxDomainHandle_t domain, uint32_t category, const char* name); +typedef void (NVTX_API * nvtxDomainNameCategoryW_impl_fntype)(nvtxDomainHandle_t domain, uint32_t category, const wchar_t* name); +typedef nvtxStringHandle_t (NVTX_API * nvtxDomainRegisterStringA_impl_fntype)(nvtxDomainHandle_t domain, const char* string); +typedef nvtxStringHandle_t (NVTX_API * nvtxDomainRegisterStringW_impl_fntype)(nvtxDomainHandle_t domain, const wchar_t* string); +typedef nvtxDomainHandle_t (NVTX_API * nvtxDomainCreateA_impl_fntype)(const char* message); +typedef nvtxDomainHandle_t (NVTX_API * nvtxDomainCreateW_impl_fntype)(const wchar_t* message); +typedef void (NVTX_API * nvtxDomainDestroy_impl_fntype)(nvtxDomainHandle_t domain); +typedef void (NVTX_API * nvtxInitialize_impl_fntype)(const void* reserved); + +typedef nvtx_nvtxSyncUser_t (NVTX_API * nvtxDomainSyncUserCreate_fakeimpl_fntype)(nvtxDomainHandle_t domain, const nvtx_nvtxSyncUserAttributes_t* attribs); +typedef void (NVTX_API * nvtxDomainSyncUserDestroy_fakeimpl_fntype)(nvtx_nvtxSyncUser_t handle); +typedef void (NVTX_API * nvtxDomainSyncUserAcquireStart_fakeimpl_fntype)(nvtx_nvtxSyncUser_t handle); +typedef void (NVTX_API * nvtxDomainSyncUserAcquireFailed_fakeimpl_fntype)(nvtx_nvtxSyncUser_t handle); +typedef void (NVTX_API * nvtxDomainSyncUserAcquireSuccess_fakeimpl_fntype)(nvtx_nvtxSyncUser_t handle); +typedef void (NVTX_API * nvtxDomainSyncUserReleasing_fakeimpl_fntype)(nvtx_nvtxSyncUser_t handle); + +/* ---------------- Types for callback subscription --------------------- */ + +typedef const void *(NVTX_API * NvtxGetExportTableFunc_t)(uint32_t exportTableId); +typedef int (NVTX_API * NvtxInitializeInjectionNvtxFunc_t)(NvtxGetExportTableFunc_t exportTable); + +typedef enum NvtxCallbackModule +{ + NVTX_CB_MODULE_INVALID = 0, + NVTX_CB_MODULE_CORE = 1, + NVTX_CB_MODULE_CUDA = 2, + NVTX_CB_MODULE_OPENCL = 3, + NVTX_CB_MODULE_CUDART = 4, + NVTX_CB_MODULE_CORE2 = 5, + NVTX_CB_MODULE_SYNC = 6, + /* --- New constants must only be added directly above this line --- */ + NVTX_CB_MODULE_SIZE, + NVTX_CB_MODULE_FORCE_INT = 0x7fffffff +} NvtxCallbackModule; + +typedef enum NvtxCallbackIdCore +{ + NVTX_CBID_CORE_INVALID = 0, + NVTX_CBID_CORE_MarkEx = 1, + NVTX_CBID_CORE_MarkA = 2, + NVTX_CBID_CORE_MarkW = 3, + NVTX_CBID_CORE_RangeStartEx = 4, + NVTX_CBID_CORE_RangeStartA = 5, + NVTX_CBID_CORE_RangeStartW = 6, + NVTX_CBID_CORE_RangeEnd = 7, + NVTX_CBID_CORE_RangePushEx = 8, + NVTX_CBID_CORE_RangePushA = 9, + NVTX_CBID_CORE_RangePushW = 10, + NVTX_CBID_CORE_RangePop = 11, + NVTX_CBID_CORE_NameCategoryA = 12, + NVTX_CBID_CORE_NameCategoryW = 13, + NVTX_CBID_CORE_NameOsThreadA = 14, + NVTX_CBID_CORE_NameOsThreadW = 15, + /* --- New constants must only be added directly above this line --- */ + NVTX_CBID_CORE_SIZE, + NVTX_CBID_CORE_FORCE_INT = 0x7fffffff +} NvtxCallbackIdCore; + +typedef enum NvtxCallbackIdCore2 +{ + NVTX_CBID_CORE2_INVALID = 0, + NVTX_CBID_CORE2_DomainMarkEx = 1, + NVTX_CBID_CORE2_DomainRangeStartEx = 2, + NVTX_CBID_CORE2_DomainRangeEnd = 3, + NVTX_CBID_CORE2_DomainRangePushEx = 4, + NVTX_CBID_CORE2_DomainRangePop = 5, + NVTX_CBID_CORE2_DomainResourceCreate = 6, + NVTX_CBID_CORE2_DomainResourceDestroy = 7, + NVTX_CBID_CORE2_DomainNameCategoryA = 8, + NVTX_CBID_CORE2_DomainNameCategoryW = 9, + NVTX_CBID_CORE2_DomainRegisterStringA = 10, + NVTX_CBID_CORE2_DomainRegisterStringW = 11, + NVTX_CBID_CORE2_DomainCreateA = 12, + NVTX_CBID_CORE2_DomainCreateW = 13, + NVTX_CBID_CORE2_DomainDestroy = 14, + NVTX_CBID_CORE2_Initialize = 15, + /* --- New constants must only be added directly above this line --- */ + NVTX_CBID_CORE2_SIZE, + NVTX_CBID_CORE2_FORCE_INT = 0x7fffffff +} NvtxCallbackIdCore2; + +typedef enum NvtxCallbackIdCuda +{ + NVTX_CBID_CUDA_INVALID = 0, + NVTX_CBID_CUDA_NameCuDeviceA = 1, + NVTX_CBID_CUDA_NameCuDeviceW = 2, + NVTX_CBID_CUDA_NameCuContextA = 3, + NVTX_CBID_CUDA_NameCuContextW = 4, + NVTX_CBID_CUDA_NameCuStreamA = 5, + NVTX_CBID_CUDA_NameCuStreamW = 6, + NVTX_CBID_CUDA_NameCuEventA = 7, + NVTX_CBID_CUDA_NameCuEventW = 8, + /* --- New constants must only be added directly above this line --- */ + NVTX_CBID_CUDA_SIZE, + NVTX_CBID_CUDA_FORCE_INT = 0x7fffffff +} NvtxCallbackIdCuda; + +typedef enum NvtxCallbackIdCudaRt +{ + NVTX_CBID_CUDART_INVALID = 0, + NVTX_CBID_CUDART_NameCudaDeviceA = 1, + NVTX_CBID_CUDART_NameCudaDeviceW = 2, + NVTX_CBID_CUDART_NameCudaStreamA = 3, + NVTX_CBID_CUDART_NameCudaStreamW = 4, + NVTX_CBID_CUDART_NameCudaEventA = 5, + NVTX_CBID_CUDART_NameCudaEventW = 6, + /* --- New constants must only be added directly above this line --- */ + NVTX_CBID_CUDART_SIZE, + NVTX_CBID_CUDART_FORCE_INT = 0x7fffffff +} NvtxCallbackIdCudaRt; + +typedef enum NvtxCallbackIdOpenCL +{ + NVTX_CBID_OPENCL_INVALID = 0, + NVTX_CBID_OPENCL_NameClDeviceA = 1, + NVTX_CBID_OPENCL_NameClDeviceW = 2, + NVTX_CBID_OPENCL_NameClContextA = 3, + NVTX_CBID_OPENCL_NameClContextW = 4, + NVTX_CBID_OPENCL_NameClCommandQueueA = 5, + NVTX_CBID_OPENCL_NameClCommandQueueW = 6, + NVTX_CBID_OPENCL_NameClMemObjectA = 7, + NVTX_CBID_OPENCL_NameClMemObjectW = 8, + NVTX_CBID_OPENCL_NameClSamplerA = 9, + NVTX_CBID_OPENCL_NameClSamplerW = 10, + NVTX_CBID_OPENCL_NameClProgramA = 11, + NVTX_CBID_OPENCL_NameClProgramW = 12, + NVTX_CBID_OPENCL_NameClEventA = 13, + NVTX_CBID_OPENCL_NameClEventW = 14, + /* --- New constants must only be added directly above this line --- */ + NVTX_CBID_OPENCL_SIZE, + NVTX_CBID_OPENCL_FORCE_INT = 0x7fffffff +} NvtxCallbackIdOpenCL; + +typedef enum NvtxCallbackIdSync +{ + NVTX_CBID_SYNC_INVALID = 0, + NVTX_CBID_SYNC_DomainSyncUserCreate = 1, + NVTX_CBID_SYNC_DomainSyncUserDestroy = 2, + NVTX_CBID_SYNC_DomainSyncUserAcquireStart = 3, + NVTX_CBID_SYNC_DomainSyncUserAcquireFailed = 4, + NVTX_CBID_SYNC_DomainSyncUserAcquireSuccess = 5, + NVTX_CBID_SYNC_DomainSyncUserReleasing = 6, + /* --- New constants must only be added directly above this line --- */ + NVTX_CBID_SYNC_SIZE, + NVTX_CBID_SYNC_FORCE_INT = 0x7fffffff +} NvtxCallbackIdSync; + +/* IDs for NVTX Export Tables */ +typedef enum NvtxExportTableID +{ + NVTX_ETID_INVALID = 0, + NVTX_ETID_CALLBACKS = 1, + NVTX_ETID_RESERVED0 = 2, + NVTX_ETID_VERSIONINFO = 3, + /* --- New constants must only be added directly above this line --- */ + NVTX_ETID_SIZE, + NVTX_ETID_FORCE_INT = 0x7fffffff +} NvtxExportTableID; + +typedef void (* NvtxFunctionPointer)(void); /* generic uncallable function pointer, must be cast to appropriate function type */ +typedef NvtxFunctionPointer** NvtxFunctionTable; /* double pointer because array(1) of pointers(2) to function pointers */ + +typedef struct NvtxExportTableCallbacks +{ + size_t struct_size; + + /* returns an array of pointer to function pointers*/ + int (NVTX_API *GetModuleFunctionTable)( + NvtxCallbackModule callback_module, + NvtxFunctionTable* out_table, + unsigned int* out_size); +} NvtxExportTableCallbacks; + +typedef struct NvtxExportTableVersionInfo +{ + /* sizeof(NvtxExportTableVersionInfo) */ + size_t struct_size; + + /* The API version comes from the NVTX library linked to the app. The + * injection library is can use this info to make some assumptions */ + uint32_t version; + + /* Reserved for alignment, do not use */ + uint32_t reserved0; + + /* This must be set by tools when attaching to provide applications + * the ability to, in emergency situations, detect problematic tools + * versions and modify the NVTX source to prevent attaching anything + * that causes trouble in the app. Currently, this value is ignored. */ + void (NVTX_API *SetInjectionNvtxVersion)( + uint32_t version); +} NvtxExportTableVersionInfo; diff --git a/nvpro_core_legacy/nvvkhl/Roboto-Regular.h b/nvpro_core_legacy/nvvkhl/Roboto-Regular.h new file mode 100644 index 0000000..7ef0948 --- /dev/null +++ b/nvpro_core_legacy/nvvkhl/Roboto-Regular.h @@ -0,0 +1,9039 @@ +/// @DOC_SKIP +const uint8_t g_Roboto_Regular[] = { + 0x00, 0x01, 0x00, 0x00, 0x00, 0x12, 0x01, 0x00, 0x00, 0x04, 0x00, 0x20, 0x47, 0x44, 0x45, 0x46, 0xb4, 0x42, 0xb0, + 0x82, 0x00, 0x02, 0x28, 0xdc, 0x00, 0x00, 0x02, 0x62, 0x47, 0x50, 0x4f, 0x53, 0xff, 0x1a, 0x12, 0xd7, 0x00, 0x02, + 0x2b, 0x40, 0x00, 0x00, 0x5d, 0xcc, 0x47, 0x53, 0x55, 0x42, 0xeb, 0x82, 0xe4, 0x59, 0x00, 0x02, 0x89, 0x0c, 0x00, + 0x00, 0x15, 0x90, 0x4f, 0x53, 0x2f, 0x32, 0x97, 0x82, 0xb1, 0xa8, 0x00, 0x00, 0x01, 0xa8, 0x00, 0x00, 0x00, 0x60, + 0x63, 0x6d, 0x61, 0x70, 0x01, 0x77, 0x58, 0x1e, 0x00, 0x00, 0x1b, 0x58, 0x00, 0x00, 0x12, 0x46, 0x63, 0x76, 0x74, + 0x20, 0x2b, 0xa8, 0x07, 0x9d, 0x00, 0x00, 0x30, 0xa8, 0x00, 0x00, 0x00, 0x54, 0x66, 0x70, 0x67, 0x6d, 0x77, 0xf8, + 0x60, 0xab, 0x00, 0x00, 0x2d, 0xa0, 0x00, 0x00, 0x01, 0xbc, 0x67, 0x61, 0x73, 0x70, 0x00, 0x08, 0x00, 0x13, 0x00, + 0x02, 0x28, 0xd0, 0x00, 0x00, 0x00, 0x0c, 0x67, 0x6c, 0x79, 0x66, 0x26, 0xba, 0x0b, 0xf4, 0x00, 0x00, 0x3b, 0x1c, + 0x00, 0x01, 0xe9, 0x6c, 0x68, 0x64, 0x6d, 0x78, 0x55, 0x7a, 0x60, 0x7a, 0x00, 0x00, 0x16, 0x40, 0x00, 0x00, 0x05, + 0x18, 0x68, 0x65, 0x61, 0x64, 0xfc, 0x6a, 0xd2, 0x7a, 0x00, 0x00, 0x01, 0x2c, 0x00, 0x00, 0x00, 0x36, 0x68, 0x68, + 0x65, 0x61, 0x0a, 0xba, 0x0a, 0xae, 0x00, 0x00, 0x01, 0x64, 0x00, 0x00, 0x00, 0x24, 0x68, 0x6d, 0x74, 0x78, 0xae, + 0x72, 0x8f, 0x97, 0x00, 0x00, 0x02, 0x08, 0x00, 0x00, 0x14, 0x38, 0x6c, 0x6f, 0x63, 0x61, 0x80, 0x77, 0xff, 0xbb, + 0x00, 0x00, 0x30, 0xfc, 0x00, 0x00, 0x0a, 0x1e, 0x6d, 0x61, 0x78, 0x70, 0x07, 0x3e, 0x03, 0x09, 0x00, 0x00, 0x01, + 0x88, 0x00, 0x00, 0x00, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0xe6, 0xa4, 0x15, 0x89, 0x00, 0x02, 0x24, 0x88, 0x00, 0x00, + 0x04, 0x26, 0x70, 0x6f, 0x73, 0x74, 0xff, 0x6d, 0x00, 0x64, 0x00, 0x02, 0x28, 0xb0, 0x00, 0x00, 0x00, 0x20, 0x70, + 0x72, 0x65, 0x70, 0xa2, 0x66, 0xfa, 0xc9, 0x00, 0x00, 0x2f, 0x5c, 0x00, 0x00, 0x01, 0x49, 0x00, 0x01, 0x00, 0x00, + 0x00, 0x02, 0x23, 0x12, 0x8a, 0x7f, 0x70, 0x48, 0x5f, 0x0f, 0x3c, 0xf5, 0x00, 0x19, 0x08, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xc4, 0xf0, 0x11, 0x2e, 0x00, 0x00, 0x00, 0x00, 0xd5, 0x01, 0x52, 0xf4, 0xfa, 0x1b, 0xfd, 0xd5, 0x09, 0x30, + 0x08, 0x73, 0x00, 0x00, 0x00, 0x09, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x07, + 0x6c, 0xfe, 0x0c, 0x00, 0x00, 0x09, 0x49, 0xfa, 0x1b, 0xfe, 0x4a, 0x09, 0x30, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x0e, 0x00, 0x01, 0x00, 0x00, 0x05, 0x0e, 0x00, + 0x8f, 0x00, 0x16, 0x00, 0x54, 0x00, 0x05, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x02, 0x00, + 0x02, 0x24, 0x00, 0x06, 0x00, 0x01, 0x00, 0x03, 0x04, 0x86, 0x01, 0x90, 0x00, 0x05, 0x00, 0x00, 0x05, 0x9a, 0x05, + 0x33, 0x00, 0x00, 0x01, 0x1f, 0x05, 0x9a, 0x05, 0x33, 0x00, 0x00, 0x03, 0xd1, 0x00, 0x66, 0x02, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x02, 0xff, 0x50, 0x00, 0x20, 0x5b, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x47, 0x4f, 0x4f, 0x47, 0x00, 0x40, 0x00, 0x00, 0xff, 0xfd, 0x06, 0x00, + 0xfe, 0x00, 0x00, 0x66, 0x07, 0x9a, 0x02, 0x00, 0x20, 0x00, 0x01, 0x9f, 0x00, 0x00, 0x00, 0x00, 0x04, 0x3a, 0x05, + 0xb0, 0x00, 0x20, 0x00, 0x20, 0x00, 0x03, 0x03, 0x8c, 0x00, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0xfb, 0x00, 0x00, 0x01, 0xfb, 0x00, 0x00, 0x02, 0x0f, 0x00, 0xa0, 0x02, 0x8f, 0x00, 0x88, 0x04, 0xed, 0x00, + 0x77, 0x04, 0x7e, 0x00, 0x6e, 0x05, 0xdc, 0x00, 0x69, 0x04, 0xf9, 0x00, 0x65, 0x01, 0x65, 0x00, 0x67, 0x02, 0xbc, + 0x00, 0x85, 0x02, 0xc8, 0x00, 0x26, 0x03, 0x72, 0x00, 0x1c, 0x04, 0x89, 0x00, 0x4e, 0x01, 0x92, 0x00, 0x1d, 0x02, + 0x35, 0x00, 0x25, 0x02, 0x1b, 0x00, 0x90, 0x03, 0x4c, 0x00, 0x12, 0x04, 0x7e, 0x00, 0x73, 0x04, 0x7e, 0x00, 0xaa, + 0x04, 0x7e, 0x00, 0x5d, 0x04, 0x7e, 0x00, 0x5e, 0x04, 0x7e, 0x00, 0x35, 0x04, 0x7e, 0x00, 0x9a, 0x04, 0x7e, 0x00, + 0x84, 0x04, 0x7e, 0x00, 0x4d, 0x04, 0x7e, 0x00, 0x70, 0x04, 0x7e, 0x00, 0x64, 0x01, 0xf0, 0x00, 0x86, 0x01, 0xb1, + 0x00, 0x29, 0x04, 0x11, 0x00, 0x48, 0x04, 0x64, 0x00, 0x98, 0x04, 0x2e, 0x00, 0x86, 0x03, 0xc7, 0x00, 0x4b, 0x07, + 0x2f, 0x00, 0x6a, 0x05, 0x38, 0x00, 0x1c, 0x04, 0xfb, 0x00, 0xa9, 0x05, 0x35, 0x00, 0x77, 0x05, 0x3f, 0x00, 0xa9, + 0x04, 0x8c, 0x00, 0xa9, 0x04, 0x6c, 0x00, 0xa9, 0x05, 0x73, 0x00, 0x7a, 0x05, 0xb4, 0x00, 0xa9, 0x02, 0x2d, 0x00, + 0xb7, 0x04, 0x6a, 0x00, 0x35, 0x05, 0x04, 0x00, 0xa9, 0x04, 0x4e, 0x00, 0xa9, 0x06, 0xfc, 0x00, 0xa9, 0x05, 0xb4, + 0x00, 0xa9, 0x05, 0x80, 0x00, 0x76, 0x05, 0x0c, 0x00, 0xa9, 0x05, 0x80, 0x00, 0x6d, 0x04, 0xed, 0x00, 0xa8, 0x04, + 0xbf, 0x00, 0x50, 0x04, 0xc6, 0x00, 0x31, 0x05, 0x30, 0x00, 0x8c, 0x05, 0x17, 0x00, 0x1c, 0x07, 0x19, 0x00, 0x3d, + 0x05, 0x04, 0x00, 0x39, 0x04, 0xce, 0x00, 0x0f, 0x04, 0xca, 0x00, 0x56, 0x02, 0x1f, 0x00, 0x92, 0x03, 0x48, 0x00, + 0x28, 0x02, 0x1f, 0x00, 0x09, 0x03, 0x58, 0x00, 0x40, 0x03, 0x9c, 0x00, 0x04, 0x02, 0x79, 0x00, 0x39, 0x04, 0x5a, + 0x00, 0x6d, 0x04, 0x7d, 0x00, 0x8c, 0x04, 0x30, 0x00, 0x5c, 0x04, 0x83, 0x00, 0x5f, 0x04, 0x3d, 0x00, 0x5d, 0x02, + 0xc7, 0x00, 0x3c, 0x04, 0x7d, 0x00, 0x60, 0x04, 0x68, 0x00, 0x8c, 0x01, 0xf1, 0x00, 0x8d, 0x01, 0xe9, 0xff, 0xbf, + 0x04, 0x0e, 0x00, 0x8d, 0x01, 0xf1, 0x00, 0x9c, 0x07, 0x03, 0x00, 0x8b, 0x04, 0x6a, 0x00, 0x8c, 0x04, 0x90, 0x00, + 0x5b, 0x04, 0x7d, 0x00, 0x8c, 0x04, 0x8c, 0x00, 0x5f, 0x02, 0xb5, 0x00, 0x8c, 0x04, 0x20, 0x00, 0x5f, 0x02, 0x9d, + 0x00, 0x09, 0x04, 0x69, 0x00, 0x88, 0x03, 0xe0, 0x00, 0x21, 0x06, 0x03, 0x00, 0x2b, 0x03, 0xf7, 0x00, 0x29, 0x03, + 0xc9, 0x00, 0x16, 0x03, 0xf7, 0x00, 0x58, 0x02, 0xb5, 0x00, 0x40, 0x01, 0xf3, 0x00, 0xaf, 0x02, 0xb5, 0x00, 0x13, + 0x05, 0x71, 0x00, 0x83, 0x01, 0xf3, 0x00, 0x8b, 0x04, 0x60, 0x00, 0x69, 0x04, 0xa6, 0x00, 0x5b, 0x05, 0xb4, 0x00, + 0x69, 0x04, 0x33, 0x00, 0x0f, 0x01, 0xeb, 0x00, 0x93, 0x04, 0xe8, 0x00, 0x5a, 0x03, 0x58, 0x00, 0x65, 0x06, 0x49, + 0x00, 0x5b, 0x03, 0x93, 0x00, 0x93, 0x03, 0xc1, 0x00, 0x66, 0x04, 0x6e, 0x00, 0x7f, 0x06, 0x4a, 0x00, 0x5a, 0x03, + 0xaa, 0x00, 0x8e, 0x02, 0xfd, 0x00, 0x82, 0x04, 0x46, 0x00, 0x61, 0x02, 0xef, 0x00, 0x42, 0x02, 0xef, 0x00, 0x3e, + 0x02, 0x82, 0x00, 0x7b, 0x04, 0x88, 0x00, 0x9a, 0x03, 0xe9, 0x00, 0x43, 0x02, 0x16, 0x00, 0x93, 0x01, 0xfb, 0x00, + 0x74, 0x02, 0xef, 0x00, 0x7a, 0x03, 0xa3, 0x00, 0x7a, 0x03, 0xc0, 0x00, 0x66, 0x05, 0xdc, 0x00, 0x55, 0x06, 0x35, + 0x00, 0x50, 0x06, 0x39, 0x00, 0x6f, 0x03, 0xc9, 0x00, 0x44, 0x07, 0x7a, 0xff, 0xf2, 0x04, 0x44, 0x00, 0x59, 0x05, + 0x80, 0x00, 0x76, 0x04, 0xba, 0x00, 0xa6, 0x04, 0xc2, 0x00, 0x8b, 0x06, 0xc1, 0x00, 0x4e, 0x04, 0xb0, 0x00, 0x7e, + 0x04, 0x91, 0x00, 0x47, 0x04, 0x88, 0x00, 0x5b, 0x04, 0x9c, 0x00, 0x95, 0x04, 0xc7, 0x00, 0x5f, 0x05, 0x9a, 0x00, + 0x1d, 0x01, 0xfa, 0x00, 0x9b, 0x04, 0x73, 0x00, 0x9a, 0x04, 0x4f, 0x00, 0x22, 0x02, 0x29, 0x00, 0x22, 0x05, 0x8b, + 0x00, 0xa2, 0x04, 0x88, 0x00, 0x91, 0x07, 0xa1, 0x00, 0x68, 0x07, 0x44, 0x00, 0x61, 0x01, 0xfc, 0x00, 0xa0, 0x05, + 0x87, 0x00, 0x5d, 0x02, 0xb9, 0xff, 0xe4, 0x05, 0x7e, 0x00, 0x65, 0x04, 0x92, 0x00, 0x5b, 0x05, 0x90, 0x00, 0x8c, + 0x04, 0xf3, 0x00, 0x88, 0x02, 0x03, 0xff, 0xb4, 0x04, 0x37, 0x00, 0x62, 0x03, 0xc4, 0x00, 0xa9, 0x03, 0x8d, 0x00, + 0x8d, 0x03, 0xab, 0x00, 0x8e, 0x03, 0x6a, 0x00, 0x81, 0x01, 0xf1, 0x00, 0x8d, 0x02, 0xad, 0x00, 0x79, 0x02, 0x2a, + 0x00, 0x32, 0x03, 0xc6, 0x00, 0x7b, 0x02, 0xfc, 0x00, 0x5e, 0x02, 0x5a, 0x00, 0x7e, 0x00, 0x00, 0xfc, 0xa7, 0x00, + 0x00, 0xfd, 0x6f, 0x00, 0x00, 0xfc, 0x8b, 0x00, 0x00, 0xfd, 0x5e, 0x00, 0x00, 0xfc, 0x27, 0x00, 0x00, 0xfd, 0x38, + 0x02, 0x0d, 0x00, 0xb7, 0x04, 0x0b, 0x00, 0x71, 0x02, 0x17, 0x00, 0x93, 0x04, 0x73, 0x00, 0xb1, 0x05, 0xa4, 0x00, + 0x1f, 0x05, 0x71, 0x00, 0x67, 0x05, 0x3e, 0x00, 0x32, 0x04, 0x91, 0x00, 0x78, 0x05, 0xb5, 0x00, 0xb2, 0x04, 0x91, + 0x00, 0x45, 0x05, 0xbb, 0x00, 0x4d, 0x05, 0x89, 0x00, 0x5a, 0x05, 0x52, 0x00, 0x71, 0x04, 0x85, 0x00, 0x64, 0x04, + 0xbd, 0x00, 0xa0, 0x04, 0x02, 0x00, 0x2e, 0x04, 0x88, 0x00, 0x60, 0x04, 0x50, 0x00, 0x63, 0x04, 0x25, 0x00, 0x6d, + 0x04, 0x88, 0x00, 0x91, 0x04, 0x8e, 0x00, 0x7a, 0x02, 0x97, 0x00, 0xc3, 0x04, 0x6e, 0x00, 0x25, 0x03, 0xec, 0x00, + 0x65, 0x04, 0xc4, 0x00, 0x29, 0x04, 0x88, 0x00, 0x91, 0x04, 0x4d, 0x00, 0x65, 0x04, 0x88, 0x00, 0x60, 0x04, 0x2c, + 0x00, 0x51, 0x04, 0x5d, 0x00, 0x8f, 0x05, 0xa3, 0x00, 0x57, 0x05, 0x9a, 0x00, 0x5f, 0x06, 0x97, 0x00, 0x7a, 0x04, + 0xa1, 0x00, 0x79, 0x04, 0x42, 0xff, 0xda, 0x06, 0x48, 0x00, 0x4a, 0x05, 0xff, 0x00, 0x2a, 0x05, 0x64, 0x00, 0x7b, + 0x08, 0x91, 0x00, 0x31, 0x08, 0xa4, 0x00, 0xb1, 0x06, 0x82, 0x00, 0x3e, 0x05, 0xb4, 0x00, 0xb0, 0x05, 0x0b, 0x00, + 0xa2, 0x06, 0x04, 0x00, 0x32, 0x07, 0x43, 0x00, 0x1b, 0x04, 0xbf, 0x00, 0x50, 0x05, 0xb4, 0x00, 0xb1, 0x05, 0xa9, + 0x00, 0x2f, 0x05, 0x07, 0x00, 0x4d, 0x06, 0x2c, 0x00, 0x53, 0x05, 0xd9, 0x00, 0xaf, 0x05, 0x7a, 0x00, 0x96, 0x07, + 0x87, 0x00, 0xb0, 0x07, 0xc0, 0x00, 0xb0, 0x06, 0x12, 0x00, 0x10, 0x06, 0xeb, 0x00, 0xb2, 0x05, 0x05, 0x00, 0xa3, + 0x05, 0x64, 0x00, 0x93, 0x07, 0x27, 0x00, 0xb7, 0x05, 0x18, 0x00, 0x59, 0x04, 0x6c, 0x00, 0x61, 0x04, 0x92, 0x00, + 0x9d, 0x03, 0x5b, 0x00, 0x9a, 0x04, 0xd4, 0x00, 0x2e, 0x06, 0x20, 0x00, 0x15, 0x04, 0x10, 0x00, 0x58, 0x04, 0x9e, + 0x00, 0x9c, 0x04, 0x52, 0x00, 0x9c, 0x04, 0xa0, 0x00, 0x2c, 0x05, 0xef, 0x00, 0x9d, 0x04, 0x9d, 0x00, 0x9c, 0x04, + 0x9e, 0x00, 0x9c, 0x03, 0xd8, 0x00, 0x28, 0x05, 0xcd, 0x00, 0x64, 0x04, 0xbd, 0x00, 0x9c, 0x04, 0x59, 0x00, 0x67, + 0x06, 0x78, 0x00, 0x9c, 0x06, 0x9e, 0x00, 0x91, 0x04, 0xf7, 0x00, 0x1e, 0x06, 0x36, 0x00, 0x9d, 0x04, 0x58, 0x00, + 0x9d, 0x04, 0x4d, 0x00, 0x64, 0x06, 0x87, 0x00, 0x9d, 0x04, 0x64, 0x00, 0x2f, 0x04, 0x68, 0xff, 0xe8, 0x04, 0x4d, + 0x00, 0x67, 0x06, 0xc9, 0x00, 0x27, 0x06, 0xe4, 0x00, 0x9c, 0x04, 0x89, 0xff, 0xfd, 0x04, 0x9e, 0x00, 0x9c, 0x07, + 0x08, 0x00, 0x9c, 0x06, 0x2b, 0x00, 0x81, 0x04, 0x56, 0xff, 0xdc, 0x07, 0x2b, 0x00, 0xb7, 0x05, 0xf8, 0x00, 0x99, + 0x04, 0xd2, 0x00, 0x28, 0x04, 0x46, 0x00, 0x0f, 0x07, 0x0b, 0x00, 0xc9, 0x06, 0x0b, 0x00, 0xbc, 0x06, 0xd1, 0x00, + 0x93, 0x05, 0xe1, 0x00, 0x96, 0x09, 0x04, 0x00, 0xb6, 0x07, 0xd1, 0x00, 0x9b, 0x04, 0x23, 0x00, 0x50, 0x03, 0xdb, + 0x00, 0x4c, 0x05, 0x71, 0x00, 0x67, 0x04, 0x8b, 0x00, 0x5b, 0x05, 0x0a, 0x00, 0x16, 0x04, 0x03, 0x00, 0x2e, 0x05, + 0x71, 0x00, 0x67, 0x04, 0x88, 0x00, 0x5b, 0x07, 0x01, 0x00, 0x9c, 0x06, 0x24, 0x00, 0x7e, 0x07, 0x08, 0x00, 0x9c, + 0x06, 0x2b, 0x00, 0x81, 0x05, 0x32, 0x00, 0x75, 0x04, 0x47, 0x00, 0x64, 0x04, 0xfd, 0x00, 0x74, 0x00, 0x00, 0xfc, + 0x67, 0x00, 0x00, 0xfc, 0x71, 0x00, 0x00, 0xfd, 0x66, 0x00, 0x00, 0xfd, 0xa4, 0x00, 0x00, 0xfa, 0x1b, 0x00, 0x00, + 0xfa, 0x2c, 0x06, 0x09, 0x00, 0xb1, 0x04, 0xed, 0x00, 0x9c, 0x04, 0x56, 0xff, 0xdc, 0x05, 0x1b, 0x00, 0xa8, 0x04, + 0x89, 0x00, 0x8c, 0x04, 0x63, 0x00, 0xa2, 0x03, 0x90, 0x00, 0x91, 0x04, 0xdb, 0x00, 0xb1, 0x04, 0x05, 0x00, 0x91, + 0x07, 0xa2, 0x00, 0x1b, 0x06, 0x61, 0x00, 0x15, 0x05, 0x9a, 0x00, 0xb2, 0x04, 0xb8, 0x00, 0x9c, 0x05, 0x09, 0x00, + 0xa3, 0x04, 0x7e, 0x00, 0x9a, 0x06, 0x8c, 0x00, 0x44, 0x05, 0x83, 0x00, 0x3e, 0x05, 0xff, 0x00, 0xa9, 0x04, 0xd9, + 0x00, 0x9c, 0x07, 0xcf, 0x00, 0xa8, 0x05, 0xb4, 0x00, 0x91, 0x08, 0x31, 0x00, 0xb0, 0x06, 0xf4, 0x00, 0x91, 0x05, + 0xee, 0x00, 0x71, 0x04, 0xd3, 0x00, 0x6d, 0x05, 0x18, 0x00, 0x39, 0x04, 0x2a, 0x00, 0x29, 0x07, 0x2c, 0x00, 0x34, + 0x05, 0x5c, 0x00, 0x1f, 0x05, 0xbc, 0x00, 0x96, 0x04, 0x96, 0x00, 0x67, 0x05, 0x6f, 0x00, 0x96, 0x04, 0x6a, 0x00, + 0x83, 0x05, 0x6f, 0x00, 0x89, 0x06, 0x2f, 0x00, 0x3f, 0x04, 0xbd, 0xff, 0xde, 0x05, 0x09, 0x00, 0xa3, 0x04, 0x5a, + 0x00, 0x9a, 0x05, 0xfe, 0x00, 0x2f, 0x04, 0xef, 0x00, 0x2c, 0x05, 0xb2, 0x00, 0xb1, 0x04, 0x88, 0x00, 0x91, 0x06, + 0x12, 0x00, 0xa9, 0x04, 0xec, 0x00, 0x9c, 0x07, 0x4f, 0x00, 0xa9, 0x06, 0x3e, 0x00, 0x9d, 0x05, 0x87, 0x00, 0x5d, + 0x04, 0xa8, 0x00, 0x68, 0x04, 0xa8, 0x00, 0x69, 0x04, 0xb7, 0x00, 0x3a, 0x03, 0xab, 0x00, 0x3b, 0x05, 0x2e, 0x00, + 0x39, 0x04, 0x40, 0x00, 0x29, 0x04, 0xf6, 0x00, 0x57, 0x06, 0x94, 0x00, 0x59, 0x06, 0xe4, 0x00, 0x64, 0x06, 0x56, + 0x00, 0x36, 0x05, 0x2b, 0x00, 0x31, 0x04, 0x49, 0x00, 0x52, 0x04, 0x07, 0x00, 0x79, 0x07, 0xc1, 0x00, 0x44, 0x06, + 0x75, 0x00, 0x3f, 0x07, 0xfb, 0x00, 0xa9, 0x06, 0xa1, 0x00, 0x90, 0x04, 0xf6, 0x00, 0x76, 0x04, 0x1d, 0x00, 0x65, + 0x05, 0xad, 0x00, 0x23, 0x05, 0x20, 0x00, 0x46, 0x05, 0x64, 0x00, 0x96, 0x06, 0x02, 0x00, 0x2f, 0x04, 0xf2, 0x00, + 0x2c, 0x03, 0x20, 0x00, 0x6f, 0x04, 0x14, 0x00, 0x00, 0x08, 0x29, 0x00, 0x00, 0x04, 0x14, 0x00, 0x00, 0x08, 0x29, + 0x00, 0x00, 0x02, 0xb9, 0x00, 0x00, 0x02, 0x0a, 0x00, 0x00, 0x01, 0x5c, 0x00, 0x00, 0x04, 0x7f, 0x00, 0x00, 0x02, + 0x30, 0x00, 0x00, 0x01, 0xa2, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x02, 0x34, 0x00, 0x25, 0x02, 0x34, 0x00, 0x25, 0x05, 0x40, 0x00, 0xa2, 0x06, 0x3f, 0x00, 0x90, 0x03, 0xa5, 0x00, + 0x0d, 0x01, 0x99, 0x00, 0x60, 0x01, 0x99, 0x00, 0x30, 0x01, 0x97, 0x00, 0x24, 0x01, 0x99, 0x00, 0x4f, 0x02, 0xd4, + 0x00, 0x68, 0x02, 0xdb, 0x00, 0x3c, 0x02, 0xc1, 0x00, 0x24, 0x04, 0x69, 0x00, 0x46, 0x04, 0x8f, 0x00, 0x57, 0x02, + 0xb2, 0x00, 0x8a, 0x03, 0xc4, 0x00, 0x94, 0x05, 0x5a, 0x00, 0x94, 0x01, 0x7e, 0x00, 0x52, 0x07, 0xaa, 0x00, 0x44, + 0x02, 0x66, 0x00, 0x6c, 0x02, 0x66, 0x00, 0x59, 0x03, 0xa3, 0x00, 0x3b, 0x02, 0xef, 0x00, 0x36, 0x03, 0x60, 0x00, + 0x7a, 0x04, 0xa6, 0x00, 0x5b, 0x06, 0x55, 0x00, 0x1f, 0x06, 0x90, 0x00, 0xa7, 0x08, 0x76, 0x00, 0xa8, 0x05, 0xeb, + 0x00, 0x1f, 0x06, 0x2b, 0x00, 0x8c, 0x04, 0x7e, 0x00, 0x5f, 0x05, 0xda, 0x00, 0x1f, 0x04, 0x22, 0x00, 0x2a, 0x04, + 0x74, 0x00, 0x20, 0x05, 0x48, 0x00, 0x5d, 0x05, 0x4f, 0x00, 0x1f, 0x05, 0xe7, 0x00, 0x7a, 0x03, 0xce, 0x00, 0x68, + 0x08, 0x3a, 0x00, 0xa2, 0x05, 0x01, 0x00, 0x67, 0x05, 0x17, 0x00, 0x98, 0x06, 0x26, 0x00, 0x54, 0x06, 0xd7, 0x00, + 0x64, 0x06, 0xcf, 0x00, 0x63, 0x06, 0x6a, 0x00, 0x59, 0x04, 0x8f, 0x00, 0x6a, 0x05, 0x8e, 0x00, 0xa9, 0x04, 0xaf, + 0x00, 0x45, 0x04, 0x92, 0x00, 0xa8, 0x04, 0xc5, 0x00, 0x3f, 0x08, 0x3a, 0x00, 0x62, 0x02, 0x0c, 0xff, 0xb0, 0x04, + 0x82, 0x00, 0x65, 0x04, 0x64, 0x00, 0x98, 0x04, 0x11, 0x00, 0x3e, 0x04, 0x2f, 0x00, 0x85, 0x04, 0x08, 0x00, 0x2b, + 0x02, 0x4c, 0x00, 0xb5, 0x02, 0x8f, 0x00, 0x6e, 0x02, 0x03, 0x00, 0x5c, 0x04, 0xf3, 0x00, 0x3c, 0x04, 0x6e, 0x00, + 0x1f, 0x04, 0x8b, 0x00, 0x3c, 0x06, 0xd4, 0x00, 0x3c, 0x06, 0xd4, 0x00, 0x3c, 0x04, 0xee, 0x00, 0x3c, 0x06, 0x9b, + 0x00, 0x5f, 0x00, 0x00, 0x00, 0x00, 0x08, 0x33, 0x00, 0x5b, 0x08, 0x35, 0x00, 0x5c, 0x02, 0xef, 0x00, 0x42, 0x02, + 0xef, 0x00, 0x7a, 0x02, 0xef, 0x00, 0x50, 0x04, 0x0f, 0x00, 0x55, 0x04, 0x0f, 0x00, 0x60, 0x04, 0x0f, 0x00, 0x42, + 0x04, 0x0e, 0x00, 0x72, 0x04, 0x0f, 0x00, 0x80, 0x04, 0x0f, 0x00, 0x30, 0x04, 0x0f, 0x00, 0x4e, 0x04, 0x0f, 0x00, + 0x4e, 0x04, 0x0f, 0x00, 0x98, 0x04, 0x0f, 0x00, 0x63, 0x04, 0x23, 0x00, 0x47, 0x04, 0x2b, 0x00, 0x0d, 0x04, 0x54, + 0x00, 0x26, 0x06, 0x15, 0x00, 0x31, 0x04, 0x67, 0x00, 0x14, 0x04, 0x7c, 0x00, 0x74, 0x04, 0x26, 0x00, 0x28, 0x04, + 0x20, 0x00, 0x43, 0x04, 0x4a, 0x00, 0x8a, 0x04, 0xbb, 0x00, 0x59, 0x04, 0x5c, 0x00, 0x8a, 0x04, 0xbb, 0x00, 0x60, + 0x04, 0xe3, 0x00, 0x8a, 0x06, 0x02, 0x00, 0x8a, 0x03, 0xb4, 0x00, 0x8a, 0x04, 0x54, 0x00, 0x8a, 0x03, 0xcf, 0x00, + 0x2b, 0x01, 0xe8, 0x00, 0x97, 0x04, 0xe3, 0x00, 0x8a, 0x04, 0xac, 0x00, 0x63, 0x03, 0xcb, 0x00, 0x8a, 0x04, 0x20, + 0x00, 0x43, 0x04, 0x33, 0x00, 0x30, 0x03, 0xa1, 0x00, 0x0d, 0x03, 0xaf, 0x00, 0x8a, 0x04, 0x67, 0x00, 0x14, 0x04, + 0xbb, 0x00, 0x60, 0x04, 0x67, 0x00, 0x14, 0x03, 0x89, 0x00, 0x3e, 0x04, 0xce, 0x00, 0x8a, 0x03, 0xef, 0x00, 0x3f, + 0x05, 0x67, 0x00, 0x60, 0x05, 0x17, 0x00, 0x60, 0x04, 0xf2, 0x00, 0x75, 0x05, 0x72, 0x00, 0x26, 0x04, 0x7c, 0x00, + 0x60, 0x07, 0x41, 0x00, 0x27, 0x07, 0x4f, 0x00, 0x8a, 0x05, 0x74, 0x00, 0x28, 0x04, 0xcd, 0x00, 0x8a, 0x04, 0x59, + 0x00, 0x8a, 0x05, 0x24, 0x00, 0x2e, 0x06, 0x0b, 0x00, 0x1f, 0x04, 0x3f, 0x00, 0x47, 0x04, 0xec, 0x00, 0x8a, 0x04, + 0x4e, 0x00, 0x8b, 0x04, 0xc1, 0x00, 0x27, 0x04, 0x1f, 0x00, 0x22, 0x05, 0x28, 0x00, 0x8a, 0x04, 0x6a, 0x00, 0x3d, + 0x06, 0x51, 0x00, 0x8a, 0x06, 0xac, 0x00, 0x8a, 0x05, 0x1d, 0x00, 0x08, 0x05, 0xf1, 0x00, 0x8a, 0x04, 0x4e, 0x00, + 0x8a, 0x04, 0x7b, 0x00, 0x4b, 0x06, 0x76, 0x00, 0x8a, 0x04, 0x87, 0x00, 0x50, 0x04, 0x11, 0x00, 0x0b, 0x06, 0x47, + 0x00, 0x1f, 0x04, 0x79, 0x00, 0x8b, 0x05, 0x09, 0x00, 0x8b, 0x05, 0x37, 0x00, 0x23, 0x05, 0xc2, 0x00, 0x60, 0x04, + 0x5f, 0x00, 0x0d, 0x04, 0xa8, 0x00, 0x26, 0x06, 0x61, 0x00, 0x26, 0x04, 0x6a, 0x00, 0x3d, 0x04, 0x6a, 0x00, 0x8a, + 0x05, 0xc3, 0x00, 0x02, 0x04, 0xca, 0x00, 0x5e, 0x04, 0x3f, 0x00, 0x47, 0x04, 0xbb, 0x00, 0x60, 0x04, 0x33, 0x00, + 0x30, 0x03, 0xe3, 0x00, 0x42, 0x08, 0x22, 0x00, 0x8a, 0x04, 0xab, 0x00, 0x28, 0x02, 0xef, 0x00, 0x3e, 0x02, 0xef, + 0x00, 0x36, 0x02, 0xef, 0x00, 0x5b, 0x02, 0xef, 0x00, 0x56, 0x02, 0xef, 0x00, 0x3a, 0x02, 0xef, 0x00, 0x4f, 0x02, + 0xef, 0x00, 0x49, 0x03, 0x96, 0x00, 0x8f, 0x02, 0xb5, 0x00, 0x9e, 0x03, 0xe6, 0x00, 0x8a, 0x04, 0x3a, 0x00, 0x1e, + 0x04, 0xc3, 0x00, 0x64, 0x05, 0x4c, 0x00, 0xb1, 0x05, 0x24, 0x00, 0xb2, 0x04, 0x13, 0x00, 0x92, 0x05, 0x3d, 0x00, + 0xb2, 0x04, 0x0f, 0x00, 0x92, 0x04, 0x80, 0x00, 0x8a, 0x04, 0x7c, 0x00, 0x60, 0x04, 0x50, 0x00, 0x8a, 0x04, 0x85, + 0x00, 0x13, 0x01, 0xfd, 0x00, 0x9f, 0x03, 0xa4, 0x00, 0x81, 0x00, 0x00, 0xfc, 0xa4, 0x03, 0xef, 0x00, 0x6e, 0x03, + 0xf3, 0xff, 0x5e, 0x04, 0x0e, 0x00, 0x69, 0x03, 0xf4, 0x00, 0x69, 0x03, 0xaf, 0x00, 0x8a, 0x03, 0x9f, 0x00, 0x81, + 0x03, 0x9e, 0x00, 0x81, 0x02, 0xef, 0x00, 0x50, 0x02, 0xef, 0x00, 0x36, 0x02, 0xef, 0x00, 0x5b, 0x02, 0xef, 0x00, + 0x56, 0x02, 0xef, 0x00, 0x3a, 0x02, 0xef, 0x00, 0x4f, 0x02, 0xef, 0x00, 0x49, 0x05, 0x81, 0x00, 0x7e, 0x05, 0xae, + 0x00, 0x7e, 0x05, 0x93, 0x00, 0xb2, 0x05, 0xe0, 0x00, 0x7e, 0x05, 0xe3, 0x00, 0x7e, 0x03, 0xd5, 0x00, 0xa0, 0x04, + 0x82, 0x00, 0x83, 0x04, 0x58, 0x00, 0x0f, 0x04, 0xcf, 0x00, 0x3e, 0x04, 0x6b, 0x00, 0x65, 0x04, 0x2e, 0x00, 0x4a, + 0x03, 0xa4, 0x00, 0x83, 0x01, 0x91, 0x00, 0x67, 0x06, 0xa4, 0x00, 0x60, 0x04, 0xb9, 0x00, 0x82, 0x01, 0xfc, 0xff, + 0xb6, 0x04, 0x7f, 0x00, 0x3b, 0x04, 0x7f, 0x00, 0x73, 0x04, 0x7f, 0x00, 0x23, 0x04, 0x7f, 0x00, 0x77, 0x04, 0x7f, + 0x00, 0x76, 0x04, 0x7f, 0x00, 0x37, 0x04, 0x7f, 0x00, 0x7e, 0x04, 0x7f, 0x00, 0x5f, 0x04, 0x7f, 0x00, 0x70, 0x04, + 0x7f, 0x00, 0xf4, 0x02, 0x06, 0xff, 0xb4, 0x02, 0x04, 0xff, 0xb4, 0x01, 0xfb, 0x00, 0x9b, 0x01, 0xfb, 0xff, 0xfa, + 0x01, 0xfb, 0x00, 0x9b, 0x04, 0x50, 0x00, 0x8a, 0x05, 0x00, 0x00, 0x78, 0x04, 0x20, 0x00, 0x3b, 0x04, 0x7d, 0x00, + 0x8c, 0x04, 0x32, 0x00, 0x5c, 0x04, 0x93, 0x00, 0x5b, 0x04, 0x8c, 0x00, 0x5b, 0x04, 0x9e, 0x00, 0x5a, 0x04, 0x8d, + 0x00, 0x8c, 0x04, 0x9c, 0x00, 0x5b, 0x04, 0x3d, 0x00, 0x5d, 0x04, 0x7d, 0x00, 0x60, 0x03, 0x79, 0x00, 0x57, 0x04, + 0xd6, 0x00, 0x67, 0x03, 0xb4, 0x00, 0x00, 0x06, 0x39, 0x00, 0x09, 0x03, 0xf8, 0x00, 0x8a, 0x04, 0xbb, 0x00, 0x60, + 0x04, 0xe3, 0x00, 0x30, 0x04, 0xe3, 0x00, 0x8a, 0x01, 0xfb, 0x00, 0x00, 0x02, 0x35, 0x00, 0x25, 0x05, 0x5d, 0x00, + 0x07, 0x05, 0x5d, 0x00, 0x07, 0x04, 0x86, 0xff, 0xe2, 0x04, 0xc6, 0x00, 0x31, 0x02, 0x9d, 0xff, 0xf4, 0x05, 0x38, + 0x00, 0x1c, 0x05, 0x38, 0x00, 0x1c, 0x05, 0x38, 0x00, 0x1c, 0x05, 0x38, 0x00, 0x1c, 0x05, 0x38, 0x00, 0x1c, 0x05, + 0x38, 0x00, 0x1c, 0x05, 0x38, 0x00, 0x1c, 0x05, 0x35, 0x00, 0x77, 0x04, 0x8c, 0x00, 0xa9, 0x04, 0x8c, 0x00, 0xa9, + 0x04, 0x8c, 0x00, 0xa9, 0x04, 0x8c, 0x00, 0xa9, 0x02, 0x2d, 0xff, 0xe0, 0x02, 0x2d, 0x00, 0xb0, 0x02, 0x2d, 0xff, + 0xe9, 0x02, 0x2d, 0xff, 0xd5, 0x05, 0xb4, 0x00, 0xa9, 0x05, 0x80, 0x00, 0x76, 0x05, 0x80, 0x00, 0x76, 0x05, 0x80, + 0x00, 0x76, 0x05, 0x80, 0x00, 0x76, 0x05, 0x80, 0x00, 0x76, 0x05, 0x30, 0x00, 0x8c, 0x05, 0x30, 0x00, 0x8c, 0x05, + 0x30, 0x00, 0x8c, 0x05, 0x30, 0x00, 0x8c, 0x04, 0xce, 0x00, 0x0f, 0x04, 0x5a, 0x00, 0x6d, 0x04, 0x5a, 0x00, 0x6d, + 0x04, 0x5a, 0x00, 0x6d, 0x04, 0x5a, 0x00, 0x6d, 0x04, 0x5a, 0x00, 0x6d, 0x04, 0x5a, 0x00, 0x6d, 0x04, 0x5a, 0x00, + 0x6d, 0x04, 0x30, 0x00, 0x5c, 0x04, 0x3d, 0x00, 0x5d, 0x04, 0x3d, 0x00, 0x5d, 0x04, 0x3d, 0x00, 0x5d, 0x04, 0x3d, + 0x00, 0x5d, 0x01, 0xfa, 0xff, 0xc6, 0x01, 0xfa, 0x00, 0x96, 0x01, 0xfa, 0xff, 0xcf, 0x01, 0xfa, 0xff, 0xbb, 0x04, + 0x6a, 0x00, 0x8c, 0x04, 0x90, 0x00, 0x5b, 0x04, 0x90, 0x00, 0x5b, 0x04, 0x90, 0x00, 0x5b, 0x04, 0x90, 0x00, 0x5b, + 0x04, 0x90, 0x00, 0x5b, 0x04, 0x69, 0x00, 0x88, 0x04, 0x69, 0x00, 0x88, 0x04, 0x69, 0x00, 0x88, 0x04, 0x69, 0x00, + 0x88, 0x03, 0xc9, 0x00, 0x16, 0x03, 0xc9, 0x00, 0x16, 0x05, 0x38, 0x00, 0x1c, 0x04, 0x5a, 0x00, 0x6d, 0x05, 0x38, + 0x00, 0x1c, 0x04, 0x5a, 0x00, 0x6d, 0x05, 0x38, 0x00, 0x1c, 0x04, 0x5a, 0x00, 0x6d, 0x05, 0x35, 0x00, 0x77, 0x04, + 0x30, 0x00, 0x5c, 0x05, 0x35, 0x00, 0x77, 0x04, 0x30, 0x00, 0x5c, 0x05, 0x35, 0x00, 0x77, 0x04, 0x30, 0x00, 0x5c, + 0x05, 0x35, 0x00, 0x77, 0x04, 0x30, 0x00, 0x5c, 0x05, 0x3f, 0x00, 0xa9, 0x05, 0x19, 0x00, 0x5f, 0x04, 0x8c, 0x00, + 0xa9, 0x04, 0x3d, 0x00, 0x5d, 0x04, 0x8c, 0x00, 0xa9, 0x04, 0x3d, 0x00, 0x5d, 0x04, 0x8c, 0x00, 0xa9, 0x04, 0x3d, + 0x00, 0x5d, 0x04, 0x8c, 0x00, 0xa9, 0x04, 0x3d, 0x00, 0x5d, 0x04, 0x8c, 0x00, 0xa9, 0x04, 0x3d, 0x00, 0x5d, 0x05, + 0x73, 0x00, 0x7a, 0x04, 0x7d, 0x00, 0x60, 0x05, 0x73, 0x00, 0x7a, 0x04, 0x7d, 0x00, 0x60, 0x05, 0x73, 0x00, 0x7a, + 0x04, 0x7d, 0x00, 0x60, 0x05, 0x73, 0x00, 0x7a, 0x04, 0x7d, 0x00, 0x60, 0x05, 0xb4, 0x00, 0xa9, 0x04, 0x68, 0x00, + 0x8c, 0x02, 0x2d, 0xff, 0xb7, 0x01, 0xfa, 0xff, 0x9d, 0x02, 0x2d, 0xff, 0xcc, 0x01, 0xfa, 0xff, 0xb2, 0x02, 0x2d, + 0xff, 0xec, 0x01, 0xfa, 0xff, 0xd2, 0x02, 0x2d, 0x00, 0x18, 0x01, 0xf1, 0xff, 0xfb, 0x02, 0x2d, 0x00, 0xa9, 0x06, + 0x97, 0x00, 0xb7, 0x03, 0xda, 0x00, 0x8d, 0x04, 0x6a, 0x00, 0x35, 0x02, 0x03, 0xff, 0xb4, 0x05, 0x04, 0x00, 0xa9, + 0x04, 0x0e, 0x00, 0x8d, 0x04, 0x4e, 0x00, 0xa1, 0x01, 0xf1, 0x00, 0x93, 0x04, 0x4e, 0x00, 0xa9, 0x01, 0xf1, 0x00, + 0x57, 0x04, 0x4e, 0x00, 0xa9, 0x02, 0x87, 0x00, 0x9c, 0x04, 0x4e, 0x00, 0xa9, 0x02, 0xcd, 0x00, 0x9c, 0x05, 0xb4, + 0x00, 0xa9, 0x04, 0x6a, 0x00, 0x8c, 0x05, 0xb4, 0x00, 0xa9, 0x04, 0x6a, 0x00, 0x8c, 0x05, 0xb4, 0x00, 0xa9, 0x04, + 0x6a, 0x00, 0x8c, 0x04, 0x6a, 0xff, 0xbc, 0x05, 0x80, 0x00, 0x76, 0x04, 0x90, 0x00, 0x5b, 0x05, 0x80, 0x00, 0x76, + 0x04, 0x90, 0x00, 0x5b, 0x05, 0x80, 0x00, 0x76, 0x04, 0x90, 0x00, 0x5b, 0x04, 0xed, 0x00, 0xa8, 0x02, 0xb5, 0x00, + 0x8c, 0x04, 0xed, 0x00, 0xa8, 0x02, 0xb5, 0x00, 0x53, 0x04, 0xed, 0x00, 0xa8, 0x02, 0xb5, 0x00, 0x63, 0x04, 0xbf, + 0x00, 0x50, 0x04, 0x20, 0x00, 0x5f, 0x04, 0xbf, 0x00, 0x50, 0x04, 0x20, 0x00, 0x5f, 0x04, 0xbf, 0x00, 0x50, 0x04, + 0x20, 0x00, 0x5f, 0x04, 0xbf, 0x00, 0x50, 0x04, 0x20, 0x00, 0x5f, 0x04, 0xbf, 0x00, 0x50, 0x04, 0x20, 0x00, 0x5f, + 0x04, 0xc6, 0x00, 0x31, 0x02, 0x9d, 0x00, 0x09, 0x04, 0xc6, 0x00, 0x31, 0x02, 0x9d, 0x00, 0x09, 0x04, 0xc6, 0x00, + 0x31, 0x02, 0xc5, 0x00, 0x09, 0x05, 0x30, 0x00, 0x8c, 0x04, 0x69, 0x00, 0x88, 0x05, 0x30, 0x00, 0x8c, 0x04, 0x69, + 0x00, 0x88, 0x05, 0x30, 0x00, 0x8c, 0x04, 0x69, 0x00, 0x88, 0x05, 0x30, 0x00, 0x8c, 0x04, 0x69, 0x00, 0x88, 0x05, + 0x30, 0x00, 0x8c, 0x04, 0x69, 0x00, 0x88, 0x05, 0x30, 0x00, 0x8c, 0x04, 0x69, 0x00, 0x88, 0x07, 0x19, 0x00, 0x3d, + 0x06, 0x03, 0x00, 0x2b, 0x04, 0xce, 0x00, 0x0f, 0x03, 0xc9, 0x00, 0x16, 0x04, 0xce, 0x00, 0x0f, 0x04, 0xca, 0x00, + 0x56, 0x03, 0xf7, 0x00, 0x58, 0x04, 0xca, 0x00, 0x56, 0x03, 0xf7, 0x00, 0x58, 0x04, 0xca, 0x00, 0x56, 0x03, 0xf7, + 0x00, 0x58, 0x07, 0x7a, 0xff, 0xf2, 0x06, 0xc1, 0x00, 0x4e, 0x05, 0x80, 0x00, 0x76, 0x04, 0x88, 0x00, 0x5b, 0x04, + 0x80, 0xff, 0xbe, 0x04, 0x80, 0xff, 0xbe, 0x04, 0x26, 0x00, 0x28, 0x04, 0x85, 0x00, 0x13, 0x04, 0x85, 0x00, 0x13, + 0x04, 0x85, 0x00, 0x13, 0x04, 0x85, 0x00, 0x13, 0x04, 0x85, 0x00, 0x13, 0x04, 0x85, 0x00, 0x13, 0x04, 0x85, 0x00, + 0x13, 0x04, 0x7c, 0x00, 0x60, 0x03, 0xe6, 0x00, 0x8a, 0x03, 0xe6, 0x00, 0x8a, 0x03, 0xe6, 0x00, 0x8a, 0x03, 0xe6, + 0x00, 0x8a, 0x01, 0xe8, 0xff, 0xbe, 0x01, 0xe8, 0x00, 0x8e, 0x01, 0xe8, 0xff, 0xc7, 0x01, 0xe8, 0xff, 0xb3, 0x04, + 0xe3, 0x00, 0x8a, 0x04, 0xbb, 0x00, 0x60, 0x04, 0xbb, 0x00, 0x60, 0x04, 0xbb, 0x00, 0x60, 0x04, 0xbb, 0x00, 0x60, + 0x04, 0xbb, 0x00, 0x60, 0x04, 0x7c, 0x00, 0x74, 0x04, 0x7c, 0x00, 0x74, 0x04, 0x7c, 0x00, 0x74, 0x04, 0x7c, 0x00, + 0x74, 0x04, 0x2b, 0x00, 0x0d, 0x04, 0x85, 0x00, 0x13, 0x04, 0x85, 0x00, 0x13, 0x04, 0x85, 0x00, 0x13, 0x04, 0x7c, + 0x00, 0x60, 0x04, 0x7c, 0x00, 0x60, 0x04, 0x7c, 0x00, 0x60, 0x04, 0x7c, 0x00, 0x60, 0x04, 0x80, 0x00, 0x8a, 0x03, + 0xe6, 0x00, 0x8a, 0x03, 0xe6, 0x00, 0x8a, 0x03, 0xe6, 0x00, 0x8a, 0x03, 0xe6, 0x00, 0x8a, 0x03, 0xe6, 0x00, 0x8a, + 0x04, 0xac, 0x00, 0x63, 0x04, 0xac, 0x00, 0x63, 0x04, 0xac, 0x00, 0x63, 0x04, 0xac, 0x00, 0x63, 0x04, 0xe3, 0x00, + 0x8a, 0x01, 0xe8, 0xff, 0x95, 0x01, 0xe8, 0xff, 0xaa, 0x01, 0xe8, 0xff, 0xca, 0x01, 0xe8, 0x00, 0x06, 0x01, 0xe8, + 0x00, 0x88, 0x03, 0xcf, 0x00, 0x2b, 0x04, 0x54, 0x00, 0x8a, 0x03, 0xb4, 0x00, 0x82, 0x03, 0xb4, 0x00, 0x8a, 0x03, + 0xb4, 0x00, 0x8a, 0x03, 0xb4, 0x00, 0x8a, 0x04, 0xe3, 0x00, 0x8a, 0x04, 0xe3, 0x00, 0x8a, 0x04, 0xe3, 0x00, 0x8a, + 0x04, 0xbb, 0x00, 0x60, 0x04, 0xbb, 0x00, 0x60, 0x04, 0xbb, 0x00, 0x60, 0x04, 0x4a, 0x00, 0x8a, 0x04, 0x4a, 0x00, + 0x8a, 0x04, 0x4a, 0x00, 0x8a, 0x04, 0x20, 0x00, 0x43, 0x04, 0x20, 0x00, 0x43, 0x04, 0x20, 0x00, 0x43, 0x04, 0x20, + 0x00, 0x43, 0x04, 0x26, 0x00, 0x28, 0x04, 0x26, 0x00, 0x28, 0x04, 0x26, 0x00, 0x28, 0x04, 0x7c, 0x00, 0x74, 0x04, + 0x7c, 0x00, 0x74, 0x04, 0x7c, 0x00, 0x74, 0x04, 0x7c, 0x00, 0x74, 0x04, 0x7c, 0x00, 0x74, 0x04, 0x7c, 0x00, 0x74, + 0x06, 0x15, 0x00, 0x31, 0x04, 0x2b, 0x00, 0x0d, 0x04, 0x2b, 0x00, 0x0d, 0x04, 0x23, 0x00, 0x47, 0x04, 0x23, 0x00, + 0x47, 0x04, 0x23, 0x00, 0x47, 0x05, 0x38, 0x00, 0x1c, 0x04, 0x8c, 0xff, 0x29, 0x05, 0xb4, 0xff, 0x37, 0x02, 0x2d, + 0xff, 0x3d, 0x05, 0x94, 0xff, 0xe6, 0x05, 0x32, 0xff, 0x14, 0x05, 0x66, 0xff, 0xe9, 0x02, 0x97, 0xff, 0x9b, 0x05, + 0x38, 0x00, 0x1c, 0x04, 0xfb, 0x00, 0xa9, 0x04, 0x8c, 0x00, 0xa9, 0x04, 0xca, 0x00, 0x56, 0x05, 0xb4, 0x00, 0xa9, + 0x02, 0x2d, 0x00, 0xb7, 0x05, 0x04, 0x00, 0xa9, 0x06, 0xfc, 0x00, 0xa9, 0x05, 0xb4, 0x00, 0xa9, 0x05, 0x80, 0x00, + 0x76, 0x05, 0x0c, 0x00, 0xa9, 0x04, 0xc6, 0x00, 0x31, 0x04, 0xce, 0x00, 0x0f, 0x05, 0x04, 0x00, 0x39, 0x02, 0x2d, + 0xff, 0xd5, 0x04, 0xce, 0x00, 0x0f, 0x04, 0x85, 0x00, 0x64, 0x04, 0x50, 0x00, 0x63, 0x04, 0x88, 0x00, 0x91, 0x02, + 0x97, 0x00, 0xc3, 0x04, 0x5d, 0x00, 0x8f, 0x04, 0x73, 0x00, 0x9a, 0x04, 0x90, 0x00, 0x5b, 0x04, 0x88, 0x00, 0x9a, + 0x03, 0xe0, 0x00, 0x21, 0x03, 0xf7, 0x00, 0x29, 0x02, 0x97, 0xff, 0xe5, 0x04, 0x5d, 0x00, 0x8f, 0x04, 0x90, 0x00, + 0x5b, 0x04, 0x5d, 0x00, 0x8f, 0x06, 0x97, 0x00, 0x7a, 0x04, 0x8c, 0x00, 0xa9, 0x04, 0x73, 0x00, 0xb1, 0x04, 0xbf, + 0x00, 0x50, 0x02, 0x2d, 0x00, 0xb7, 0x02, 0x2d, 0xff, 0xd5, 0x04, 0x6a, 0x00, 0x35, 0x05, 0x24, 0x00, 0xb2, 0x05, + 0x04, 0x00, 0xa9, 0x05, 0x07, 0x00, 0x4d, 0x05, 0x38, 0x00, 0x1c, 0x04, 0xfb, 0x00, 0xa9, 0x04, 0x73, 0x00, 0xb1, + 0x04, 0x8c, 0x00, 0xa9, 0x05, 0xb4, 0x00, 0xb1, 0x06, 0xfc, 0x00, 0xa9, 0x05, 0xb4, 0x00, 0xa9, 0x05, 0x80, 0x00, + 0x76, 0x05, 0xb5, 0x00, 0xb2, 0x05, 0x0c, 0x00, 0xa9, 0x05, 0x35, 0x00, 0x77, 0x04, 0xc6, 0x00, 0x31, 0x05, 0x04, + 0x00, 0x39, 0x04, 0x5a, 0x00, 0x6d, 0x04, 0x3d, 0x00, 0x5d, 0x04, 0x9e, 0x00, 0x9c, 0x04, 0x90, 0x00, 0x5b, 0x04, + 0x7d, 0x00, 0x8c, 0x04, 0x30, 0x00, 0x5c, 0x03, 0xc9, 0x00, 0x16, 0x03, 0xf7, 0x00, 0x29, 0x04, 0x3d, 0x00, 0x5d, + 0x03, 0x5b, 0x00, 0x9a, 0x04, 0x20, 0x00, 0x5f, 0x01, 0xf1, 0x00, 0x8d, 0x01, 0xfa, 0xff, 0xbb, 0x01, 0xe9, 0xff, + 0xbf, 0x04, 0x52, 0x00, 0x9c, 0x03, 0xc9, 0x00, 0x16, 0x07, 0x19, 0x00, 0x3d, 0x06, 0x03, 0x00, 0x2b, 0x07, 0x19, + 0x00, 0x3d, 0x06, 0x03, 0x00, 0x2b, 0x07, 0x19, 0x00, 0x3d, 0x06, 0x03, 0x00, 0x2b, 0x04, 0xce, 0x00, 0x0f, 0x03, + 0xc9, 0x00, 0x16, 0x01, 0x65, 0x00, 0x67, 0x02, 0x8f, 0x00, 0x88, 0x04, 0x1e, 0x00, 0xa0, 0x02, 0x03, 0xff, 0xb4, + 0x01, 0x99, 0x00, 0x30, 0x06, 0xfc, 0x00, 0xa9, 0x07, 0x03, 0x00, 0x8b, 0x05, 0x38, 0x00, 0x1c, 0x04, 0x5a, 0x00, + 0x6d, 0x04, 0x8c, 0x00, 0xa9, 0x05, 0xb4, 0x00, 0xb1, 0x04, 0x3d, 0x00, 0x5d, 0x04, 0x9e, 0x00, 0x9c, 0x05, 0x89, + 0x00, 0x5a, 0x05, 0x9a, 0x00, 0x5f, 0x05, 0x0a, 0x00, 0x16, 0x04, 0x03, 0xff, 0xfb, 0x08, 0x59, 0x00, 0x5b, 0x09, + 0x49, 0x00, 0x76, 0x04, 0xbf, 0x00, 0x50, 0x04, 0x10, 0x00, 0x58, 0x05, 0x35, 0x00, 0x77, 0x04, 0x30, 0x00, 0x5c, + 0x04, 0xce, 0x00, 0x0f, 0x04, 0x02, 0x00, 0x2e, 0x02, 0x2d, 0x00, 0xb7, 0x07, 0x43, 0x00, 0x1b, 0x06, 0x20, 0x00, + 0x15, 0x02, 0x2d, 0x00, 0xb7, 0x05, 0x38, 0x00, 0x1c, 0x04, 0x5a, 0x00, 0x6d, 0x05, 0x38, 0x00, 0x1c, 0x04, 0x5a, + 0x00, 0x6d, 0x07, 0x7a, 0xff, 0xf2, 0x06, 0xc1, 0x00, 0x4e, 0x04, 0x8c, 0x00, 0xa9, 0x04, 0x3d, 0x00, 0x5d, 0x05, + 0x87, 0x00, 0x5d, 0x04, 0x37, 0x00, 0x62, 0x04, 0x37, 0x00, 0x62, 0x07, 0x43, 0x00, 0x1b, 0x06, 0x20, 0x00, 0x15, + 0x04, 0xbf, 0x00, 0x50, 0x04, 0x10, 0x00, 0x58, 0x05, 0xb4, 0x00, 0xb1, 0x04, 0x9e, 0x00, 0x9c, 0x05, 0xb4, 0x00, + 0xb1, 0x04, 0x9e, 0x00, 0x9c, 0x05, 0x80, 0x00, 0x76, 0x04, 0x90, 0x00, 0x5b, 0x05, 0x71, 0x00, 0x67, 0x04, 0x8b, + 0x00, 0x5b, 0x05, 0x71, 0x00, 0x67, 0x04, 0x8b, 0x00, 0x5b, 0x05, 0x64, 0x00, 0x93, 0x04, 0x4d, 0x00, 0x64, 0x05, + 0x07, 0x00, 0x4d, 0x03, 0xc9, 0x00, 0x16, 0x05, 0x07, 0x00, 0x4d, 0x03, 0xc9, 0x00, 0x16, 0x05, 0x07, 0x00, 0x4d, + 0x03, 0xc9, 0x00, 0x16, 0x05, 0x7a, 0x00, 0x96, 0x04, 0x59, 0x00, 0x67, 0x06, 0xeb, 0x00, 0xb2, 0x06, 0x36, 0x00, + 0x9d, 0x04, 0x83, 0x00, 0x5f, 0x05, 0x38, 0x00, 0x1c, 0x04, 0x5a, 0x00, 0x6d, 0x05, 0x38, 0x00, 0x1c, 0x04, 0x5a, + 0x00, 0x6d, 0x05, 0x38, 0x00, 0x1c, 0x04, 0x5a, 0x00, 0x6d, 0x05, 0x38, 0x00, 0x1c, 0x04, 0x5a, 0xff, 0xca, 0x05, + 0x38, 0x00, 0x1c, 0x04, 0x5a, 0x00, 0x6d, 0x05, 0x38, 0x00, 0x1c, 0x04, 0x5a, 0x00, 0x6d, 0x05, 0x38, 0x00, 0x1c, + 0x04, 0x5a, 0x00, 0x6d, 0x05, 0x38, 0x00, 0x1c, 0x04, 0x5a, 0x00, 0x6d, 0x05, 0x38, 0x00, 0x1c, 0x04, 0x5a, 0x00, + 0x6d, 0x05, 0x38, 0x00, 0x1c, 0x04, 0x5a, 0x00, 0x6d, 0x05, 0x38, 0x00, 0x1c, 0x04, 0x5a, 0x00, 0x6d, 0x05, 0x38, + 0x00, 0x1c, 0x04, 0x5a, 0x00, 0x6d, 0x04, 0x8c, 0x00, 0xa9, 0x04, 0x3d, 0x00, 0x5d, 0x04, 0x8c, 0x00, 0xa9, 0x04, + 0x3d, 0x00, 0x5d, 0x04, 0x8c, 0x00, 0xa9, 0x04, 0x3d, 0x00, 0x5d, 0x04, 0x8c, 0x00, 0xa9, 0x04, 0x3d, 0x00, 0x5d, + 0x04, 0x8c, 0xff, 0xf0, 0x04, 0x3d, 0xff, 0xba, 0x04, 0x8c, 0x00, 0xa9, 0x04, 0x3d, 0x00, 0x5d, 0x04, 0x8c, 0x00, + 0xa9, 0x04, 0x3d, 0x00, 0x5d, 0x04, 0x8c, 0x00, 0xa9, 0x04, 0x3d, 0x00, 0x5d, 0x02, 0x2d, 0x00, 0xb7, 0x01, 0xfa, + 0x00, 0x9b, 0x02, 0x2d, 0x00, 0xa3, 0x01, 0xf1, 0x00, 0x85, 0x05, 0x80, 0x00, 0x76, 0x04, 0x90, 0x00, 0x5b, 0x05, + 0x80, 0x00, 0x76, 0x04, 0x90, 0x00, 0x5b, 0x05, 0x80, 0x00, 0x76, 0x04, 0x90, 0x00, 0x5b, 0x05, 0x80, 0x00, 0x47, + 0x04, 0x90, 0xff, 0xc4, 0x05, 0x80, 0x00, 0x76, 0x04, 0x90, 0x00, 0x5b, 0x05, 0x80, 0x00, 0x76, 0x04, 0x90, 0x00, + 0x5b, 0x05, 0x80, 0x00, 0x76, 0x04, 0x90, 0x00, 0x5b, 0x05, 0x7e, 0x00, 0x65, 0x04, 0x92, 0x00, 0x5b, 0x05, 0x7e, + 0x00, 0x65, 0x04, 0x92, 0x00, 0x5b, 0x05, 0x7e, 0x00, 0x65, 0x04, 0x92, 0x00, 0x5b, 0x05, 0x7e, 0x00, 0x65, 0x04, + 0x92, 0x00, 0x5b, 0x05, 0x7e, 0x00, 0x65, 0x04, 0x92, 0x00, 0x5b, 0x05, 0x30, 0x00, 0x8c, 0x04, 0x69, 0x00, 0x88, + 0x05, 0x30, 0x00, 0x8c, 0x04, 0x69, 0x00, 0x88, 0x05, 0x90, 0x00, 0x8c, 0x04, 0xf3, 0x00, 0x88, 0x05, 0x90, 0x00, + 0x8c, 0x04, 0xf3, 0x00, 0x88, 0x05, 0x90, 0x00, 0x8c, 0x04, 0xf3, 0x00, 0x88, 0x05, 0x90, 0x00, 0x8c, 0x04, 0xf3, + 0x00, 0x88, 0x05, 0x90, 0x00, 0x8c, 0x04, 0xf3, 0x00, 0x88, 0x04, 0xce, 0x00, 0x0f, 0x03, 0xc9, 0x00, 0x16, 0x04, + 0xce, 0x00, 0x0f, 0x03, 0xc9, 0x00, 0x16, 0x04, 0xce, 0x00, 0x0f, 0x03, 0xc9, 0x00, 0x16, 0x04, 0xa1, 0x00, 0x5f, + 0x04, 0xc6, 0x00, 0x31, 0x03, 0xd8, 0x00, 0x28, 0x05, 0x7a, 0x00, 0x96, 0x04, 0x59, 0x00, 0x67, 0x04, 0x73, 0x00, + 0xb1, 0x03, 0x5b, 0x00, 0x9a, 0x06, 0x2f, 0x00, 0x3f, 0x04, 0xbd, 0xff, 0xde, 0x04, 0x68, 0x00, 0x8c, 0x05, 0x05, + 0xff, 0xd4, 0x05, 0x05, 0xff, 0xd4, 0x04, 0x73, 0x00, 0x03, 0x03, 0x5b, 0xff, 0xfc, 0x05, 0x38, 0xff, 0xf7, 0x04, + 0x27, 0xff, 0xbf, 0x04, 0xce, 0x00, 0x0f, 0x04, 0x02, 0x00, 0x2e, 0x05, 0x04, 0x00, 0x39, 0x03, 0xf7, 0x00, 0x29, + 0x04, 0x50, 0x00, 0x63, 0x04, 0x6c, 0x00, 0x12, 0x06, 0x3f, 0x00, 0x90, 0x04, 0x7e, 0x00, 0x5d, 0x04, 0x7e, 0x00, + 0x5e, 0x04, 0x7e, 0x00, 0x35, 0x04, 0x7e, 0x00, 0x9a, 0x04, 0x92, 0x00, 0x98, 0x04, 0xa6, 0x00, 0x84, 0x04, 0x92, + 0x00, 0x64, 0x04, 0xa6, 0x00, 0x87, 0x05, 0x73, 0x00, 0x7a, 0x04, 0x7d, 0x00, 0x60, 0x05, 0xb4, 0x00, 0xa9, 0x04, + 0x6a, 0x00, 0x8c, 0x05, 0x38, 0x00, 0x1c, 0x04, 0x5a, 0x00, 0x39, 0x04, 0x8c, 0x00, 0x5f, 0x04, 0x3d, 0x00, 0x29, + 0x02, 0x2d, 0xff, 0x0a, 0x01, 0xfa, 0xfe, 0xf0, 0x05, 0x80, 0x00, 0x76, 0x04, 0x90, 0x00, 0x33, 0x04, 0xed, 0x00, + 0x55, 0x02, 0xb5, 0xff, 0x8b, 0x05, 0x30, 0x00, 0x8c, 0x04, 0x69, 0x00, 0x2b, 0x04, 0xa6, 0xfe, 0xd6, 0x04, 0xfb, + 0x00, 0xa9, 0x04, 0x7d, 0x00, 0x8c, 0x05, 0x3f, 0x00, 0xa9, 0x04, 0x83, 0x00, 0x5f, 0x05, 0x3f, 0x00, 0xa9, 0x04, + 0x83, 0x00, 0x5f, 0x05, 0xb4, 0x00, 0xa9, 0x04, 0x68, 0x00, 0x8c, 0x05, 0x04, 0x00, 0xa9, 0x04, 0x0e, 0x00, 0x8d, + 0x05, 0x04, 0x00, 0xa9, 0x04, 0x0e, 0x00, 0x8d, 0x04, 0x4e, 0x00, 0xa9, 0x01, 0xf1, 0x00, 0x86, 0x06, 0xfc, 0x00, + 0xa9, 0x07, 0x03, 0x00, 0x8b, 0x05, 0xb4, 0x00, 0xa9, 0x04, 0x6a, 0x00, 0x8c, 0x05, 0x80, 0x00, 0x76, 0x05, 0x0c, + 0x00, 0xa9, 0x04, 0x7d, 0x00, 0x8c, 0x04, 0xed, 0x00, 0xa8, 0x02, 0xb5, 0x00, 0x82, 0x04, 0xbf, 0x00, 0x50, 0x04, + 0x20, 0x00, 0x5f, 0x04, 0xc6, 0x00, 0x31, 0x02, 0x9d, 0x00, 0x09, 0x05, 0x30, 0x00, 0x8c, 0x05, 0x17, 0x00, 0x1c, + 0x03, 0xe0, 0x00, 0x21, 0x05, 0x17, 0x00, 0x1c, 0x03, 0xe0, 0x00, 0x21, 0x07, 0x19, 0x00, 0x3d, 0x06, 0x03, 0x00, + 0x2b, 0x04, 0xca, 0x00, 0x56, 0x03, 0xf7, 0x00, 0x58, 0x05, 0xc6, 0xfe, 0x32, 0x04, 0x85, 0x00, 0x13, 0x04, 0x22, + 0xff, 0x63, 0x05, 0x1f, 0xff, 0x80, 0x02, 0x24, 0xff, 0x84, 0x04, 0xc5, 0xff, 0xd5, 0x04, 0x67, 0xff, 0x1b, 0x04, + 0xfc, 0xff, 0xee, 0x04, 0x85, 0x00, 0x13, 0x04, 0x50, 0x00, 0x8a, 0x03, 0xe6, 0x00, 0x8a, 0x04, 0x23, 0x00, 0x47, + 0x04, 0xe3, 0x00, 0x8a, 0x01, 0xe8, 0x00, 0x97, 0x04, 0x54, 0x00, 0x8a, 0x06, 0x02, 0x00, 0x8a, 0x04, 0xe3, 0x00, + 0x8a, 0x04, 0xbb, 0x00, 0x60, 0x04, 0x5c, 0x00, 0x8a, 0x04, 0x26, 0x00, 0x28, 0x04, 0x2b, 0x00, 0x0d, 0x04, 0x54, + 0x00, 0x26, 0x01, 0xe8, 0xff, 0xb3, 0x04, 0x2b, 0x00, 0x0d, 0x03, 0xe6, 0x00, 0x8a, 0x03, 0xaf, 0x00, 0x8a, 0x04, + 0x20, 0x00, 0x43, 0x01, 0xe8, 0x00, 0x97, 0x01, 0xe8, 0xff, 0xb3, 0x03, 0xcf, 0x00, 0x2b, 0x04, 0x54, 0x00, 0x8a, + 0x04, 0x1f, 0x00, 0x22, 0x04, 0x85, 0x00, 0x13, 0x04, 0x50, 0x00, 0x8a, 0x03, 0xaf, 0x00, 0x8a, 0x03, 0xe6, 0x00, + 0x8a, 0x04, 0xec, 0x00, 0x8a, 0x06, 0x02, 0x00, 0x8a, 0x04, 0xe3, 0x00, 0x8a, 0x04, 0xbb, 0x00, 0x60, 0x04, 0xce, + 0x00, 0x8a, 0x04, 0x5c, 0x00, 0x8a, 0x04, 0x7c, 0x00, 0x60, 0x04, 0x26, 0x00, 0x28, 0x04, 0x54, 0x00, 0x26, 0x04, + 0x3f, 0x00, 0x47, 0x04, 0xe3, 0x00, 0x8a, 0x04, 0x7c, 0x00, 0x60, 0x04, 0x2b, 0x00, 0x0d, 0x05, 0xc3, 0x00, 0x02, + 0x04, 0xec, 0x00, 0x8a, 0x04, 0x1f, 0x00, 0x22, 0x05, 0x67, 0x00, 0x60, 0x05, 0xb7, 0x00, 0x97, 0x06, 0x39, 0x00, + 0x09, 0x04, 0xbb, 0x00, 0x60, 0x04, 0x20, 0x00, 0x43, 0x06, 0x15, 0x00, 0x31, 0x06, 0x15, 0x00, 0x31, 0x06, 0x15, + 0x00, 0x31, 0x04, 0x2b, 0x00, 0x0d, 0x05, 0x38, 0x00, 0x1c, 0x04, 0x5a, 0x00, 0x6d, 0x04, 0x8c, 0x00, 0xa9, 0x04, + 0x3d, 0x00, 0x5d, 0x04, 0x85, 0x00, 0x13, 0x03, 0xe6, 0x00, 0x8a, 0x01, 0xfa, 0x00, 0x85, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x05, 0x10, 0x09, 0x0a, 0x04, 0x00, 0x00, 0x02, 0x02, 0x02, 0x03, 0x06, 0x05, 0x07, 0x06, 0x02, 0x03, + 0x03, 0x04, 0x05, 0x02, 0x02, 0x02, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x02, 0x02, + 0x05, 0x05, 0x05, 0x04, 0x08, 0x06, 0x06, 0x06, 0x06, 0x05, 0x05, 0x06, 0x06, 0x02, 0x05, 0x06, 0x05, 0x08, 0x06, + 0x06, 0x06, 0x06, 0x06, 0x05, 0x05, 0x06, 0x06, 0x08, 0x06, 0x05, 0x05, 0x02, 0x04, 0x02, 0x04, 0x04, 0x03, 0x05, + 0x05, 0x05, 0x05, 0x05, 0x03, 0x05, 0x05, 0x02, 0x02, 0x05, 0x02, 0x08, 0x05, 0x05, 0x05, 0x05, 0x03, 0x05, 0x03, + 0x05, 0x04, 0x07, 0x04, 0x04, 0x04, 0x03, 0x02, 0x03, 0x06, 0x02, 0x05, 0x05, 0x06, 0x05, 0x02, 0x06, 0x04, 0x07, + 0x04, 0x04, 0x05, 0x07, 0x04, 0x03, 0x05, 0x03, 0x03, 0x03, 0x05, 0x04, 0x02, 0x02, 0x03, 0x04, 0x04, 0x07, 0x07, + 0x07, 0x04, 0x08, 0x05, 0x06, 0x05, 0x05, 0x08, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x02, 0x05, 0x05, 0x02, 0x06, + 0x05, 0x09, 0x08, 0x02, 0x06, 0x03, 0x06, 0x05, 0x06, 0x06, 0x02, 0x05, 0x04, 0x04, 0x04, 0x04, 0x02, 0x03, 0x02, + 0x04, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x05, 0x02, 0x05, 0x06, 0x06, 0x06, 0x05, 0x06, 0x05, + 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x03, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x05, 0x06, 0x06, 0x07, 0x05, 0x05, 0x07, 0x07, 0x06, 0x0a, 0x0a, 0x07, 0x06, 0x06, 0x07, 0x08, 0x05, 0x06, 0x06, + 0x06, 0x07, 0x07, 0x06, 0x08, 0x09, 0x07, 0x08, 0x06, 0x06, 0x08, 0x06, 0x05, 0x05, 0x04, 0x05, 0x07, 0x05, 0x05, + 0x05, 0x05, 0x07, 0x05, 0x05, 0x04, 0x07, 0x05, 0x05, 0x07, 0x07, 0x06, 0x07, 0x05, 0x05, 0x07, 0x05, 0x05, 0x05, + 0x08, 0x08, 0x05, 0x05, 0x08, 0x07, 0x05, 0x08, 0x07, 0x05, 0x05, 0x08, 0x07, 0x08, 0x07, 0x0a, 0x09, 0x05, 0x04, + 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, 0x08, 0x07, 0x08, 0x07, 0x06, 0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x07, 0x06, 0x05, 0x06, 0x05, 0x05, 0x04, 0x05, 0x05, 0x09, 0x07, 0x06, 0x05, 0x06, 0x05, 0x07, 0x06, 0x07, 0x05, + 0x09, 0x06, 0x09, 0x08, 0x07, 0x05, 0x06, 0x05, 0x08, 0x06, 0x06, 0x05, 0x06, 0x05, 0x06, 0x07, 0x05, 0x06, 0x05, + 0x07, 0x06, 0x06, 0x05, 0x07, 0x06, 0x08, 0x07, 0x06, 0x05, 0x05, 0x05, 0x04, 0x06, 0x05, 0x06, 0x07, 0x08, 0x07, + 0x06, 0x05, 0x05, 0x09, 0x07, 0x09, 0x07, 0x06, 0x05, 0x06, 0x06, 0x06, 0x07, 0x06, 0x04, 0x05, 0x09, 0x05, 0x09, + 0x03, 0x02, 0x02, 0x05, 0x02, 0x02, 0x01, 0x01, 0x00, 0x02, 0x02, 0x06, 0x07, 0x04, 0x02, 0x02, 0x02, 0x02, 0x03, + 0x03, 0x03, 0x05, 0x05, 0x03, 0x04, 0x06, 0x02, 0x09, 0x03, 0x03, 0x04, 0x03, 0x04, 0x05, 0x07, 0x07, 0x0a, 0x07, + 0x07, 0x05, 0x07, 0x05, 0x05, 0x06, 0x06, 0x07, 0x04, 0x09, 0x06, 0x06, 0x07, 0x08, 0x08, 0x07, 0x05, 0x06, 0x05, + 0x05, 0x05, 0x09, 0x02, 0x05, 0x05, 0x05, 0x05, 0x05, 0x03, 0x03, 0x02, 0x06, 0x05, 0x05, 0x08, 0x08, 0x06, 0x07, + 0x00, 0x09, 0x09, 0x03, 0x03, 0x03, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x07, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x07, 0x04, 0x05, 0x04, 0x02, 0x06, 0x05, 0x04, 0x05, + 0x05, 0x04, 0x04, 0x05, 0x05, 0x05, 0x04, 0x05, 0x04, 0x06, 0x06, 0x06, 0x06, 0x05, 0x08, 0x08, 0x06, 0x05, 0x05, + 0x06, 0x07, 0x05, 0x06, 0x05, 0x05, 0x05, 0x06, 0x05, 0x07, 0x08, 0x06, 0x07, 0x05, 0x05, 0x07, 0x05, 0x05, 0x07, + 0x05, 0x06, 0x06, 0x06, 0x05, 0x05, 0x07, 0x05, 0x05, 0x06, 0x05, 0x05, 0x05, 0x05, 0x04, 0x09, 0x05, 0x03, 0x03, + 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x03, 0x04, 0x05, 0x05, 0x06, 0x06, 0x05, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x02, 0x04, 0x00, 0x04, 0x04, 0x05, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x06, 0x06, + 0x06, 0x07, 0x07, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x02, 0x07, 0x05, 0x02, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x05, 0x05, 0x05, 0x05, 0x05, 0x02, 0x02, 0x02, 0x02, 0x02, 0x05, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x05, 0x05, 0x05, 0x04, 0x05, 0x04, 0x07, 0x04, 0x05, 0x06, 0x06, 0x02, 0x02, 0x06, 0x06, 0x05, 0x05, 0x03, 0x06, + 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x02, 0x02, 0x02, 0x02, 0x06, 0x06, 0x06, 0x06, + 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x02, 0x02, 0x02, 0x02, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x06, 0x05, 0x06, + 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x05, 0x05, 0x05, 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x07, 0x04, 0x05, 0x02, 0x06, 0x05, 0x05, 0x02, 0x05, 0x02, 0x05, 0x03, 0x05, 0x03, 0x06, + 0x05, 0x06, 0x05, 0x06, 0x05, 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, 0x03, 0x06, 0x03, 0x06, 0x03, 0x05, + 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x03, 0x05, 0x03, 0x05, 0x03, 0x06, 0x05, 0x06, 0x05, + 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, 0x08, 0x07, 0x05, 0x04, 0x05, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, + 0x08, 0x08, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, + 0x02, 0x02, 0x02, 0x02, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x06, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x04, 0x05, 0x04, 0x04, 0x04, 0x04, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x07, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x05, 0x06, 0x02, + 0x06, 0x06, 0x06, 0x03, 0x06, 0x06, 0x05, 0x05, 0x06, 0x02, 0x06, 0x08, 0x06, 0x06, 0x06, 0x05, 0x05, 0x06, 0x02, + 0x05, 0x05, 0x05, 0x05, 0x03, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x03, 0x05, 0x05, 0x05, 0x07, 0x05, 0x05, 0x05, + 0x02, 0x02, 0x05, 0x06, 0x06, 0x06, 0x06, 0x06, 0x05, 0x05, 0x06, 0x08, 0x06, 0x06, 0x06, 0x06, 0x06, 0x05, 0x06, + 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x05, 0x04, 0x05, 0x02, 0x02, 0x02, 0x05, 0x04, 0x08, 0x07, 0x08, + 0x07, 0x08, 0x07, 0x05, 0x04, 0x02, 0x03, 0x05, 0x02, 0x02, 0x08, 0x08, 0x06, 0x05, 0x05, 0x06, 0x05, 0x05, 0x06, + 0x06, 0x06, 0x05, 0x09, 0x0a, 0x05, 0x05, 0x06, 0x05, 0x05, 0x05, 0x02, 0x08, 0x07, 0x02, 0x06, 0x05, 0x06, 0x05, + 0x08, 0x08, 0x05, 0x05, 0x06, 0x05, 0x05, 0x08, 0x07, 0x05, 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, + 0x06, 0x05, 0x06, 0x05, 0x06, 0x04, 0x06, 0x04, 0x06, 0x04, 0x06, 0x05, 0x08, 0x07, 0x05, 0x06, 0x05, 0x06, 0x05, + 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, + 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x02, 0x02, + 0x02, 0x02, 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, + 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, + 0x06, 0x06, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 0x04, 0x06, 0x05, 0x05, 0x04, 0x07, 0x05, 0x05, 0x06, + 0x06, 0x05, 0x04, 0x06, 0x05, 0x05, 0x05, 0x06, 0x04, 0x05, 0x05, 0x07, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, 0x05, 0x05, 0x02, 0x02, 0x06, 0x05, 0x06, 0x03, 0x06, 0x05, 0x05, 0x06, + 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, 0x06, 0x05, 0x05, 0x02, 0x08, 0x08, 0x06, 0x05, 0x06, 0x06, + 0x05, 0x06, 0x03, 0x05, 0x05, 0x05, 0x03, 0x06, 0x06, 0x04, 0x06, 0x04, 0x08, 0x07, 0x05, 0x04, 0x07, 0x05, 0x05, + 0x06, 0x02, 0x05, 0x05, 0x06, 0x05, 0x05, 0x04, 0x05, 0x06, 0x02, 0x05, 0x07, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x02, 0x05, 0x04, 0x04, 0x05, 0x02, 0x02, 0x04, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x06, 0x07, 0x06, 0x05, 0x05, + 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x05, 0x05, 0x06, 0x06, 0x05, 0x06, 0x06, 0x07, 0x05, 0x05, 0x07, 0x07, 0x07, + 0x05, 0x06, 0x05, 0x05, 0x05, 0x05, 0x04, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x1c, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x03, 0x00, 0x0a, 0x00, 0x00, 0x06, 0x8a, 0x00, 0x04, + 0x06, 0x6e, 0x00, 0x00, 0x00, 0xf4, 0x00, 0x80, 0x00, 0x06, 0x00, 0x74, 0x00, 0x00, 0x00, 0x02, 0x00, 0x0d, 0x00, + 0x7e, 0x00, 0xa0, 0x00, 0xac, 0x00, 0xad, 0x00, 0xbf, 0x00, 0xc6, 0x00, 0xcf, 0x00, 0xe6, 0x00, 0xef, 0x00, 0xfe, + 0x01, 0x0f, 0x01, 0x11, 0x01, 0x25, 0x01, 0x27, 0x01, 0x30, 0x01, 0x53, 0x01, 0x5f, 0x01, 0x67, 0x01, 0x7e, 0x01, + 0x7f, 0x01, 0x8f, 0x01, 0x92, 0x01, 0xa1, 0x01, 0xb0, 0x01, 0xf0, 0x01, 0xff, 0x02, 0x1b, 0x02, 0x37, 0x02, 0x59, + 0x02, 0xbc, 0x02, 0xc7, 0x02, 0xc9, 0x02, 0xdd, 0x02, 0xf3, 0x03, 0x01, 0x03, 0x03, 0x03, 0x09, 0x03, 0x0f, 0x03, + 0x23, 0x03, 0x8a, 0x03, 0x8c, 0x03, 0x92, 0x03, 0xa1, 0x03, 0xb0, 0x03, 0xb9, 0x03, 0xc9, 0x03, 0xce, 0x03, 0xd2, + 0x03, 0xd6, 0x04, 0x25, 0x04, 0x2f, 0x04, 0x45, 0x04, 0x4f, 0x04, 0x62, 0x04, 0x6f, 0x04, 0x79, 0x04, 0x86, 0x04, + 0x9f, 0x04, 0xa9, 0x04, 0xb1, 0x04, 0xba, 0x04, 0xce, 0x04, 0xd7, 0x04, 0xe1, 0x04, 0xf5, 0x05, 0x01, 0x05, 0x10, + 0x05, 0x13, 0x1e, 0x01, 0x1e, 0x3f, 0x1e, 0x85, 0x1e, 0xf1, 0x1e, 0xf3, 0x1e, 0xf9, 0x1f, 0x4d, 0x20, 0x09, 0x20, + 0x0b, 0x20, 0x11, 0x20, 0x15, 0x20, 0x1e, 0x20, 0x22, 0x20, 0x27, 0x20, 0x30, 0x20, 0x33, 0x20, 0x3a, 0x20, 0x3c, + 0x20, 0x44, 0x20, 0x74, 0x20, 0x7f, 0x20, 0xa4, 0x20, 0xaa, 0x20, 0xac, 0x20, 0xb1, 0x20, 0xba, 0x20, 0xbd, 0x21, + 0x05, 0x21, 0x13, 0x21, 0x16, 0x21, 0x22, 0x21, 0x26, 0x21, 0x2e, 0x21, 0x5e, 0x22, 0x02, 0x22, 0x06, 0x22, 0x0f, + 0x22, 0x12, 0x22, 0x1a, 0x22, 0x1e, 0x22, 0x2b, 0x22, 0x48, 0x22, 0x60, 0x22, 0x65, 0x25, 0xca, 0xee, 0x02, 0xf6, + 0xc3, 0xfb, 0x04, 0xfe, 0xff, 0xff, 0xfd, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x0d, 0x00, 0x20, + 0x00, 0xa0, 0x00, 0xa1, 0x00, 0xad, 0x00, 0xae, 0x00, 0xc0, 0x00, 0xc7, 0x00, 0xd0, 0x00, 0xe7, 0x00, 0xf0, 0x00, + 0xff, 0x01, 0x10, 0x01, 0x12, 0x01, 0x26, 0x01, 0x28, 0x01, 0x31, 0x01, 0x54, 0x01, 0x60, 0x01, 0x68, 0x01, 0x7f, + 0x01, 0x8f, 0x01, 0x92, 0x01, 0xa0, 0x01, 0xaf, 0x01, 0xf0, 0x01, 0xfa, 0x02, 0x18, 0x02, 0x37, 0x02, 0x59, 0x02, + 0xbc, 0x02, 0xc6, 0x02, 0xc9, 0x02, 0xd8, 0x02, 0xf3, 0x03, 0x00, 0x03, 0x03, 0x03, 0x09, 0x03, 0x0f, 0x03, 0x23, + 0x03, 0x84, 0x03, 0x8c, 0x03, 0x8e, 0x03, 0x93, 0x03, 0xa3, 0x03, 0xb1, 0x03, 0xba, 0x03, 0xca, 0x03, 0xd1, 0x03, + 0xd6, 0x04, 0x00, 0x04, 0x26, 0x04, 0x30, 0x04, 0x46, 0x04, 0x50, 0x04, 0x63, 0x04, 0x70, 0x04, 0x7a, 0x04, 0x88, + 0x04, 0xa0, 0x04, 0xaa, 0x04, 0xb2, 0x04, 0xbb, 0x04, 0xcf, 0x04, 0xd8, 0x04, 0xe2, 0x04, 0xf6, 0x05, 0x02, 0x05, + 0x11, 0x1e, 0x00, 0x1e, 0x3e, 0x1e, 0x80, 0x1e, 0xa0, 0x1e, 0xf2, 0x1e, 0xf4, 0x1f, 0x4d, 0x20, 0x00, 0x20, 0x0a, + 0x20, 0x10, 0x20, 0x13, 0x20, 0x17, 0x20, 0x20, 0x20, 0x25, 0x20, 0x30, 0x20, 0x32, 0x20, 0x39, 0x20, 0x3c, 0x20, + 0x44, 0x20, 0x74, 0x20, 0x7f, 0x20, 0xa3, 0x20, 0xa6, 0x20, 0xab, 0x20, 0xb1, 0x20, 0xb9, 0x20, 0xbc, 0x21, 0x05, + 0x21, 0x13, 0x21, 0x16, 0x21, 0x22, 0x21, 0x26, 0x21, 0x2e, 0x21, 0x5b, 0x22, 0x02, 0x22, 0x06, 0x22, 0x0f, 0x22, + 0x11, 0x22, 0x1a, 0x22, 0x1e, 0x22, 0x2b, 0x22, 0x48, 0x22, 0x60, 0x22, 0x64, 0x25, 0xca, 0xee, 0x01, 0xf6, 0xc3, + 0xfb, 0x01, 0xfe, 0xff, 0xff, 0xfc, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00, 0xff, 0xf6, 0xff, 0xe4, 0x01, 0xd8, 0xff, + 0xc2, 0x01, 0xcc, 0xff, 0xc1, 0x00, 0x00, 0x01, 0xbf, 0x00, 0x00, 0x01, 0xba, 0x00, 0x00, 0x01, 0xb6, 0x00, 0x00, + 0x01, 0xb4, 0x00, 0x00, 0x01, 0xb2, 0x00, 0x00, 0x01, 0xaa, 0x00, 0x00, 0x01, 0xac, 0xff, 0x16, 0xff, 0x07, 0xff, + 0x05, 0xfe, 0xf8, 0xfe, 0xeb, 0x01, 0xee, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x65, 0xfe, 0x44, 0x01, 0x23, 0xfd, 0xd8, + 0xfd, 0xd7, 0xfd, 0xc9, 0xfd, 0xb4, 0xfd, 0xa8, 0xfd, 0xa7, 0xfd, 0xa2, 0xfd, 0x9d, 0xfd, 0x8a, 0x00, 0x00, 0xff, + 0xfe, 0xff, 0xfd, 0x00, 0x00, 0x00, 0x00, 0xfd, 0x0a, 0x00, 0x00, 0xff, 0xde, 0xfc, 0xfe, 0xfc, 0xfb, 0x00, 0x00, + 0xfc, 0xba, 0x00, 0x00, 0xfc, 0xb2, 0x00, 0x00, 0xfc, 0xa7, 0x00, 0x00, 0xfc, 0xa1, 0x00, 0x00, 0xfc, 0x99, 0x00, + 0x00, 0xfc, 0x91, 0x00, 0x00, 0xff, 0x28, 0x00, 0x00, 0xff, 0x25, 0x00, 0x00, 0xfc, 0x5e, 0x00, 0x00, 0xe5, 0xe2, + 0xe5, 0xa2, 0xe5, 0x53, 0xe5, 0x7e, 0xe4, 0xe7, 0xe5, 0x7c, 0xe5, 0x7d, 0xe1, 0x72, 0xe1, 0x73, 0xe1, 0x6f, 0x00, + 0x00, 0xe1, 0x6c, 0xe1, 0x6b, 0xe1, 0x69, 0xe1, 0x61, 0xe3, 0xa9, 0xe1, 0x59, 0xe3, 0xa1, 0xe1, 0x50, 0xe1, 0x21, + 0xe1, 0x17, 0x00, 0x00, 0xe0, 0xf2, 0x00, 0x00, 0xe0, 0xed, 0xe0, 0xe6, 0xe0, 0xe5, 0xe0, 0x9e, 0xe0, 0x91, 0xe0, + 0x8f, 0xe0, 0x84, 0xdf, 0x94, 0xe0, 0x79, 0xe0, 0x4d, 0xdf, 0xaa, 0xde, 0xac, 0xdf, 0x9e, 0xdf, 0x9d, 0xdf, 0x96, + 0xdf, 0x93, 0xdf, 0x87, 0xdf, 0x6b, 0xdf, 0x54, 0xdf, 0x51, 0xdb, 0xed, 0x13, 0xb7, 0x0a, 0xf7, 0x06, 0xbb, 0x02, + 0xc3, 0x01, 0xc7, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xe4, 0x00, 0x00, 0x00, 0xee, 0x00, 0x00, 0x01, 0x18, 0x00, 0x00, 0x01, 0x32, 0x00, 0x00, 0x01, + 0x32, 0x00, 0x00, 0x01, 0x32, 0x00, 0x00, 0x01, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x74, 0x01, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x6c, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x74, 0x01, 0x90, 0x00, 0x00, 0x01, 0xa8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xc0, 0x00, 0x00, 0x02, + 0x08, 0x00, 0x00, 0x02, 0x30, 0x00, 0x00, 0x02, 0x52, 0x00, 0x00, 0x02, 0x62, 0x00, 0x00, 0x02, 0x8e, 0x00, 0x00, + 0x02, 0x9a, 0x00, 0x00, 0x02, 0xbe, 0x00, 0x00, 0x02, 0xce, 0x00, 0x00, 0x02, 0xe2, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xd2, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0xc2, 0x00, 0x00, 0x02, 0xc2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x02, 0x7f, 0x02, 0x80, 0x02, 0x81, 0x02, 0x82, 0x02, 0x83, 0x02, 0x84, 0x00, 0x81, 0x02, 0x7b, 0x02, + 0x8f, 0x02, 0x90, 0x02, 0x91, 0x02, 0x92, 0x02, 0x93, 0x02, 0x94, 0x00, 0x82, 0x00, 0x83, 0x02, 0x95, 0x02, 0x96, + 0x02, 0x97, 0x02, 0x98, 0x02, 0x99, 0x00, 0x84, 0x00, 0x85, 0x02, 0x9a, 0x02, 0x9b, 0x02, 0x9c, 0x02, 0x9d, 0x02, + 0x9e, 0x02, 0x9f, 0x00, 0x86, 0x00, 0x87, 0x02, 0xaa, 0x02, 0xab, 0x02, 0xac, 0x02, 0xad, 0x02, 0xae, 0x02, 0xaf, + 0x00, 0x88, 0x00, 0x89, 0x02, 0xb0, 0x02, 0xb1, 0x02, 0xb2, 0x02, 0xb3, 0x02, 0xb4, 0x00, 0x8a, 0x02, 0x7a, 0x00, + 0x8b, 0x00, 0x8c, 0x02, 0x7c, 0x00, 0x8d, 0x02, 0xe3, 0x02, 0xe4, 0x02, 0xe5, 0x02, 0xe6, 0x02, 0xe7, 0x02, 0xe8, + 0x00, 0x8e, 0x02, 0xe9, 0x02, 0xea, 0x02, 0xeb, 0x02, 0xec, 0x02, 0xed, 0x02, 0xee, 0x02, 0xef, 0x02, 0xf0, 0x00, + 0x8f, 0x00, 0x90, 0x02, 0xf1, 0x02, 0xf2, 0x02, 0xf3, 0x02, 0xf4, 0x02, 0xf5, 0x02, 0xf6, 0x02, 0xf7, 0x00, 0x91, + 0x00, 0x92, 0x02, 0xf8, 0x02, 0xf9, 0x02, 0xfa, 0x02, 0xfb, 0x02, 0xfc, 0x02, 0xfd, 0x00, 0x93, 0x00, 0x94, 0x03, + 0x0c, 0x03, 0x0d, 0x03, 0x10, 0x03, 0x11, 0x03, 0x12, 0x03, 0x13, 0x02, 0x7d, 0x02, 0x7e, 0x02, 0x85, 0x02, 0xa0, + 0x03, 0x2b, 0x03, 0x2c, 0x03, 0x2d, 0x03, 0x2e, 0x03, 0x0a, 0x03, 0x0b, 0x03, 0x0e, 0x03, 0x0f, 0x00, 0xae, 0x00, + 0xaf, 0x03, 0x86, 0x00, 0xb0, 0x03, 0x87, 0x03, 0x88, 0x03, 0x89, 0x00, 0xb1, 0x00, 0xb2, 0x03, 0x90, 0x03, 0x91, + 0x03, 0x92, 0x00, 0xb3, 0x03, 0x93, 0x03, 0x94, 0x00, 0xb4, 0x03, 0x95, 0x03, 0x96, 0x00, 0xb5, 0x03, 0x97, 0x00, + 0xb6, 0x03, 0x98, 0x00, 0xb7, 0x03, 0x99, 0x03, 0x9a, 0x00, 0xb8, 0x03, 0x9b, 0x00, 0xb9, 0x00, 0xba, 0x03, 0x9c, + 0x03, 0x9d, 0x03, 0x9e, 0x03, 0x9f, 0x03, 0xa0, 0x03, 0xa1, 0x03, 0xa2, 0x03, 0xa3, 0x00, 0xc4, 0x03, 0xa5, 0x03, + 0xa6, 0x00, 0xc5, 0x03, 0xa4, 0x00, 0xc6, 0x00, 0xc7, 0x00, 0xc8, 0x00, 0xc9, 0x00, 0xca, 0x00, 0xcb, 0x00, 0xcc, + 0x03, 0xa7, 0x00, 0xcd, 0x00, 0xce, 0x03, 0xe4, 0x03, 0xad, 0x00, 0xd2, 0x03, 0xae, 0x00, 0xd3, 0x03, 0xaf, 0x03, + 0xb0, 0x03, 0xb1, 0x03, 0xb2, 0x00, 0xd4, 0x00, 0xd5, 0x00, 0xd6, 0x03, 0xb4, 0x03, 0xe5, 0x03, 0xb5, 0x00, 0xd7, + 0x03, 0xb6, 0x00, 0xd8, 0x03, 0xb7, 0x03, 0xb8, 0x00, 0xd9, 0x03, 0xb9, 0x00, 0xda, 0x00, 0xdb, 0x00, 0xdc, 0x03, + 0xba, 0x03, 0xb3, 0x00, 0xdd, 0x03, 0xbb, 0x03, 0xbc, 0x03, 0xbd, 0x03, 0xbe, 0x03, 0xbf, 0x03, 0xc0, 0x03, 0xc1, + 0x00, 0xde, 0x00, 0xdf, 0x03, 0xc2, 0x03, 0xc3, 0x00, 0xea, 0x00, 0xeb, 0x00, 0xec, 0x00, 0xed, 0x03, 0xc4, 0x00, + 0xee, 0x00, 0xef, 0x00, 0xf0, 0x03, 0xc5, 0x00, 0xf1, 0x00, 0xf2, 0x00, 0xf3, 0x00, 0xf4, 0x03, 0xc6, 0x00, 0xf5, + 0x03, 0xc7, 0x03, 0xc8, 0x00, 0xf6, 0x03, 0xc9, 0x00, 0xf7, 0x03, 0xca, 0x03, 0xe6, 0x03, 0xcb, 0x01, 0x02, 0x03, + 0xcc, 0x01, 0x03, 0x03, 0xcd, 0x03, 0xce, 0x03, 0xcf, 0x03, 0xd0, 0x01, 0x04, 0x01, 0x05, 0x01, 0x06, 0x03, 0xd1, + 0x03, 0xe7, 0x03, 0xd2, 0x01, 0x07, 0x01, 0x08, 0x01, 0x09, 0x04, 0x81, 0x03, 0xe8, 0x03, 0xe9, 0x01, 0x17, 0x01, + 0x18, 0x01, 0x19, 0x01, 0x1a, 0x03, 0xea, 0x03, 0xeb, 0x03, 0xed, 0x03, 0xec, 0x01, 0x28, 0x01, 0x29, 0x01, 0x2a, + 0x01, 0x2b, 0x04, 0x80, 0x01, 0x2c, 0x01, 0x2d, 0x01, 0x2e, 0x01, 0x2f, 0x01, 0x30, 0x04, 0x82, 0x04, 0x83, 0x01, + 0x31, 0x01, 0x32, 0x01, 0x33, 0x01, 0x34, 0x03, 0xee, 0x03, 0xef, 0x01, 0x35, 0x01, 0x36, 0x01, 0x37, 0x01, 0x38, + 0x04, 0x84, 0x04, 0x85, 0x03, 0xf0, 0x03, 0xf1, 0x04, 0x77, 0x04, 0x78, 0x03, 0xf2, 0x03, 0xf3, 0x04, 0x86, 0x04, + 0x87, 0x04, 0x7f, 0x01, 0x4c, 0x01, 0x4d, 0x04, 0x7d, 0x04, 0x7e, 0x03, 0xf4, 0x03, 0xf5, 0x03, 0xf6, 0x01, 0x4e, + 0x01, 0x4f, 0x01, 0x50, 0x01, 0x51, 0x01, 0x52, 0x01, 0x53, 0x01, 0x54, 0x01, 0x55, 0x04, 0x79, 0x04, 0x7a, 0x01, + 0x56, 0x01, 0x57, 0x01, 0x58, 0x04, 0x01, 0x04, 0x00, 0x04, 0x02, 0x04, 0x03, 0x04, 0x04, 0x04, 0x05, 0x04, 0x06, + 0x01, 0x59, 0x01, 0x5a, 0x04, 0x7b, 0x04, 0x7c, 0x04, 0x1b, 0x04, 0x1c, 0x01, 0x5b, 0x01, 0x5c, 0x01, 0x5d, 0x01, + 0x5e, 0x04, 0x88, 0x04, 0x89, 0x01, 0x5f, 0x04, 0x1d, 0x04, 0x8a, 0x01, 0x6f, 0x01, 0x70, 0x01, 0x81, 0x01, 0x82, + 0x04, 0x8c, 0x04, 0x8b, 0x01, 0x97, 0x04, 0x76, 0x01, 0x9d, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x0b, 0xbc, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, + 0x0d, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, + 0x00, 0xa0, 0x00, 0x00, 0x00, 0xa0, 0x00, 0x00, 0x02, 0x78, 0x00, 0x00, 0x00, 0xa1, 0x00, 0x00, 0x00, 0xac, 0x00, + 0x00, 0x00, 0x63, 0x00, 0x00, 0x00, 0xad, 0x00, 0x00, 0x00, 0xad, 0x00, 0x00, 0x02, 0x79, 0x00, 0x00, 0x00, 0xae, + 0x00, 0x00, 0x00, 0xbf, 0x00, 0x00, 0x00, 0x6f, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0xc5, 0x00, 0x00, 0x02, + 0x7f, 0x00, 0x00, 0x00, 0xc6, 0x00, 0x00, 0x00, 0xc6, 0x00, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00, 0xc7, 0x00, 0x00, + 0x00, 0xcf, 0x00, 0x00, 0x02, 0x86, 0x00, 0x00, 0x00, 0xd0, 0x00, 0x00, 0x00, 0xd0, 0x00, 0x00, 0x02, 0x7b, 0x00, + 0x00, 0x00, 0xd1, 0x00, 0x00, 0x00, 0xd6, 0x00, 0x00, 0x02, 0x8f, 0x00, 0x00, 0x00, 0xd7, 0x00, 0x00, 0x00, 0xd8, + 0x00, 0x00, 0x00, 0x82, 0x00, 0x00, 0x00, 0xd9, 0x00, 0x00, 0x00, 0xdd, 0x00, 0x00, 0x02, 0x95, 0x00, 0x00, 0x00, + 0xde, 0x00, 0x00, 0x00, 0xdf, 0x00, 0x00, 0x00, 0x84, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x00, 0xe5, 0x00, 0x00, + 0x02, 0x9a, 0x00, 0x00, 0x00, 0xe6, 0x00, 0x00, 0x00, 0xe6, 0x00, 0x00, 0x00, 0x86, 0x00, 0x00, 0x00, 0xe7, 0x00, + 0x00, 0x00, 0xef, 0x00, 0x00, 0x02, 0xa1, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x87, + 0x00, 0x00, 0x00, 0xf1, 0x00, 0x00, 0x00, 0xf6, 0x00, 0x00, 0x02, 0xaa, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x00, 0x00, + 0xf8, 0x00, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x00, 0x02, 0xb0, 0x00, 0x00, + 0x00, 0xfe, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x00, 0x00, 0x8a, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x01, 0x0f, 0x00, + 0x00, 0x02, 0xb5, 0x00, 0x00, 0x01, 0x10, 0x00, 0x00, 0x01, 0x10, 0x00, 0x00, 0x02, 0x7a, 0x00, 0x00, 0x01, 0x11, + 0x00, 0x00, 0x01, 0x11, 0x00, 0x00, 0x00, 0x8b, 0x00, 0x00, 0x01, 0x12, 0x00, 0x00, 0x01, 0x25, 0x00, 0x00, 0x02, + 0xc6, 0x00, 0x00, 0x01, 0x26, 0x00, 0x00, 0x01, 0x26, 0x00, 0x00, 0x00, 0x8c, 0x00, 0x00, 0x01, 0x27, 0x00, 0x00, + 0x01, 0x27, 0x00, 0x00, 0x02, 0x7c, 0x00, 0x00, 0x01, 0x28, 0x00, 0x00, 0x01, 0x30, 0x00, 0x00, 0x02, 0xda, 0x00, + 0x00, 0x01, 0x31, 0x00, 0x00, 0x01, 0x31, 0x00, 0x00, 0x00, 0x8d, 0x00, 0x00, 0x01, 0x32, 0x00, 0x00, 0x01, 0x37, + 0x00, 0x00, 0x02, 0xe3, 0x00, 0x00, 0x01, 0x38, 0x00, 0x00, 0x01, 0x38, 0x00, 0x00, 0x00, 0x8e, 0x00, 0x00, 0x01, + 0x39, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x02, 0xe9, 0x00, 0x00, 0x01, 0x41, 0x00, 0x00, 0x01, 0x42, 0x00, 0x00, + 0x00, 0x8f, 0x00, 0x00, 0x01, 0x43, 0x00, 0x00, 0x01, 0x49, 0x00, 0x00, 0x02, 0xf1, 0x00, 0x00, 0x01, 0x4a, 0x00, + 0x00, 0x01, 0x4b, 0x00, 0x00, 0x00, 0x91, 0x00, 0x00, 0x01, 0x4c, 0x00, 0x00, 0x01, 0x51, 0x00, 0x00, 0x02, 0xf8, + 0x00, 0x00, 0x01, 0x52, 0x00, 0x00, 0x01, 0x53, 0x00, 0x00, 0x00, 0x93, 0x00, 0x00, 0x01, 0x54, 0x00, 0x00, 0x01, + 0x5f, 0x00, 0x00, 0x02, 0xfe, 0x00, 0x00, 0x01, 0x60, 0x00, 0x00, 0x01, 0x61, 0x00, 0x00, 0x03, 0x0c, 0x00, 0x00, + 0x01, 0x62, 0x00, 0x00, 0x01, 0x65, 0x00, 0x00, 0x03, 0x10, 0x00, 0x00, 0x01, 0x66, 0x00, 0x00, 0x01, 0x67, 0x00, + 0x00, 0x02, 0x7d, 0x00, 0x00, 0x01, 0x68, 0x00, 0x00, 0x01, 0x7e, 0x00, 0x00, 0x03, 0x14, 0x00, 0x00, 0x01, 0x7f, + 0x00, 0x00, 0x01, 0x7f, 0x00, 0x00, 0x00, 0x95, 0x00, 0x00, 0x01, 0x8f, 0x00, 0x00, 0x01, 0x8f, 0x00, 0x00, 0x00, + 0x96, 0x00, 0x00, 0x01, 0x92, 0x00, 0x00, 0x01, 0x92, 0x00, 0x00, 0x00, 0x97, 0x00, 0x00, 0x01, 0xa0, 0x00, 0x00, + 0x01, 0xa1, 0x00, 0x00, 0x00, 0x98, 0x00, 0x00, 0x01, 0xaf, 0x00, 0x00, 0x01, 0xb0, 0x00, 0x00, 0x00, 0x9a, 0x00, + 0x00, 0x01, 0xf0, 0x00, 0x00, 0x01, 0xf0, 0x00, 0x00, 0x03, 0xde, 0x00, 0x00, 0x01, 0xfa, 0x00, 0x00, 0x01, 0xfa, + 0x00, 0x00, 0x02, 0x85, 0x00, 0x00, 0x01, 0xfb, 0x00, 0x00, 0x01, 0xfb, 0x00, 0x00, 0x02, 0xa0, 0x00, 0x00, 0x01, + 0xfc, 0x00, 0x00, 0x01, 0xff, 0x00, 0x00, 0x03, 0x2b, 0x00, 0x00, 0x02, 0x18, 0x00, 0x00, 0x02, 0x19, 0x00, 0x00, + 0x03, 0x0a, 0x00, 0x00, 0x02, 0x1a, 0x00, 0x00, 0x02, 0x1b, 0x00, 0x00, 0x03, 0x0e, 0x00, 0x00, 0x02, 0x37, 0x00, + 0x00, 0x02, 0x37, 0x00, 0x00, 0x00, 0x9c, 0x00, 0x00, 0x02, 0x59, 0x00, 0x00, 0x02, 0x59, 0x00, 0x00, 0x00, 0x9d, + 0x00, 0x00, 0x02, 0xbc, 0x00, 0x00, 0x02, 0xbc, 0x00, 0x00, 0x03, 0xdf, 0x00, 0x00, 0x02, 0xc6, 0x00, 0x00, 0x02, + 0xc7, 0x00, 0x00, 0x00, 0x9e, 0x00, 0x00, 0x02, 0xc9, 0x00, 0x00, 0x02, 0xc9, 0x00, 0x00, 0x00, 0xa0, 0x00, 0x00, + 0x02, 0xd8, 0x00, 0x00, 0x02, 0xdd, 0x00, 0x00, 0x00, 0xa1, 0x00, 0x00, 0x02, 0xf3, 0x00, 0x00, 0x02, 0xf3, 0x00, + 0x00, 0x00, 0xa7, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x01, 0x00, 0x00, 0x00, 0xa8, 0x00, 0x00, 0x03, 0x03, + 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x00, 0xaa, 0x00, 0x00, 0x03, 0x09, 0x00, 0x00, 0x03, 0x09, 0x00, 0x00, 0x00, + 0xab, 0x00, 0x00, 0x03, 0x0f, 0x00, 0x00, 0x03, 0x0f, 0x00, 0x00, 0x00, 0xac, 0x00, 0x00, 0x03, 0x23, 0x00, 0x00, + 0x03, 0x23, 0x00, 0x00, 0x00, 0xad, 0x00, 0x00, 0x03, 0x84, 0x00, 0x00, 0x03, 0x85, 0x00, 0x00, 0x00, 0xae, 0x00, + 0x00, 0x03, 0x86, 0x00, 0x00, 0x03, 0x86, 0x00, 0x00, 0x03, 0x86, 0x00, 0x00, 0x03, 0x87, 0x00, 0x00, 0x03, 0x87, + 0x00, 0x00, 0x00, 0xb0, 0x00, 0x00, 0x03, 0x88, 0x00, 0x00, 0x03, 0x8a, 0x00, 0x00, 0x03, 0x87, 0x00, 0x00, 0x03, + 0x8c, 0x00, 0x00, 0x03, 0x8c, 0x00, 0x00, 0x03, 0x8a, 0x00, 0x00, 0x03, 0x8e, 0x00, 0x00, 0x03, 0x92, 0x00, 0x00, + 0x03, 0x8b, 0x00, 0x00, 0x03, 0x93, 0x00, 0x00, 0x03, 0x94, 0x00, 0x00, 0x00, 0xb1, 0x00, 0x00, 0x03, 0x95, 0x00, + 0x00, 0x03, 0x97, 0x00, 0x00, 0x03, 0x90, 0x00, 0x00, 0x03, 0x98, 0x00, 0x00, 0x03, 0x98, 0x00, 0x00, 0x00, 0xb3, + 0x00, 0x00, 0x03, 0x99, 0x00, 0x00, 0x03, 0x9a, 0x00, 0x00, 0x03, 0x93, 0x00, 0x00, 0x03, 0x9b, 0x00, 0x00, 0x03, + 0x9b, 0x00, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x03, 0x9c, 0x00, 0x00, 0x03, 0x9d, 0x00, 0x00, 0x03, 0x95, 0x00, 0x00, + 0x03, 0x9e, 0x00, 0x00, 0x03, 0x9e, 0x00, 0x00, 0x00, 0xb5, 0x00, 0x00, 0x03, 0x9f, 0x00, 0x00, 0x03, 0x9f, 0x00, + 0x00, 0x03, 0x97, 0x00, 0x00, 0x03, 0xa0, 0x00, 0x00, 0x03, 0xa0, 0x00, 0x00, 0x00, 0xb6, 0x00, 0x00, 0x03, 0xa1, + 0x00, 0x00, 0x03, 0xa1, 0x00, 0x00, 0x03, 0x98, 0x00, 0x00, 0x03, 0xa3, 0x00, 0x00, 0x03, 0xa3, 0x00, 0x00, 0x00, + 0xb7, 0x00, 0x00, 0x03, 0xa4, 0x00, 0x00, 0x03, 0xa5, 0x00, 0x00, 0x03, 0x99, 0x00, 0x00, 0x03, 0xa6, 0x00, 0x00, + 0x03, 0xa6, 0x00, 0x00, 0x00, 0xb8, 0x00, 0x00, 0x03, 0xa7, 0x00, 0x00, 0x03, 0xa7, 0x00, 0x00, 0x03, 0x9b, 0x00, + 0x00, 0x03, 0xa8, 0x00, 0x00, 0x03, 0xa9, 0x00, 0x00, 0x00, 0xb9, 0x00, 0x00, 0x03, 0xaa, 0x00, 0x00, 0x03, 0xb0, + 0x00, 0x00, 0x03, 0x9c, 0x00, 0x00, 0x03, 0xb1, 0x00, 0x00, 0x03, 0xb9, 0x00, 0x00, 0x00, 0xbb, 0x00, 0x00, 0x03, + 0xba, 0x00, 0x00, 0x03, 0xba, 0x00, 0x00, 0x03, 0xa3, 0x00, 0x00, 0x03, 0xbb, 0x00, 0x00, 0x03, 0xbb, 0x00, 0x00, + 0x00, 0xc4, 0x00, 0x00, 0x03, 0xbc, 0x00, 0x00, 0x03, 0xbd, 0x00, 0x00, 0x03, 0xa5, 0x00, 0x00, 0x03, 0xbe, 0x00, + 0x00, 0x03, 0xbe, 0x00, 0x00, 0x00, 0xc5, 0x00, 0x00, 0x03, 0xbf, 0x00, 0x00, 0x03, 0xbf, 0x00, 0x00, 0x03, 0xa4, + 0x00, 0x00, 0x03, 0xc0, 0x00, 0x00, 0x03, 0xc6, 0x00, 0x00, 0x00, 0xc6, 0x00, 0x00, 0x03, 0xc7, 0x00, 0x00, 0x03, + 0xc7, 0x00, 0x00, 0x03, 0xa7, 0x00, 0x00, 0x03, 0xc8, 0x00, 0x00, 0x03, 0xc9, 0x00, 0x00, 0x00, 0xcd, 0x00, 0x00, + 0x03, 0xca, 0x00, 0x00, 0x03, 0xce, 0x00, 0x00, 0x03, 0xa8, 0x00, 0x00, 0x03, 0xd1, 0x00, 0x00, 0x03, 0xd2, 0x00, + 0x00, 0x00, 0xcf, 0x00, 0x00, 0x03, 0xd6, 0x00, 0x00, 0x03, 0xd6, 0x00, 0x00, 0x00, 0xd1, 0x00, 0x00, 0x04, 0x00, + 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0xe4, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x03, + 0xad, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0xd2, 0x00, 0x00, 0x04, 0x03, 0x00, 0x00, + 0x04, 0x03, 0x00, 0x00, 0x03, 0xae, 0x00, 0x00, 0x04, 0x04, 0x00, 0x00, 0x04, 0x04, 0x00, 0x00, 0x00, 0xd3, 0x00, + 0x00, 0x04, 0x05, 0x00, 0x00, 0x04, 0x08, 0x00, 0x00, 0x03, 0xaf, 0x00, 0x00, 0x04, 0x09, 0x00, 0x00, 0x04, 0x0b, + 0x00, 0x00, 0x00, 0xd4, 0x00, 0x00, 0x04, 0x0c, 0x00, 0x00, 0x04, 0x0c, 0x00, 0x00, 0x03, 0xb4, 0x00, 0x00, 0x04, + 0x0d, 0x00, 0x00, 0x04, 0x0d, 0x00, 0x00, 0x03, 0xe5, 0x00, 0x00, 0x04, 0x0e, 0x00, 0x00, 0x04, 0x0e, 0x00, 0x00, + 0x03, 0xb5, 0x00, 0x00, 0x04, 0x0f, 0x00, 0x00, 0x04, 0x0f, 0x00, 0x00, 0x00, 0xd7, 0x00, 0x00, 0x04, 0x10, 0x00, + 0x00, 0x04, 0x10, 0x00, 0x00, 0x03, 0xb6, 0x00, 0x00, 0x04, 0x11, 0x00, 0x00, 0x04, 0x11, 0x00, 0x00, 0x00, 0xd8, + 0x00, 0x00, 0x04, 0x12, 0x00, 0x00, 0x04, 0x13, 0x00, 0x00, 0x03, 0xb7, 0x00, 0x00, 0x04, 0x14, 0x00, 0x00, 0x04, + 0x14, 0x00, 0x00, 0x00, 0xd9, 0x00, 0x00, 0x04, 0x15, 0x00, 0x00, 0x04, 0x15, 0x00, 0x00, 0x03, 0xb9, 0x00, 0x00, + 0x04, 0x16, 0x00, 0x00, 0x04, 0x18, 0x00, 0x00, 0x00, 0xda, 0x00, 0x00, 0x04, 0x19, 0x00, 0x00, 0x04, 0x19, 0x00, + 0x00, 0x03, 0xba, 0x00, 0x00, 0x04, 0x1a, 0x00, 0x00, 0x04, 0x1a, 0x00, 0x00, 0x03, 0xb3, 0x00, 0x00, 0x04, 0x1b, + 0x00, 0x00, 0x04, 0x1b, 0x00, 0x00, 0x00, 0xdd, 0x00, 0x00, 0x04, 0x1c, 0x00, 0x00, 0x04, 0x22, 0x00, 0x00, 0x03, + 0xbb, 0x00, 0x00, 0x04, 0x23, 0x00, 0x00, 0x04, 0x24, 0x00, 0x00, 0x00, 0xde, 0x00, 0x00, 0x04, 0x25, 0x00, 0x00, + 0x04, 0x25, 0x00, 0x00, 0x03, 0xc2, 0x00, 0x00, 0x04, 0x26, 0x00, 0x00, 0x04, 0x2f, 0x00, 0x00, 0x00, 0xe0, 0x00, + 0x00, 0x04, 0x30, 0x00, 0x00, 0x04, 0x30, 0x00, 0x00, 0x03, 0xc3, 0x00, 0x00, 0x04, 0x31, 0x00, 0x00, 0x04, 0x34, + 0x00, 0x00, 0x00, 0xea, 0x00, 0x00, 0x04, 0x35, 0x00, 0x00, 0x04, 0x35, 0x00, 0x00, 0x03, 0xc4, 0x00, 0x00, 0x04, + 0x36, 0x00, 0x00, 0x04, 0x38, 0x00, 0x00, 0x00, 0xee, 0x00, 0x00, 0x04, 0x39, 0x00, 0x00, 0x04, 0x39, 0x00, 0x00, + 0x03, 0xc5, 0x00, 0x00, 0x04, 0x3a, 0x00, 0x00, 0x04, 0x3d, 0x00, 0x00, 0x00, 0xf1, 0x00, 0x00, 0x04, 0x3e, 0x00, + 0x00, 0x04, 0x3e, 0x00, 0x00, 0x03, 0xc6, 0x00, 0x00, 0x04, 0x3f, 0x00, 0x00, 0x04, 0x3f, 0x00, 0x00, 0x00, 0xf5, + 0x00, 0x00, 0x04, 0x40, 0x00, 0x00, 0x04, 0x41, 0x00, 0x00, 0x03, 0xc7, 0x00, 0x00, 0x04, 0x42, 0x00, 0x00, 0x04, + 0x42, 0x00, 0x00, 0x00, 0xf6, 0x00, 0x00, 0x04, 0x43, 0x00, 0x00, 0x04, 0x43, 0x00, 0x00, 0x03, 0xc9, 0x00, 0x00, + 0x04, 0x44, 0x00, 0x00, 0x04, 0x44, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x00, 0x04, 0x45, 0x00, 0x00, 0x04, 0x45, 0x00, + 0x00, 0x03, 0xca, 0x00, 0x00, 0x04, 0x46, 0x00, 0x00, 0x04, 0x4f, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x00, 0x04, 0x50, + 0x00, 0x00, 0x04, 0x50, 0x00, 0x00, 0x03, 0xe6, 0x00, 0x00, 0x04, 0x51, 0x00, 0x00, 0x04, 0x51, 0x00, 0x00, 0x03, + 0xcb, 0x00, 0x00, 0x04, 0x52, 0x00, 0x00, 0x04, 0x52, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x04, 0x53, 0x00, 0x00, + 0x04, 0x53, 0x00, 0x00, 0x03, 0xcc, 0x00, 0x00, 0x04, 0x54, 0x00, 0x00, 0x04, 0x54, 0x00, 0x00, 0x01, 0x03, 0x00, + 0x00, 0x04, 0x55, 0x00, 0x00, 0x04, 0x58, 0x00, 0x00, 0x03, 0xcd, 0x00, 0x00, 0x04, 0x59, 0x00, 0x00, 0x04, 0x5b, + 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x04, 0x5c, 0x00, 0x00, 0x04, 0x5c, 0x00, 0x00, 0x03, 0xd1, 0x00, 0x00, 0x04, + 0x5d, 0x00, 0x00, 0x04, 0x5d, 0x00, 0x00, 0x03, 0xe7, 0x00, 0x00, 0x04, 0x5e, 0x00, 0x00, 0x04, 0x5e, 0x00, 0x00, + 0x03, 0xd2, 0x00, 0x00, 0x04, 0x5f, 0x00, 0x00, 0x04, 0x61, 0x00, 0x00, 0x01, 0x07, 0x00, 0x00, 0x04, 0x62, 0x00, + 0x00, 0x04, 0x62, 0x00, 0x00, 0x04, 0x81, 0x00, 0x00, 0x04, 0x63, 0x00, 0x00, 0x04, 0x6f, 0x00, 0x00, 0x01, 0x0a, + 0x00, 0x00, 0x04, 0x70, 0x00, 0x00, 0x04, 0x71, 0x00, 0x00, 0x03, 0xe8, 0x00, 0x00, 0x04, 0x72, 0x00, 0x00, 0x04, + 0x75, 0x00, 0x00, 0x01, 0x17, 0x00, 0x00, 0x04, 0x76, 0x00, 0x00, 0x04, 0x77, 0x00, 0x00, 0x03, 0xea, 0x00, 0x00, + 0x04, 0x78, 0x00, 0x00, 0x04, 0x78, 0x00, 0x00, 0x03, 0xed, 0x00, 0x00, 0x04, 0x79, 0x00, 0x00, 0x04, 0x79, 0x00, + 0x00, 0x03, 0xec, 0x00, 0x00, 0x04, 0x7a, 0x00, 0x00, 0x04, 0x86, 0x00, 0x00, 0x01, 0x1b, 0x00, 0x00, 0x04, 0x88, + 0x00, 0x00, 0x04, 0x8b, 0x00, 0x00, 0x01, 0x28, 0x00, 0x00, 0x04, 0x8c, 0x00, 0x00, 0x04, 0x8c, 0x00, 0x00, 0x04, + 0x80, 0x00, 0x00, 0x04, 0x8d, 0x00, 0x00, 0x04, 0x91, 0x00, 0x00, 0x01, 0x2c, 0x00, 0x00, 0x04, 0x92, 0x00, 0x00, + 0x04, 0x93, 0x00, 0x00, 0x04, 0x82, 0x00, 0x00, 0x04, 0x94, 0x00, 0x00, 0x04, 0x97, 0x00, 0x00, 0x01, 0x31, 0x00, + 0x00, 0x04, 0x98, 0x00, 0x00, 0x04, 0x99, 0x00, 0x00, 0x03, 0xee, 0x00, 0x00, 0x04, 0x9a, 0x00, 0x00, 0x04, 0x9d, + 0x00, 0x00, 0x01, 0x35, 0x00, 0x00, 0x04, 0x9e, 0x00, 0x00, 0x04, 0x9f, 0x00, 0x00, 0x04, 0x84, 0x00, 0x00, 0x04, + 0xa0, 0x00, 0x00, 0x04, 0xa9, 0x00, 0x00, 0x01, 0x39, 0x00, 0x00, 0x04, 0xaa, 0x00, 0x00, 0x04, 0xab, 0x00, 0x00, + 0x03, 0xf0, 0x00, 0x00, 0x04, 0xac, 0x00, 0x00, 0x04, 0xad, 0x00, 0x00, 0x04, 0x77, 0x00, 0x00, 0x04, 0xae, 0x00, + 0x00, 0x04, 0xaf, 0x00, 0x00, 0x03, 0xf2, 0x00, 0x00, 0x04, 0xb0, 0x00, 0x00, 0x04, 0xb1, 0x00, 0x00, 0x04, 0x86, + 0x00, 0x00, 0x04, 0xb2, 0x00, 0x00, 0x04, 0xba, 0x00, 0x00, 0x01, 0x43, 0x00, 0x00, 0x04, 0xbb, 0x00, 0x00, 0x04, + 0xbb, 0x00, 0x00, 0x04, 0x7f, 0x00, 0x00, 0x04, 0xbc, 0x00, 0x00, 0x04, 0xbd, 0x00, 0x00, 0x01, 0x4c, 0x00, 0x00, + 0x04, 0xbe, 0x00, 0x00, 0x04, 0xbf, 0x00, 0x00, 0x04, 0x7d, 0x00, 0x00, 0x04, 0xc0, 0x00, 0x00, 0x04, 0xc2, 0x00, + 0x00, 0x03, 0xf4, 0x00, 0x00, 0x04, 0xc3, 0x00, 0x00, 0x04, 0xca, 0x00, 0x00, 0x01, 0x4e, 0x00, 0x00, 0x04, 0xcb, + 0x00, 0x00, 0x04, 0xcc, 0x00, 0x00, 0x04, 0x79, 0x00, 0x00, 0x04, 0xcd, 0x00, 0x00, 0x04, 0xce, 0x00, 0x00, 0x01, + 0x56, 0x00, 0x00, 0x04, 0xcf, 0x00, 0x00, 0x04, 0xd7, 0x00, 0x00, 0x03, 0xf7, 0x00, 0x00, 0x04, 0xd8, 0x00, 0x00, + 0x04, 0xd8, 0x00, 0x00, 0x01, 0x58, 0x00, 0x00, 0x04, 0xd9, 0x00, 0x00, 0x04, 0xd9, 0x00, 0x00, 0x04, 0x01, 0x00, + 0x00, 0x04, 0xda, 0x00, 0x00, 0x04, 0xda, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0xdb, 0x00, 0x00, 0x04, 0xdf, + 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x04, 0xe0, 0x00, 0x00, 0x04, 0xe1, 0x00, 0x00, 0x01, 0x59, 0x00, 0x00, 0x04, + 0xe2, 0x00, 0x00, 0x04, 0xf5, 0x00, 0x00, 0x04, 0x07, 0x00, 0x00, 0x04, 0xf6, 0x00, 0x00, 0x04, 0xf7, 0x00, 0x00, + 0x04, 0x7b, 0x00, 0x00, 0x04, 0xf8, 0x00, 0x00, 0x04, 0xf9, 0x00, 0x00, 0x04, 0x1b, 0x00, 0x00, 0x04, 0xfa, 0x00, + 0x00, 0x04, 0xfd, 0x00, 0x00, 0x01, 0x5b, 0x00, 0x00, 0x04, 0xfe, 0x00, 0x00, 0x04, 0xff, 0x00, 0x00, 0x04, 0x88, + 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x5f, 0x00, 0x00, 0x05, 0x01, 0x00, 0x00, 0x05, + 0x01, 0x00, 0x00, 0x04, 0x1d, 0x00, 0x00, 0x05, 0x02, 0x00, 0x00, 0x05, 0x10, 0x00, 0x00, 0x01, 0x60, 0x00, 0x00, + 0x05, 0x11, 0x00, 0x00, 0x05, 0x11, 0x00, 0x00, 0x04, 0x8a, 0x00, 0x00, 0x05, 0x12, 0x00, 0x00, 0x05, 0x13, 0x00, + 0x00, 0x01, 0x6f, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x01, 0x00, 0x00, 0x03, 0xe2, 0x00, 0x00, 0x1e, 0x3e, + 0x00, 0x00, 0x1e, 0x3f, 0x00, 0x00, 0x03, 0xe0, 0x00, 0x00, 0x1e, 0x80, 0x00, 0x00, 0x1e, 0x85, 0x00, 0x00, 0x03, + 0xd3, 0x00, 0x00, 0x1e, 0xa0, 0x00, 0x00, 0x1e, 0xf1, 0x00, 0x00, 0x04, 0x1e, 0x00, 0x00, 0x1e, 0xf2, 0x00, 0x00, + 0x1e, 0xf3, 0x00, 0x00, 0x03, 0xd9, 0x00, 0x00, 0x1e, 0xf4, 0x00, 0x00, 0x1e, 0xf9, 0x00, 0x00, 0x04, 0x70, 0x00, + 0x00, 0x1f, 0x4d, 0x00, 0x00, 0x1f, 0x4d, 0x00, 0x00, 0x04, 0xca, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x09, + 0x00, 0x00, 0x01, 0x72, 0x00, 0x00, 0x20, 0x0a, 0x00, 0x00, 0x20, 0x0b, 0x00, 0x00, 0x01, 0x7d, 0x00, 0x00, 0x20, + 0x10, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x01, 0x7f, 0x00, 0x00, 0x20, 0x13, 0x00, 0x00, 0x20, 0x14, 0x00, 0x00, + 0x01, 0x81, 0x00, 0x00, 0x20, 0x15, 0x00, 0x00, 0x20, 0x15, 0x00, 0x00, 0x04, 0x8c, 0x00, 0x00, 0x20, 0x17, 0x00, + 0x00, 0x20, 0x1e, 0x00, 0x00, 0x01, 0x83, 0x00, 0x00, 0x20, 0x20, 0x00, 0x00, 0x20, 0x22, 0x00, 0x00, 0x01, 0x8b, + 0x00, 0x00, 0x20, 0x25, 0x00, 0x00, 0x20, 0x27, 0x00, 0x00, 0x01, 0x8e, 0x00, 0x00, 0x20, 0x30, 0x00, 0x00, 0x20, + 0x30, 0x00, 0x00, 0x01, 0x91, 0x00, 0x00, 0x20, 0x32, 0x00, 0x00, 0x20, 0x33, 0x00, 0x00, 0x03, 0xdb, 0x00, 0x00, + 0x20, 0x39, 0x00, 0x00, 0x20, 0x3a, 0x00, 0x00, 0x01, 0x92, 0x00, 0x00, 0x20, 0x3c, 0x00, 0x00, 0x20, 0x3c, 0x00, + 0x00, 0x03, 0xdd, 0x00, 0x00, 0x20, 0x44, 0x00, 0x00, 0x20, 0x44, 0x00, 0x00, 0x01, 0x94, 0x00, 0x00, 0x20, 0x74, + 0x00, 0x00, 0x20, 0x74, 0x00, 0x00, 0x01, 0x95, 0x00, 0x00, 0x20, 0x7f, 0x00, 0x00, 0x20, 0x7f, 0x00, 0x00, 0x01, + 0x96, 0x00, 0x00, 0x20, 0xa3, 0x00, 0x00, 0x20, 0xa3, 0x00, 0x00, 0x04, 0x8b, 0x00, 0x00, 0x20, 0xa4, 0x00, 0x00, + 0x20, 0xa4, 0x00, 0x00, 0x01, 0x97, 0x00, 0x00, 0x20, 0xa6, 0x00, 0x00, 0x20, 0xaa, 0x00, 0x00, 0x01, 0x98, 0x00, + 0x00, 0x20, 0xab, 0x00, 0x00, 0x20, 0xab, 0x00, 0x00, 0x04, 0x76, 0x00, 0x00, 0x20, 0xac, 0x00, 0x00, 0x20, 0xac, + 0x00, 0x00, 0x01, 0x9d, 0x00, 0x00, 0x20, 0xb1, 0x00, 0x00, 0x20, 0xb1, 0x00, 0x00, 0x01, 0x9e, 0x00, 0x00, 0x20, + 0xb9, 0x00, 0x00, 0x20, 0xba, 0x00, 0x00, 0x01, 0x9f, 0x00, 0x00, 0x20, 0xbc, 0x00, 0x00, 0x20, 0xbd, 0x00, 0x00, + 0x01, 0xa1, 0x00, 0x00, 0x21, 0x05, 0x00, 0x00, 0x21, 0x05, 0x00, 0x00, 0x01, 0xa3, 0x00, 0x00, 0x21, 0x13, 0x00, + 0x00, 0x21, 0x13, 0x00, 0x00, 0x01, 0xa4, 0x00, 0x00, 0x21, 0x16, 0x00, 0x00, 0x21, 0x16, 0x00, 0x00, 0x01, 0xa5, + 0x00, 0x00, 0x21, 0x22, 0x00, 0x00, 0x21, 0x22, 0x00, 0x00, 0x01, 0xa6, 0x00, 0x00, 0x21, 0x26, 0x00, 0x00, 0x21, + 0x26, 0x00, 0x00, 0x00, 0xba, 0x00, 0x00, 0x21, 0x2e, 0x00, 0x00, 0x21, 0x2e, 0x00, 0x00, 0x01, 0xa7, 0x00, 0x00, + 0x21, 0x5b, 0x00, 0x00, 0x21, 0x5e, 0x00, 0x00, 0x01, 0xa8, 0x00, 0x00, 0x22, 0x02, 0x00, 0x00, 0x22, 0x02, 0x00, + 0x00, 0x01, 0xac, 0x00, 0x00, 0x22, 0x06, 0x00, 0x00, 0x22, 0x06, 0x00, 0x00, 0x00, 0xb2, 0x00, 0x00, 0x22, 0x0f, + 0x00, 0x00, 0x22, 0x0f, 0x00, 0x00, 0x01, 0xad, 0x00, 0x00, 0x22, 0x11, 0x00, 0x00, 0x22, 0x12, 0x00, 0x00, 0x01, + 0xae, 0x00, 0x00, 0x22, 0x1a, 0x00, 0x00, 0x22, 0x1a, 0x00, 0x00, 0x01, 0xb0, 0x00, 0x00, 0x22, 0x1e, 0x00, 0x00, + 0x22, 0x1e, 0x00, 0x00, 0x01, 0xb1, 0x00, 0x00, 0x22, 0x2b, 0x00, 0x00, 0x22, 0x2b, 0x00, 0x00, 0x01, 0xb2, 0x00, + 0x00, 0x22, 0x48, 0x00, 0x00, 0x22, 0x48, 0x00, 0x00, 0x01, 0xb3, 0x00, 0x00, 0x22, 0x60, 0x00, 0x00, 0x22, 0x60, + 0x00, 0x00, 0x01, 0xb4, 0x00, 0x00, 0x22, 0x64, 0x00, 0x00, 0x22, 0x65, 0x00, 0x00, 0x01, 0xb5, 0x00, 0x00, 0x25, + 0xca, 0x00, 0x00, 0x25, 0xca, 0x00, 0x00, 0x01, 0xb7, 0x00, 0x00, 0xee, 0x01, 0x00, 0x00, 0xee, 0x02, 0x00, 0x00, + 0x01, 0xb8, 0x00, 0x00, 0xf6, 0xc3, 0x00, 0x00, 0xf6, 0xc3, 0x00, 0x00, 0x01, 0xba, 0x00, 0x00, 0xfb, 0x01, 0x00, + 0x00, 0xfb, 0x04, 0x00, 0x00, 0x01, 0xbc, 0x00, 0x00, 0xfe, 0xff, 0x00, 0x00, 0xfe, 0xff, 0x00, 0x00, 0x01, 0xc2, + 0x00, 0x00, 0xff, 0xfc, 0x00, 0x00, 0xff, 0xfd, 0x00, 0x00, 0x01, 0xc3, 0x00, 0x00, 0xb0, 0x00, 0x2c, 0x4b, 0xb0, + 0x09, 0x50, 0x58, 0xb1, 0x01, 0x01, 0x8e, 0x59, 0xb8, 0x01, 0xff, 0x85, 0xb0, 0x84, 0x1d, 0xb1, 0x09, 0x03, 0x5f, + 0x5e, 0x2d, 0xb0, 0x01, 0x2c, 0x20, 0x20, 0x45, 0x69, 0x44, 0xb0, 0x01, 0x60, 0x2d, 0xb0, 0x02, 0x2c, 0xb0, 0x01, + 0x2a, 0x21, 0x2d, 0xb0, 0x03, 0x2c, 0x20, 0x46, 0xb0, 0x03, 0x25, 0x46, 0x52, 0x58, 0x23, 0x59, 0x20, 0x8a, 0x20, + 0x8a, 0x49, 0x64, 0x8a, 0x20, 0x46, 0x20, 0x68, 0x61, 0x64, 0xb0, 0x04, 0x25, 0x46, 0x20, 0x68, 0x61, 0x64, 0x52, + 0x58, 0x23, 0x65, 0x8a, 0x59, 0x2f, 0x20, 0xb0, 0x00, 0x53, 0x58, 0x69, 0x20, 0xb0, 0x00, 0x54, 0x58, 0x21, 0xb0, + 0x40, 0x59, 0x1b, 0x69, 0x20, 0xb0, 0x00, 0x54, 0x58, 0x21, 0xb0, 0x40, 0x65, 0x59, 0x59, 0x3a, 0x2d, 0xb0, 0x04, + 0x2c, 0x20, 0x46, 0xb0, 0x04, 0x25, 0x46, 0x52, 0x58, 0x23, 0x8a, 0x59, 0x20, 0x46, 0x20, 0x6a, 0x61, 0x64, 0xb0, + 0x04, 0x25, 0x46, 0x20, 0x6a, 0x61, 0x64, 0x52, 0x58, 0x23, 0x8a, 0x59, 0x2f, 0xfd, 0x2d, 0xb0, 0x05, 0x2c, 0x4b, + 0x20, 0xb0, 0x03, 0x26, 0x50, 0x58, 0x51, 0x58, 0xb0, 0x80, 0x44, 0x1b, 0xb0, 0x40, 0x44, 0x59, 0x1b, 0x21, 0x21, + 0x20, 0x45, 0xb0, 0xc0, 0x50, 0x58, 0xb0, 0xc0, 0x44, 0x1b, 0x21, 0x59, 0x59, 0x2d, 0xb0, 0x06, 0x2c, 0x20, 0x20, + 0x45, 0x69, 0x44, 0xb0, 0x01, 0x60, 0x20, 0x20, 0x45, 0x7d, 0x69, 0x18, 0x44, 0xb0, 0x01, 0x60, 0x2d, 0xb0, 0x07, + 0x2c, 0xb0, 0x06, 0x2a, 0x2d, 0xb0, 0x08, 0x2c, 0x4b, 0x20, 0xb0, 0x03, 0x26, 0x53, 0x58, 0xb0, 0x40, 0x1b, 0xb0, + 0x00, 0x59, 0x8a, 0x8a, 0x20, 0xb0, 0x03, 0x26, 0x53, 0x58, 0x23, 0x21, 0xb0, 0x80, 0x8a, 0x8a, 0x1b, 0x8a, 0x23, + 0x59, 0x20, 0xb0, 0x03, 0x26, 0x53, 0x58, 0x23, 0x21, 0xb0, 0xc0, 0x8a, 0x8a, 0x1b, 0x8a, 0x23, 0x59, 0x20, 0xb0, + 0x03, 0x26, 0x53, 0x58, 0x23, 0x21, 0xb8, 0x01, 0x00, 0x8a, 0x8a, 0x1b, 0x8a, 0x23, 0x59, 0x20, 0xb0, 0x03, 0x26, + 0x53, 0x58, 0x23, 0x21, 0xb8, 0x01, 0x40, 0x8a, 0x8a, 0x1b, 0x8a, 0x23, 0x59, 0x20, 0xb0, 0x03, 0x26, 0x53, 0x58, + 0xb0, 0x03, 0x25, 0x45, 0xb8, 0x01, 0x80, 0x50, 0x58, 0x23, 0x21, 0xb8, 0x01, 0x80, 0x23, 0x21, 0x1b, 0xb0, 0x03, + 0x25, 0x45, 0x23, 0x21, 0x23, 0x21, 0x59, 0x1b, 0x21, 0x59, 0x44, 0x2d, 0xb0, 0x09, 0x2c, 0x4b, 0x53, 0x58, 0x45, + 0x44, 0x1b, 0x21, 0x21, 0x59, 0x2d, 0xb0, 0x0a, 0x2c, 0xb0, 0x28, 0x45, 0x2d, 0xb0, 0x0b, 0x2c, 0xb0, 0x29, 0x45, + 0x2d, 0xb0, 0x0c, 0x2c, 0xb1, 0x27, 0x01, 0x88, 0x20, 0x8a, 0x53, 0x58, 0xb9, 0x40, 0x00, 0x04, 0x00, 0x63, 0xb8, + 0x08, 0x00, 0x88, 0x54, 0x58, 0xb9, 0x00, 0x28, 0x03, 0xe8, 0x70, 0x59, 0x1b, 0xb0, 0x23, 0x53, 0x58, 0xb0, 0x20, + 0x88, 0xb8, 0x10, 0x00, 0x54, 0x58, 0xb9, 0x00, 0x28, 0x03, 0xe8, 0x70, 0x59, 0x59, 0x59, 0x2d, 0xb0, 0x0d, 0x2c, + 0xb0, 0x40, 0x88, 0xb8, 0x20, 0x00, 0x5a, 0x58, 0xb1, 0x29, 0x00, 0x44, 0x1b, 0xb9, 0x00, 0x29, 0x03, 0xe8, 0x44, + 0x59, 0x2d, 0xb0, 0x0c, 0x2b, 0xb0, 0x00, 0x2b, 0x00, 0xb2, 0x01, 0x10, 0x02, 0x2b, 0x01, 0xb2, 0x11, 0x01, 0x02, + 0x2b, 0x01, 0xb7, 0x11, 0x3a, 0x30, 0x25, 0x1b, 0x10, 0x00, 0x08, 0x2b, 0x00, 0xb7, 0x01, 0x48, 0x3b, 0x2e, 0x21, + 0x14, 0x00, 0x08, 0x2b, 0xb7, 0x02, 0x58, 0x48, 0x38, 0x28, 0x14, 0x00, 0x08, 0x2b, 0xb7, 0x03, 0x52, 0x43, 0x34, + 0x25, 0x16, 0x00, 0x08, 0x2b, 0xb7, 0x04, 0x5e, 0x4d, 0x3c, 0x2b, 0x19, 0x00, 0x08, 0x2b, 0xb7, 0x05, 0x36, 0x2c, + 0x22, 0x19, 0x0f, 0x00, 0x08, 0x2b, 0xb7, 0x06, 0x71, 0x5d, 0x46, 0x32, 0x1b, 0x00, 0x08, 0x2b, 0xb7, 0x07, 0x91, + 0x77, 0x5c, 0x3a, 0x23, 0x00, 0x08, 0x2b, 0xb7, 0x08, 0x7e, 0x67, 0x50, 0x39, 0x1a, 0x00, 0x08, 0x2b, 0xb7, 0x09, + 0x54, 0x45, 0x36, 0x26, 0x14, 0x00, 0x08, 0x2b, 0xb7, 0x0a, 0x76, 0x60, 0x4b, 0x36, 0x1d, 0x00, 0x08, 0x2b, 0xb7, + 0x0b, 0x83, 0x64, 0x4e, 0x3a, 0x23, 0x00, 0x08, 0x2b, 0xb7, 0x0c, 0xd9, 0xb2, 0x8a, 0x63, 0x3c, 0x00, 0x08, 0x2b, + 0xb7, 0x0d, 0x14, 0x10, 0x0c, 0x09, 0x06, 0x00, 0x08, 0x2b, 0xb7, 0x0e, 0x3c, 0x32, 0x27, 0x1c, 0x11, 0x00, 0x08, + 0x2b, 0xb7, 0x0f, 0x40, 0x34, 0x29, 0x1d, 0x14, 0x00, 0x08, 0x2b, 0xb7, 0x10, 0x50, 0x41, 0x2e, 0x21, 0x14, 0x00, + 0x08, 0x2b, 0x00, 0xb2, 0x12, 0x0b, 0x07, 0x2b, 0xb0, 0x00, 0x20, 0x45, 0x7d, 0x69, 0x18, 0x44, 0xb2, 0x3f, 0x1a, + 0x01, 0x73, 0xb2, 0x5f, 0x1a, 0x01, 0x73, 0xb2, 0x7f, 0x1a, 0x01, 0x73, 0xb2, 0x2f, 0x1a, 0x01, 0x74, 0xb2, 0x4f, + 0x1a, 0x01, 0x74, 0xb2, 0x6f, 0x1a, 0x01, 0x74, 0xb2, 0x8f, 0x1a, 0x01, 0x74, 0xb2, 0xaf, 0x1a, 0x01, 0x74, 0xb2, + 0xff, 0x1a, 0x01, 0x74, 0xb2, 0x1f, 0x1a, 0x01, 0x75, 0xb2, 0x3f, 0x1a, 0x01, 0x75, 0xb2, 0x5f, 0x1a, 0x01, 0x75, + 0xb2, 0x7f, 0x1a, 0x01, 0x75, 0xb2, 0x0f, 0x1e, 0x01, 0x73, 0xb2, 0x7f, 0x1e, 0x01, 0x73, 0xb2, 0xef, 0x1e, 0x01, + 0x73, 0xb2, 0x1f, 0x1e, 0x01, 0x74, 0xb2, 0x5f, 0x1e, 0x01, 0x74, 0xb2, 0x8f, 0x1e, 0x01, 0x74, 0xb2, 0xcf, 0x1e, + 0x01, 0x74, 0xb2, 0xff, 0x1e, 0x01, 0x74, 0xb2, 0x3f, 0x1e, 0x01, 0x75, 0xb2, 0x6f, 0x1e, 0x01, 0x75, 0xb2, 0x2f, + 0x20, 0x01, 0x73, 0xb2, 0x6f, 0x20, 0x01, 0x73, 0x00, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x9d, 0x00, 0x80, 0x00, 0x8a, + 0x00, 0x78, 0x00, 0xd4, 0x00, 0x64, 0x00, 0x4e, 0x00, 0x5a, 0x00, 0x87, 0x00, 0x60, 0x00, 0x56, 0x00, 0x34, 0x02, + 0x3c, 0x00, 0xbc, 0x00, 0xb2, 0x00, 0x8e, 0x00, 0xc4, 0x00, 0x00, 0x00, 0x14, 0xfe, 0x60, 0x00, 0x14, 0x02, 0x9b, + 0x00, 0x20, 0x03, 0x21, 0x00, 0x0b, 0x04, 0x3a, 0x00, 0x14, 0x04, 0x8d, 0x00, 0x10, 0x05, 0xb0, 0x00, 0x14, 0x06, + 0x18, 0x00, 0x15, 0x01, 0xa6, 0x00, 0x11, 0x06, 0xc0, 0x00, 0x0e, 0x06, 0xd9, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x61, 0x00, 0x61, 0x00, 0x61, 0x00, 0x61, 0x00, 0x61, 0x00, 0x94, 0x00, 0xb9, 0x01, 0x3a, 0x01, + 0xae, 0x02, 0x40, 0x02, 0xd4, 0x02, 0xeb, 0x03, 0x15, 0x03, 0x3f, 0x03, 0x72, 0x03, 0x98, 0x03, 0xb7, 0x03, 0xce, + 0x03, 0xf0, 0x04, 0x07, 0x04, 0x55, 0x04, 0x83, 0x04, 0xd3, 0x05, 0x4a, 0x05, 0x8e, 0x05, 0xf0, 0x06, 0x51, 0x06, + 0x7e, 0x06, 0xf3, 0x07, 0x5b, 0x07, 0x70, 0x07, 0x85, 0x07, 0xa4, 0x07, 0xcc, 0x07, 0xeb, 0x08, 0x4a, 0x08, 0xef, + 0x09, 0x35, 0x09, 0x95, 0x09, 0xea, 0x0a, 0x30, 0x0a, 0x72, 0x0a, 0xa9, 0x0b, 0x16, 0x0b, 0x61, 0x0b, 0x7c, 0x0b, + 0xaf, 0x0c, 0x04, 0x0c, 0x28, 0x0c, 0x76, 0x0c, 0xb2, 0x0d, 0x08, 0x0d, 0x54, 0x0d, 0xba, 0x0e, 0x17, 0x0e, 0x83, + 0x0e, 0xae, 0x0e, 0xf0, 0x0f, 0x20, 0x0f, 0x75, 0x0f, 0xca, 0x0f, 0xfa, 0x10, 0x33, 0x10, 0x58, 0x10, 0x6f, 0x10, + 0x95, 0x10, 0xbc, 0x10, 0xd7, 0x10, 0xf7, 0x11, 0x71, 0x11, 0xd0, 0x12, 0x24, 0x12, 0x83, 0x12, 0xec, 0x13, 0x3f, + 0x13, 0xba, 0x14, 0x00, 0x14, 0x39, 0x14, 0x86, 0x14, 0xdd, 0x14, 0xf8, 0x15, 0x64, 0x15, 0xaf, 0x15, 0xfe, 0x16, + 0x63, 0x16, 0xc5, 0x17, 0x03, 0x17, 0x6f, 0x17, 0xc2, 0x18, 0x09, 0x18, 0x39, 0x18, 0x87, 0x18, 0xce, 0x19, 0x14, + 0x19, 0x4d, 0x19, 0x8e, 0x19, 0xa5, 0x19, 0xe5, 0x1a, 0x2d, 0x1a, 0x61, 0x1a, 0xbe, 0x1b, 0x31, 0x1b, 0x95, 0x1b, + 0xf7, 0x1c, 0x16, 0x1c, 0xbd, 0x1c, 0xec, 0x1d, 0x94, 0x1e, 0x04, 0x1e, 0x10, 0x1e, 0x2e, 0x1e, 0xe8, 0x1f, 0x02, + 0x1f, 0x3f, 0x1f, 0x83, 0x1f, 0xd4, 0x20, 0x50, 0x20, 0x70, 0x20, 0xba, 0x20, 0xe6, 0x21, 0x06, 0x21, 0x42, 0x21, + 0x74, 0x21, 0xbf, 0x21, 0xcb, 0x21, 0xe5, 0x21, 0xff, 0x22, 0x19, 0x22, 0x7b, 0x22, 0xe0, 0x23, 0x1e, 0x23, 0x9a, + 0x23, 0xef, 0x24, 0x60, 0x25, 0x20, 0x25, 0x90, 0x25, 0xe3, 0x26, 0x55, 0x26, 0xb5, 0x27, 0x2c, 0x27, 0x8b, 0x27, + 0xa6, 0x27, 0xf6, 0x28, 0x41, 0x28, 0x7f, 0x28, 0xd0, 0x29, 0x2c, 0x29, 0xb1, 0x2a, 0x4c, 0x2a, 0x7d, 0x2a, 0xe4, + 0x2b, 0x4c, 0x2b, 0xb7, 0x2c, 0x18, 0x2c, 0x6c, 0x2c, 0xc6, 0x2c, 0xf5, 0x2d, 0x5a, 0x2d, 0x88, 0x2d, 0xac, 0x2d, + 0xba, 0x2d, 0xe6, 0x2e, 0x06, 0x2e, 0x3f, 0x2e, 0x75, 0x2e, 0xba, 0x2e, 0xed, 0x2f, 0x2b, 0x2f, 0x48, 0x2f, 0x65, + 0x2f, 0x6e, 0x2f, 0xa1, 0x2f, 0xd2, 0x2f, 0xee, 0x30, 0x0a, 0x30, 0x4e, 0x30, 0x5a, 0x30, 0x81, 0x30, 0xaf, 0x31, + 0x2c, 0x31, 0x59, 0x31, 0x9d, 0x31, 0xcc, 0x32, 0x09, 0x32, 0x7e, 0x32, 0xd8, 0x33, 0x41, 0x33, 0xb7, 0x34, 0x2e, + 0x34, 0x61, 0x34, 0xd4, 0x35, 0x42, 0x35, 0x9f, 0x35, 0xea, 0x36, 0x6b, 0x36, 0x99, 0x36, 0xf3, 0x37, 0x63, 0x37, + 0xb5, 0x38, 0x10, 0x38, 0x6c, 0x38, 0xc4, 0x39, 0x08, 0x39, 0x4a, 0x39, 0xb4, 0x3a, 0x11, 0x3a, 0x78, 0x3a, 0xf0, + 0x3b, 0x44, 0x3b, 0xbb, 0x3c, 0x17, 0x3c, 0x92, 0x3d, 0x0a, 0x3d, 0x7e, 0x3d, 0xd3, 0x3e, 0x10, 0x3e, 0x69, 0x3e, + 0xc2, 0x3f, 0x31, 0x3f, 0xa8, 0x3f, 0xed, 0x40, 0x38, 0x40, 0x80, 0x40, 0xf2, 0x41, 0x28, 0x41, 0x6d, 0x41, 0xab, + 0x41, 0xf4, 0x42, 0x4d, 0x42, 0xb1, 0x42, 0xfe, 0x43, 0x7d, 0x44, 0x0f, 0x44, 0x6b, 0x44, 0xdc, 0x45, 0x54, 0x45, + 0x7b, 0x45, 0xd2, 0x46, 0x46, 0x46, 0xc1, 0x46, 0xfa, 0x47, 0x52, 0x47, 0x9a, 0x47, 0xe2, 0x48, 0x3f, 0x48, 0x6e, + 0x48, 0x9a, 0x49, 0x26, 0x49, 0x5c, 0x49, 0x9d, 0x49, 0xdb, 0x4a, 0x20, 0x4a, 0x78, 0x4a, 0xdb, 0x4b, 0x26, 0x4b, + 0x99, 0x4c, 0x20, 0x4c, 0x7c, 0x4c, 0xf5, 0x4d, 0x77, 0x4d, 0xee, 0x4e, 0x5d, 0x4e, 0xc5, 0x4f, 0x01, 0x4f, 0x64, + 0x4f, 0xc5, 0x50, 0x2e, 0x50, 0xb2, 0x51, 0x4e, 0x51, 0x9a, 0x51, 0xe9, 0x52, 0x54, 0x52, 0xc3, 0x53, 0x39, 0x53, + 0xa9, 0x54, 0x35, 0x54, 0xc0, 0x55, 0x52, 0x55, 0xed, 0x56, 0x70, 0x56, 0xea, 0x57, 0x2f, 0x57, 0x75, 0x57, 0xe2, + 0x58, 0x4a, 0x59, 0x05, 0x59, 0xc1, 0x5a, 0x41, 0x5a, 0xc1, 0x5b, 0x13, 0x5b, 0x61, 0x5b, 0x96, 0x5b, 0xb2, 0x5b, + 0xea, 0x5c, 0x00, 0x5c, 0x16, 0x5c, 0xea, 0x5d, 0x5d, 0x5d, 0x78, 0x5d, 0x93, 0x5d, 0xfd, 0x5e, 0x59, 0x5e, 0xcd, + 0x5e, 0xfd, 0x5f, 0x28, 0x5f, 0x7e, 0x5f, 0xd4, 0x5f, 0xe0, 0x5f, 0xec, 0x5f, 0xf8, 0x60, 0x04, 0x60, 0x5b, 0x60, + 0xbe, 0x61, 0x13, 0x61, 0x73, 0x61, 0x7f, 0x61, 0x8b, 0x61, 0xd6, 0x62, 0x40, 0x62, 0x9f, 0x62, 0xff, 0x63, 0xa0, + 0x64, 0x39, 0x64, 0x45, 0x64, 0x51, 0x64, 0xa2, 0x64, 0xe6, 0x64, 0xf2, 0x64, 0xfe, 0x65, 0x4e, 0x65, 0x9c, 0x65, + 0xde, 0x66, 0x50, 0x66, 0xc2, 0x67, 0x1b, 0x67, 0x80, 0x67, 0x8c, 0x67, 0x98, 0x68, 0x12, 0x68, 0x8a, 0x68, 0x96, + 0x68, 0xa2, 0x68, 0xae, 0x68, 0xba, 0x69, 0x24, 0x69, 0x85, 0x69, 0xe0, 0x69, 0xef, 0x6a, 0x03, 0x6a, 0x0f, 0x6a, + 0x1b, 0x6a, 0x69, 0x6a, 0xcd, 0x6b, 0x55, 0x6b, 0xc7, 0x6c, 0x36, 0x6c, 0x9a, 0x6c, 0xfc, 0x6d, 0x6b, 0x6d, 0xd6, + 0x6e, 0x60, 0x6e, 0xe3, 0x6f, 0x40, 0x6f, 0x93, 0x6f, 0xe6, 0x70, 0x38, 0x70, 0xaf, 0x70, 0xbb, 0x70, 0xc7, 0x70, + 0xf6, 0x70, 0xf6, 0x70, 0xf6, 0x70, 0xf6, 0x70, 0xf6, 0x70, 0xf6, 0x70, 0xf6, 0x70, 0xf6, 0x70, 0xf6, 0x70, 0xf6, + 0x70, 0xf6, 0x70, 0xf6, 0x70, 0xf6, 0x70, 0xf6, 0x70, 0xfe, 0x71, 0x06, 0x71, 0x10, 0x71, 0x1a, 0x71, 0x32, 0x71, + 0x56, 0x71, 0x7a, 0x71, 0x9d, 0x71, 0xb8, 0x71, 0xc4, 0x71, 0xd0, 0x72, 0x08, 0x72, 0x47, 0x72, 0xa9, 0x72, 0xcd, + 0x72, 0xd9, 0x72, 0xe9, 0x73, 0x0c, 0x73, 0xdf, 0x73, 0xfb, 0x74, 0x18, 0x74, 0x2b, 0x74, 0x3f, 0x74, 0x86, 0x75, + 0x10, 0x75, 0xae, 0x76, 0x3f, 0x76, 0x4b, 0x77, 0x2b, 0x77, 0x8f, 0x78, 0x0d, 0x78, 0xac, 0x79, 0x10, 0x79, 0x8b, + 0x79, 0xe5, 0x7a, 0x51, 0x7b, 0x03, 0x7b, 0x6a, 0x7c, 0x00, 0x7c, 0x5e, 0x7c, 0xc2, 0x7c, 0xdc, 0x7c, 0xf6, 0x7d, + 0x10, 0x7d, 0x2a, 0x7d, 0x9c, 0x7d, 0xc3, 0x7d, 0xfc, 0x7e, 0x18, 0x7e, 0x4d, 0x7e, 0xe0, 0x7f, 0x22, 0x7f, 0xaf, + 0x7f, 0xf0, 0x80, 0x0e, 0x80, 0x2c, 0x80, 0x65, 0x80, 0x72, 0x80, 0x9c, 0x80, 0xbf, 0x80, 0xcb, 0x81, 0x34, 0x81, + 0x87, 0x82, 0x14, 0x82, 0x83, 0x82, 0xf6, 0x83, 0xc3, 0x83, 0xc3, 0x85, 0x76, 0x85, 0xe2, 0x86, 0x32, 0x86, 0x5e, + 0x86, 0xa8, 0x87, 0x06, 0x87, 0x7d, 0x87, 0xae, 0x88, 0x15, 0x88, 0x79, 0x88, 0xc0, 0x89, 0x3e, 0x89, 0x92, 0x89, + 0xc4, 0x8a, 0x12, 0x8a, 0x4b, 0x8a, 0x7b, 0x8a, 0xc4, 0x8b, 0x1c, 0x8b, 0x4c, 0x8b, 0x8a, 0x8b, 0xb5, 0x8c, 0x1c, + 0x8c, 0x75, 0x8c, 0xd4, 0x8d, 0x1f, 0x8d, 0x73, 0x8d, 0xac, 0x8d, 0xfd, 0x8e, 0x21, 0x8e, 0x64, 0x8e, 0x9a, 0x8e, + 0xb5, 0x8e, 0xf6, 0x8f, 0x56, 0x8f, 0x8e, 0x90, 0x02, 0x90, 0x67, 0x90, 0xc6, 0x90, 0xf0, 0x91, 0x26, 0x91, 0x8e, + 0x91, 0xc0, 0x92, 0x0e, 0x92, 0x40, 0x92, 0x80, 0x92, 0xe7, 0x93, 0x3f, 0x93, 0xa1, 0x94, 0x00, 0x94, 0x72, 0x94, + 0xe8, 0x95, 0x5e, 0x95, 0xb1, 0x95, 0xf1, 0x96, 0x4a, 0x96, 0xa2, 0x97, 0x16, 0x97, 0x91, 0x97, 0xcd, 0x98, 0x1d, + 0x98, 0x66, 0x98, 0xac, 0x98, 0xe7, 0x99, 0x29, 0x99, 0x69, 0x99, 0xb3, 0x9a, 0x0d, 0x9a, 0x19, 0x9a, 0x67, 0x9a, + 0xd7, 0x9b, 0x55, 0x9b, 0xad, 0x9b, 0xf0, 0x9c, 0x76, 0x9c, 0xd8, 0x9d, 0x39, 0x9d, 0x97, 0x9e, 0x2c, 0x9e, 0x3d, + 0x9e, 0x98, 0x9e, 0xe5, 0x9f, 0x33, 0x9f, 0x75, 0x9f, 0xe6, 0xa0, 0x4a, 0xa0, 0xb0, 0xa1, 0x21, 0xa1, 0xb5, 0xa2, + 0x3b, 0xa2, 0xd2, 0xa3, 0x45, 0xa3, 0xb5, 0xa3, 0xf8, 0xa4, 0x55, 0xa4, 0xaf, 0xa4, 0xdc, 0xa5, 0x59, 0xa5, 0xb8, + 0xa5, 0xcf, 0xa6, 0x35, 0xa6, 0x7a, 0xa7, 0x25, 0xa7, 0x89, 0xa7, 0xed, 0xa8, 0x3d, 0xa8, 0x83, 0xa8, 0xc4, 0xa9, + 0x06, 0xa9, 0x4e, 0xa9, 0xa3, 0xaa, 0x0a, 0xaa, 0x4a, 0xaa, 0x64, 0xaa, 0xb3, 0xab, 0x28, 0xab, 0x70, 0xab, 0xb8, + 0xac, 0x18, 0xac, 0x86, 0xac, 0xb3, 0xad, 0x02, 0xad, 0x62, 0xad, 0x76, 0xad, 0x8a, 0xad, 0x9c, 0xad, 0xb0, 0xad, + 0xc2, 0xad, 0xd9, 0xad, 0xed, 0xae, 0x49, 0xae, 0xbb, 0xaf, 0x08, 0xaf, 0x68, 0xaf, 0xd1, 0xaf, 0xfc, 0xb0, 0x50, + 0xb0, 0xa2, 0xb0, 0xe6, 0xb1, 0x3d, 0xb1, 0x64, 0xb1, 0xd5, 0xb1, 0xeb, 0xb2, 0x6f, 0xb2, 0xd2, 0xb2, 0xfe, 0xb3, + 0x0f, 0xb3, 0x20, 0xb3, 0x33, 0xb3, 0x44, 0xb3, 0x55, 0xb3, 0x68, 0xb3, 0x7b, 0xb3, 0x8e, 0xb3, 0xa4, 0xb3, 0xac, + 0xb3, 0xb4, 0xb3, 0xbc, 0xb3, 0xcd, 0xb3, 0xd8, 0xb3, 0xe0, 0xb4, 0x48, 0xb4, 0x97, 0xb4, 0xc4, 0xb5, 0x25, 0xb5, + 0x78, 0xb5, 0xd9, 0xb6, 0x54, 0xb6, 0x9e, 0xb7, 0x04, 0xb7, 0x66, 0xb7, 0xca, 0xb8, 0x43, 0xb8, 0x4b, 0xb8, 0xe6, + 0xb9, 0x33, 0xb9, 0x9f, 0xb9, 0xef, 0xba, 0x68, 0xba, 0xd6, 0xbb, 0x27, 0xbb, 0x27, 0xbb, 0x2f, 0xbb, 0x95, 0xbb, + 0xfb, 0xbc, 0x5a, 0xbc, 0x9d, 0xbd, 0x03, 0xbd, 0x1a, 0xbd, 0x31, 0xbd, 0x48, 0xbd, 0x5f, 0xbd, 0x78, 0xbd, 0x91, + 0xbd, 0x9d, 0xbd, 0xa9, 0xbd, 0xc0, 0xbd, 0xd7, 0xbd, 0xee, 0xbe, 0x07, 0xbe, 0x1e, 0xbe, 0x35, 0xbe, 0x4c, 0xbe, + 0x65, 0xbe, 0x7c, 0xbe, 0x93, 0xbe, 0xaa, 0xbe, 0xc1, 0xbe, 0xd8, 0xbe, 0xf1, 0xbf, 0x08, 0xbf, 0x1f, 0xbf, 0x36, + 0xbf, 0x4f, 0xbf, 0x66, 0xbf, 0x7d, 0xbf, 0x94, 0xbf, 0xaa, 0xbf, 0xc0, 0xbf, 0xd9, 0xbf, 0xf2, 0xbf, 0xfe, 0xc0, + 0x0a, 0xc0, 0x21, 0xc0, 0x38, 0xc0, 0x4e, 0xc0, 0x67, 0xc0, 0x7d, 0xc0, 0x93, 0xc0, 0xaa, 0xc0, 0xc3, 0xc0, 0xd9, + 0xc0, 0xf0, 0xc1, 0x07, 0xc1, 0x1d, 0xc1, 0x33, 0xc1, 0x4c, 0xc1, 0x63, 0xc1, 0x7a, 0xc1, 0x90, 0xc1, 0xa9, 0xc1, + 0xc0, 0xc1, 0xd8, 0xc1, 0xef, 0xc2, 0x05, 0xc2, 0x1c, 0xc2, 0x33, 0xc2, 0x97, 0xc3, 0x2f, 0xc3, 0x46, 0xc3, 0x5d, + 0xc3, 0x74, 0xc3, 0x8a, 0xc3, 0xa1, 0xc3, 0xb8, 0xc3, 0xcf, 0xc3, 0xe5, 0xc3, 0xfc, 0xc4, 0x2d, 0xc4, 0x44, 0xc4, + 0x5a, 0xc4, 0x71, 0xc4, 0x88, 0xc4, 0x9f, 0xc4, 0xb6, 0xc5, 0x20, 0xc5, 0xa6, 0xc5, 0xbd, 0xc5, 0xd3, 0xc5, 0xea, + 0xc6, 0x00, 0xc6, 0x17, 0xc6, 0x2e, 0xc6, 0x45, 0xc6, 0x5c, 0xc6, 0x68, 0xc6, 0x7f, 0xc6, 0x96, 0xc6, 0xa8, 0xc6, + 0xbf, 0xc6, 0xd6, 0xc6, 0xed, 0xc7, 0x04, 0xc7, 0x1b, 0xc7, 0x32, 0xc7, 0x3d, 0xc7, 0x48, 0xc7, 0x5f, 0xc7, 0x6b, + 0xc7, 0x77, 0xc7, 0x8e, 0xc7, 0xa5, 0xc7, 0xb1, 0xc7, 0xbd, 0xc7, 0xd4, 0xc7, 0xeb, 0xc7, 0xf7, 0xc8, 0x03, 0xc8, + 0x18, 0xc8, 0x4d, 0xc8, 0x59, 0xc8, 0x65, 0xc8, 0x7c, 0xc8, 0x93, 0xc8, 0x9f, 0xc8, 0xab, 0xc8, 0xc2, 0xc8, 0xd8, + 0xc8, 0xed, 0xc9, 0x04, 0xc9, 0x1a, 0xc9, 0x31, 0xc9, 0x48, 0xc9, 0x61, 0xc9, 0x7a, 0xc9, 0x91, 0xc9, 0xa8, 0xc9, + 0xb4, 0xc9, 0xc0, 0xc9, 0xd7, 0xc9, 0xed, 0xca, 0x04, 0xca, 0x1b, 0xca, 0x32, 0xca, 0x48, 0xca, 0x54, 0xca, 0x60, + 0xca, 0x6c, 0xca, 0x78, 0xca, 0x8f, 0xca, 0xa5, 0xca, 0xb1, 0xca, 0xbd, 0xca, 0xc9, 0xca, 0xd5, 0xca, 0xec, 0xcb, + 0x02, 0xcb, 0x19, 0xcb, 0x2f, 0xcb, 0x46, 0xcb, 0x5c, 0xcb, 0x73, 0xcb, 0x8a, 0xcb, 0xa3, 0xcb, 0xbc, 0xcb, 0xd5, + 0xcb, 0xee, 0xcc, 0x4c, 0xcc, 0xb3, 0xcc, 0xca, 0xcc, 0xe1, 0xcc, 0xf8, 0xcd, 0x0e, 0xcd, 0x27, 0xcd, 0x3e, 0xcd, + 0x55, 0xcd, 0x6c, 0xcd, 0x83, 0xcd, 0x9a, 0xcd, 0xb0, 0xcd, 0xc7, 0xcd, 0xde, 0xcd, 0xf5, 0xce, 0x0c, 0xce, 0x2f, + 0xce, 0x57, 0xce, 0x6a, 0xce, 0x81, 0xce, 0x98, 0xce, 0xae, 0xce, 0xc4, 0xce, 0xdd, 0xce, 0xf6, 0xcf, 0x02, 0xcf, + 0x0e, 0xcf, 0x25, 0xcf, 0x3c, 0xcf, 0x52, 0xcf, 0x6a, 0xcf, 0x80, 0xcf, 0x96, 0xcf, 0xad, 0xcf, 0xc6, 0xcf, 0xdd, + 0xcf, 0xf4, 0xd0, 0x0b, 0xd0, 0x22, 0xd0, 0x39, 0xd0, 0x52, 0xd0, 0x69, 0xd0, 0x80, 0xd0, 0x96, 0xd0, 0xaf, 0xd0, + 0xc6, 0xd0, 0xdc, 0xd0, 0xf3, 0xd1, 0x57, 0xd1, 0x6e, 0xd1, 0x84, 0xd1, 0x9b, 0xd1, 0xb2, 0xd1, 0xc8, 0xd1, 0xde, + 0xd1, 0xf4, 0xd2, 0x0b, 0xd2, 0x76, 0xd2, 0x8c, 0xd2, 0xa2, 0xd2, 0xb9, 0xd2, 0xd0, 0xd2, 0xdc, 0xd2, 0xf3, 0xd3, + 0x0a, 0xd3, 0x21, 0xd3, 0x38, 0xd3, 0x43, 0xd3, 0x59, 0xd3, 0x70, 0xd3, 0x7c, 0xd3, 0x92, 0xd3, 0x9e, 0xd3, 0xb3, + 0xd3, 0xbf, 0xd3, 0xd6, 0xd3, 0xe2, 0xd3, 0xf9, 0xd4, 0x10, 0xd4, 0x27, 0xd4, 0x40, 0xd4, 0x57, 0xd4, 0x63, 0xd4, + 0x79, 0xd4, 0x90, 0xd4, 0xa6, 0xd4, 0xb2, 0xd4, 0xc8, 0xd4, 0xd4, 0xd4, 0xea, 0xd4, 0xf6, 0xd5, 0x0c, 0xd5, 0x22, + 0xd5, 0x39, 0xd5, 0x52, 0xd5, 0x6b, 0xd5, 0xc8, 0xd5, 0xdf, 0xd5, 0xf5, 0xd6, 0x0d, 0xd6, 0x24, 0xd6, 0x3b, 0xd6, + 0x51, 0xd6, 0x5c, 0xd6, 0x68, 0xd6, 0x74, 0xd6, 0x80, 0xd6, 0x8c, 0xd6, 0x98, 0xd6, 0xa4, 0xd6, 0xc0, 0xd6, 0xc8, + 0xd6, 0xd0, 0xd6, 0xd8, 0xd6, 0xe0, 0xd6, 0xe8, 0xd6, 0xf0, 0xd6, 0xf8, 0xd7, 0x00, 0xd7, 0x08, 0xd7, 0x10, 0xd7, + 0x18, 0xd7, 0x20, 0xd7, 0x28, 0xd7, 0x30, 0xd7, 0x49, 0xd7, 0x62, 0xd7, 0x79, 0xd7, 0x90, 0xd7, 0xa7, 0xd7, 0xbd, + 0xd7, 0xd8, 0xd7, 0xe0, 0xd7, 0xe8, 0xd7, 0xf0, 0xd7, 0xf8, 0xd8, 0x63, 0xd8, 0x7b, 0xd8, 0x93, 0xd8, 0xaa, 0xd8, + 0xc1, 0xd8, 0xd8, 0xd8, 0xf1, 0xd9, 0x08, 0xd9, 0x74, 0xd9, 0x7c, 0xd9, 0x95, 0xd9, 0x9d, 0xd9, 0xa5, 0xd9, 0xbc, + 0xd9, 0xd3, 0xd9, 0xdb, 0xd9, 0xe3, 0xd9, 0xeb, 0xd9, 0xf3, 0xda, 0x0a, 0xda, 0x12, 0xda, 0x1a, 0xda, 0x22, 0xda, + 0x2a, 0xda, 0x32, 0xda, 0x3a, 0xda, 0x42, 0xda, 0x4a, 0xda, 0x52, 0xda, 0x5a, 0xda, 0x71, 0xda, 0x79, 0xda, 0x81, + 0xda, 0xd5, 0xda, 0xdd, 0xda, 0xe5, 0xda, 0xfe, 0xdb, 0x15, 0xdb, 0x1d, 0xdb, 0x25, 0xdb, 0x3e, 0xdb, 0x46, 0xdb, + 0x5d, 0xdb, 0x73, 0xdb, 0x8a, 0xdb, 0xa1, 0xdb, 0xb8, 0xdb, 0xcf, 0xdb, 0xe8, 0xdc, 0x01, 0xdc, 0x18, 0xdc, 0x2f, + 0xdc, 0x37, 0xdc, 0x3f, 0xdc, 0x4b, 0xdc, 0x62, 0xdc, 0x6a, 0xdc, 0x81, 0xdc, 0x98, 0xdc, 0xa4, 0xdc, 0xb0, 0xdc, + 0xc7, 0xdc, 0xde, 0xdc, 0xf5, 0xdd, 0x0c, 0xdd, 0x14, 0xdd, 0x1c, 0xdd, 0x35, 0xdd, 0x4e, 0xdd, 0x5a, 0xdd, 0x66, + 0xdd, 0x72, 0xdd, 0x7e, 0xdd, 0x8a, 0xdd, 0x96, 0xdd, 0x9e, 0xdd, 0xa6, 0xdd, 0xae, 0xdd, 0xc5, 0xdd, 0xdc, 0xdd, + 0xe4, 0xdd, 0xfb, 0xde, 0x12, 0xde, 0x2b, 0xde, 0x44, 0xde, 0x4c, 0xde, 0x54, 0xde, 0x6b, 0xde, 0x82, 0xde, 0x9b, + 0xde, 0xa3, 0xde, 0xbc, 0xde, 0xd5, 0xde, 0xee, 0xdf, 0x07, 0xdf, 0x1f, 0xdf, 0x36, 0xdf, 0x4c, 0xdf, 0x65, 0xdf, + 0x7e, 0xdf, 0x97, 0xdf, 0xb0, 0xdf, 0xb8, 0xdf, 0xc0, 0xdf, 0xd9, 0xdf, 0xf2, 0xe0, 0x0b, 0xe0, 0x23, 0xe0, 0x3a, + 0xe0, 0x50, 0xe0, 0x69, 0xe0, 0x81, 0xe0, 0x9a, 0xe0, 0xb3, 0xe0, 0xcc, 0xe0, 0xe4, 0xe1, 0x01, 0xe1, 0x1e, 0xe1, + 0x26, 0xe1, 0x32, 0xe1, 0x3e, 0xe1, 0x55, 0xe1, 0x6c, 0xe1, 0x85, 0xe1, 0x9d, 0xe1, 0xb6, 0xe1, 0xce, 0xe1, 0xe7, + 0xe1, 0xff, 0xe2, 0x18, 0xe2, 0x30, 0xe2, 0x4b, 0xe2, 0x65, 0xe2, 0x7e, 0xe2, 0x97, 0xe2, 0xb0, 0xe2, 0xc9, 0xe2, + 0xe2, 0xe2, 0xfb, 0xe3, 0x14, 0xe3, 0x2d, 0xe3, 0x48, 0xe3, 0x63, 0xe3, 0x6f, 0xe3, 0x7b, 0xe3, 0x92, 0xe3, 0xa9, + 0xe3, 0xc0, 0xe3, 0xd6, 0xe3, 0xef, 0xe4, 0x07, 0xe4, 0x20, 0xe4, 0x38, 0xe4, 0x51, 0xe4, 0x69, 0xe4, 0x82, 0xe4, + 0x9a, 0xe4, 0xb5, 0xe4, 0xcf, 0xe4, 0xe6, 0xe4, 0xfd, 0xe5, 0x09, 0xe5, 0x15, 0xe5, 0x21, 0xe5, 0x2d, 0xe5, 0x44, + 0xe5, 0x5b, 0xe5, 0x74, 0xe5, 0x8c, 0xe5, 0xa5, 0xe5, 0xbd, 0xe5, 0xd6, 0xe5, 0xee, 0xe6, 0x07, 0xe6, 0x1f, 0xe6, + 0x3a, 0xe6, 0x54, 0xe6, 0x6b, 0xe6, 0x82, 0xe6, 0x99, 0xe6, 0xb0, 0xe6, 0xc7, 0xe6, 0xde, 0xe6, 0xf5, 0xe7, 0x0b, + 0xe7, 0x17, 0xe7, 0x23, 0xe7, 0x2f, 0xe7, 0x3b, 0xe7, 0x52, 0xe7, 0x69, 0xe7, 0x80, 0xe7, 0x97, 0xe7, 0xae, 0xe7, + 0xc5, 0xe7, 0xdc, 0xe7, 0xf3, 0xe8, 0x0a, 0xe8, 0x20, 0xe8, 0x2c, 0xe8, 0x38, 0xe8, 0x44, 0xe8, 0x50, 0xe8, 0x67, + 0xe8, 0x7e, 0xe8, 0x95, 0xe8, 0xab, 0xe8, 0xc0, 0xe8, 0xcc, 0xe8, 0xd8, 0xe8, 0xe4, 0xe8, 0xf0, 0xe8, 0xfc, 0xe9, + 0x08, 0xe9, 0x14, 0xe9, 0x20, 0xe9, 0x28, 0xe9, 0x88, 0xe9, 0xe8, 0xea, 0x2b, 0xea, 0x6b, 0xea, 0xcf, 0xeb, 0x2e, + 0xeb, 0x78, 0xeb, 0xc8, 0xec, 0x21, 0xec, 0x78, 0xec, 0x80, 0xec, 0x8c, 0xec, 0x96, 0xec, 0x9e, 0xec, 0xa6, 0xec, + 0xae, 0xec, 0xb6, 0xec, 0xbe, 0xec, 0xc6, 0xec, 0xce, 0xec, 0xd6, 0xec, 0xed, 0xed, 0x04, 0xed, 0x1b, 0xed, 0x32, + 0xed, 0x4b, 0xed, 0x64, 0xed, 0x7d, 0xed, 0x96, 0xed, 0xaf, 0xed, 0xc8, 0xed, 0xe1, 0xed, 0xfa, 0xee, 0x13, 0xee, + 0x2c, 0xee, 0x45, 0xee, 0x5e, 0xee, 0x6a, 0xee, 0x76, 0xee, 0x82, 0xee, 0x8e, 0xee, 0x9a, 0xee, 0xab, 0xee, 0xb7, + 0xee, 0xc3, 0xee, 0xcf, 0xee, 0xe6, 0xee, 0xf8, 0xef, 0x04, 0xef, 0x10, 0xef, 0x1c, 0xef, 0x28, 0xef, 0x34, 0xef, + 0x40, 0xef, 0x4c, 0xef, 0x58, 0xef, 0x7a, 0xef, 0x91, 0xef, 0xa8, 0xef, 0xb4, 0xef, 0xc0, 0xef, 0xcc, 0xef, 0xd8, + 0xef, 0xe4, 0xef, 0xf0, 0xf0, 0x08, 0xf0, 0x1f, 0xf0, 0x35, 0xf0, 0x41, 0xf0, 0x4d, 0xf0, 0x59, 0xf0, 0x65, 0xf0, + 0x71, 0xf0, 0x7d, 0xf0, 0x89, 0xf0, 0x95, 0xf0, 0xa1, 0xf0, 0xad, 0xf0, 0xb9, 0xf0, 0xc5, 0xf0, 0xd1, 0xf0, 0xdd, + 0xf0, 0xe5, 0xf0, 0xed, 0xf0, 0xf5, 0xf0, 0xfd, 0xf1, 0x05, 0xf1, 0x0d, 0xf1, 0x15, 0xf1, 0x1d, 0xf1, 0x25, 0xf1, + 0x2d, 0xf1, 0x35, 0xf1, 0x3d, 0xf1, 0x45, 0xf1, 0x4d, 0xf1, 0x66, 0xf1, 0x7e, 0xf1, 0x96, 0xf1, 0xad, 0xf1, 0xb5, + 0xf1, 0xbd, 0xf1, 0xd6, 0xf1, 0xde, 0xf1, 0xf5, 0xf2, 0x0b, 0xf2, 0x13, 0xf2, 0x1b, 0xf2, 0x23, 0xf2, 0x2b, 0xf2, + 0x42, 0xf2, 0x4a, 0xf2, 0x52, 0xf2, 0x5a, 0xf2, 0x62, 0xf2, 0x6a, 0xf2, 0x72, 0xf2, 0x7a, 0xf2, 0x82, 0xf3, 0x0d, + 0xf3, 0x5a, 0xf3, 0xb9, 0xf3, 0xc1, 0xf3, 0xcd, 0xf3, 0xe4, 0xf3, 0xfa, 0xf4, 0x02, 0xf4, 0x0e, 0xf4, 0x1a, 0xf4, + 0x26, 0xf4, 0x32, 0xf4, 0x3e, 0xf4, 0x4a, 0xf4, 0x56, 0xf4, 0x62, 0xf4, 0x6e, 0xf4, 0x7a, 0xf4, 0x86, 0xf4, 0x92, + 0xf4, 0x9e, 0xf4, 0xaa, 0xf4, 0xb6, 0x00, 0x00, 0x00, 0x05, 0x00, 0x64, 0x00, 0x00, 0x03, 0x28, 0x05, 0xb0, 0x00, + 0x03, 0x00, 0x06, 0x00, 0x09, 0x00, 0x0c, 0x00, 0x0f, 0x00, 0x71, 0xb2, 0x0c, 0x10, 0x11, 0x11, 0x12, 0x39, 0xb0, + 0x0c, 0x10, 0xb0, 0x00, 0xd0, 0xb0, 0x0c, 0x10, 0xb0, 0x06, 0xd0, 0xb0, 0x0c, 0x10, 0xb0, 0x09, 0xd0, 0xb0, 0x0c, + 0x10, 0xb0, 0x0d, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1e, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb2, 0x04, 0x02, 0x00, 0x11, 0x12, 0x39, + 0xb2, 0x05, 0x02, 0x00, 0x11, 0x12, 0x39, 0xb2, 0x07, 0x02, 0x00, 0x11, 0x12, 0x39, 0xb2, 0x08, 0x02, 0x00, 0x11, + 0x12, 0x39, 0xb1, 0x0a, 0x0c, 0xf4, 0xb2, 0x0c, 0x02, 0x00, 0x11, 0x12, 0x39, 0xb2, 0x0d, 0x02, 0x00, 0x11, 0x12, + 0x39, 0xb0, 0x02, 0x10, 0xb1, 0x0e, 0x0c, 0xf4, 0x30, 0x31, 0x21, 0x21, 0x11, 0x21, 0x03, 0x11, 0x01, 0x01, 0x11, + 0x01, 0x03, 0x21, 0x01, 0x35, 0x01, 0x21, 0x03, 0x28, 0xfd, 0x3c, 0x02, 0xc4, 0x36, 0xfe, 0xee, 0xfe, 0xba, 0x01, + 0x0c, 0xe4, 0x02, 0x03, 0xfe, 0xfe, 0x01, 0x02, 0xfd, 0xfd, 0x05, 0xb0, 0xfa, 0xa4, 0x05, 0x07, 0xfd, 0x7d, 0x02, + 0x77, 0xfb, 0x11, 0x02, 0x78, 0xfd, 0x5e, 0x02, 0x5e, 0x88, 0x02, 0x5e, 0x00, 0x02, 0x00, 0xa0, 0xff, 0xf5, 0x01, + 0x7b, 0x05, 0xb0, 0x00, 0x03, 0x00, 0x0c, 0x00, 0x30, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, + 0x02, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x12, 0x3e, 0x59, 0xb1, 0x06, + 0x05, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x01, 0x06, 0x02, 0x11, 0x12, 0x39, 0x30, 0x31, + 0x01, 0x23, 0x03, 0x33, 0x03, 0x34, 0x36, 0x32, 0x16, 0x14, 0x06, 0x22, 0x26, 0x01, 0x5b, 0xa7, 0x0d, 0xc2, 0xc9, + 0x37, 0x6c, 0x38, 0x38, 0x6c, 0x37, 0x01, 0x9b, 0x04, 0x15, 0xfa, 0xad, 0x2d, 0x3d, 0x3d, 0x5a, 0x3b, 0x3b, 0x00, + 0x00, 0x02, 0x00, 0x88, 0x04, 0x12, 0x02, 0x23, 0x06, 0x00, 0x00, 0x04, 0x00, 0x09, 0x00, 0x19, 0x00, 0xb0, 0x03, + 0x2f, 0xb2, 0x02, 0x0a, 0x03, 0x11, 0x12, 0x39, 0xb0, 0x02, 0x2f, 0xb0, 0x07, 0xd0, 0xb0, 0x03, 0x10, 0xb0, 0x08, + 0xd0, 0x30, 0x31, 0x01, 0x03, 0x23, 0x13, 0x33, 0x05, 0x03, 0x23, 0x13, 0x33, 0x01, 0x15, 0x1e, 0x6f, 0x01, 0x8c, + 0x01, 0x0e, 0x1e, 0x6f, 0x01, 0x8c, 0x05, 0x78, 0xfe, 0x9a, 0x01, 0xee, 0x88, 0xfe, 0x9a, 0x01, 0xee, 0x00, 0x02, + 0x00, 0x77, 0x00, 0x00, 0x04, 0xd3, 0x05, 0xb0, 0x00, 0x1b, 0x00, 0x1f, 0x00, 0x91, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, + 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x1a, 0x2f, 0x1b, 0xb1, 0x1a, 0x12, 0x3e, 0x59, 0xb2, 0x1d, 0x0c, 0x02, 0x11, 0x12, 0x39, 0x7c, 0xb0, + 0x1d, 0x2f, 0x18, 0xb1, 0x00, 0x03, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0xd0, 0xb0, + 0x1d, 0x10, 0xb0, 0x06, 0xd0, 0xb0, 0x1d, 0x10, 0xb0, 0x0b, 0xd0, 0xb0, 0x0b, 0x2f, 0xb1, 0x08, 0x03, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0b, 0x10, 0xb0, 0x0e, 0xd0, 0xb0, 0x0b, 0x10, 0xb0, 0x12, 0xd0, + 0xb0, 0x08, 0x10, 0xb0, 0x14, 0xd0, 0xb0, 0x1d, 0x10, 0xb0, 0x16, 0xd0, 0xb0, 0x00, 0x10, 0xb0, 0x18, 0xd0, 0xb0, + 0x08, 0x10, 0xb0, 0x1e, 0xd0, 0x30, 0x31, 0x01, 0x21, 0x03, 0x23, 0x13, 0x23, 0x35, 0x21, 0x13, 0x21, 0x35, 0x21, + 0x13, 0x33, 0x03, 0x21, 0x13, 0x33, 0x03, 0x33, 0x15, 0x23, 0x03, 0x33, 0x15, 0x23, 0x03, 0x23, 0x03, 0x21, 0x13, + 0x21, 0x02, 0xfd, 0xfe, 0xf8, 0x50, 0x8f, 0x50, 0xef, 0x01, 0x09, 0x45, 0xfe, 0xfe, 0x01, 0x1d, 0x52, 0x8f, 0x52, + 0x01, 0x08, 0x52, 0x90, 0x52, 0xcc, 0xe7, 0x45, 0xe1, 0xfb, 0x50, 0x90, 0x9e, 0x01, 0x08, 0x45, 0xfe, 0xf8, 0x01, + 0x9a, 0xfe, 0x66, 0x01, 0x9a, 0x89, 0x01, 0x62, 0x8b, 0x01, 0xa0, 0xfe, 0x60, 0x01, 0xa0, 0xfe, 0x60, 0x8b, 0xfe, + 0x9e, 0x89, 0xfe, 0x66, 0x02, 0x23, 0x01, 0x62, 0x00, 0x00, 0x01, 0x00, 0x6e, 0xff, 0x30, 0x04, 0x11, 0x06, 0x9c, + 0x00, 0x2b, 0x00, 0x69, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x1e, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x22, 0x2f, 0x1b, 0xb1, 0x22, 0x12, 0x3e, 0x59, 0xb2, 0x02, 0x22, 0x09, 0x11, 0x12, 0x39, + 0xb0, 0x09, 0x10, 0xb0, 0x0c, 0xd0, 0xb0, 0x09, 0x10, 0xb0, 0x10, 0xd0, 0xb0, 0x09, 0x10, 0xb1, 0x13, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x02, 0x10, 0xb1, 0x19, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x22, 0x10, 0xb0, 0x1f, 0xd0, 0xb0, 0x22, 0x10, 0xb0, 0x26, 0xd0, 0xb0, 0x22, 0x10, + 0xb1, 0x29, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x34, 0x26, 0x27, 0x26, + 0x26, 0x35, 0x34, 0x36, 0x37, 0x35, 0x33, 0x15, 0x16, 0x16, 0x15, 0x23, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x14, + 0x16, 0x04, 0x16, 0x16, 0x15, 0x14, 0x06, 0x07, 0x15, 0x23, 0x35, 0x26, 0x26, 0x35, 0x33, 0x14, 0x16, 0x33, 0x32, + 0x36, 0x03, 0x58, 0x81, 0x99, 0xd5, 0xc3, 0xbf, 0xa7, 0x95, 0xa8, 0xbb, 0xb8, 0x86, 0x72, 0x77, 0x7e, 0x85, 0x01, + 0x31, 0xab, 0x51, 0xcb, 0xb7, 0x94, 0xba, 0xd3, 0xb9, 0x92, 0x86, 0x83, 0x96, 0x01, 0x77, 0x5c, 0x7e, 0x33, 0x41, + 0xd1, 0xa1, 0xa4, 0xd2, 0x14, 0xdb, 0xdc, 0x17, 0xec, 0xcd, 0x8d, 0xa6, 0x7b, 0x6e, 0x66, 0x79, 0x63, 0x77, 0x9e, + 0x6a, 0xa9, 0xce, 0x13, 0xbf, 0xbf, 0x11, 0xe7, 0xc6, 0x8b, 0x96, 0x7e, 0x00, 0x00, 0x05, 0x00, 0x69, 0xff, 0xeb, + 0x05, 0x83, 0x05, 0xc5, 0x00, 0x0d, 0x00, 0x1a, 0x00, 0x26, 0x00, 0x34, 0x00, 0x38, 0x00, 0x7c, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x23, 0x2f, 0x1b, + 0xb1, 0x23, 0x12, 0x3e, 0x59, 0xb0, 0x03, 0x10, 0xb0, 0x0a, 0xd0, 0xb0, 0x0a, 0x2f, 0xb1, 0x11, 0x04, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x18, 0x04, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x23, 0x10, 0xb0, 0x1d, 0xd0, 0xb0, 0x1d, 0x2f, 0xb0, 0x23, 0x10, 0xb1, 0x2a, 0x04, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x1d, 0x10, 0xb1, 0x31, 0x04, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x35, 0x23, 0x03, 0x11, 0x12, 0x39, 0xb0, 0x35, 0x2f, 0xb2, 0x37, 0x03, 0x23, 0x11, + 0x12, 0x39, 0xb0, 0x37, 0x2f, 0x30, 0x31, 0x13, 0x34, 0x36, 0x33, 0x32, 0x16, 0x15, 0x15, 0x14, 0x06, 0x23, 0x22, + 0x26, 0x35, 0x17, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x35, 0x34, 0x26, 0x22, 0x06, 0x15, 0x01, 0x34, 0x36, 0x20, + 0x16, 0x15, 0x15, 0x14, 0x06, 0x20, 0x26, 0x35, 0x17, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x35, 0x34, 0x26, 0x23, + 0x22, 0x06, 0x15, 0x05, 0x27, 0x01, 0x17, 0x69, 0xa7, 0x83, 0x85, 0xa5, 0xa7, 0x81, 0x82, 0xaa, 0x8a, 0x58, 0x4a, + 0x47, 0x57, 0x56, 0x94, 0x56, 0x02, 0x3b, 0xa7, 0x01, 0x06, 0xa8, 0xa7, 0xfe, 0xfc, 0xaa, 0x8a, 0x58, 0x4a, 0x48, + 0x56, 0x57, 0x49, 0x47, 0x59, 0xfe, 0x07, 0x69, 0x02, 0xc7, 0x69, 0x04, 0x98, 0x83, 0xaa, 0xab, 0x88, 0x47, 0x84, + 0xa7, 0xa7, 0x8b, 0x07, 0x4e, 0x65, 0x62, 0x55, 0x49, 0x4e, 0x66, 0x66, 0x52, 0xfc, 0xd1, 0x83, 0xa9, 0xa8, 0x8b, + 0x47, 0x83, 0xa9, 0xa7, 0x8b, 0x06, 0x4f, 0x65, 0x63, 0x55, 0x4a, 0x4f, 0x64, 0x63, 0x54, 0xf3, 0x42, 0x04, 0x72, + 0x42, 0x00, 0x03, 0x00, 0x65, 0xff, 0xec, 0x04, 0xf3, 0x05, 0xc4, 0x00, 0x1e, 0x00, 0x27, 0x00, 0x33, 0x00, 0x87, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x1c, 0x2f, 0x1b, 0xb1, 0x1c, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x18, 0x2f, 0x1b, 0xb1, 0x18, 0x12, + 0x3e, 0x59, 0xb2, 0x22, 0x1c, 0x09, 0x11, 0x12, 0x39, 0xb2, 0x2a, 0x09, 0x1c, 0x11, 0x12, 0x39, 0xb2, 0x03, 0x22, + 0x2a, 0x11, 0x12, 0x39, 0xb2, 0x10, 0x2a, 0x22, 0x11, 0x12, 0x39, 0xb2, 0x11, 0x09, 0x1c, 0x11, 0x12, 0x39, 0xb2, + 0x13, 0x1c, 0x09, 0x11, 0x12, 0x39, 0xb2, 0x19, 0x1c, 0x09, 0x11, 0x12, 0x39, 0xb2, 0x16, 0x11, 0x19, 0x11, 0x12, + 0x39, 0xb0, 0x1c, 0x10, 0xb1, 0x1f, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x21, 0x1f, + 0x11, 0x11, 0x12, 0x39, 0xb0, 0x09, 0x10, 0xb1, 0x31, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0x30, 0x31, 0x13, 0x34, 0x36, 0x37, 0x26, 0x26, 0x35, 0x34, 0x36, 0x33, 0x32, 0x16, 0x15, 0x14, 0x06, 0x07, 0x07, + 0x01, 0x36, 0x35, 0x33, 0x14, 0x07, 0x17, 0x23, 0x27, 0x06, 0x06, 0x23, 0x22, 0x24, 0x05, 0x32, 0x37, 0x01, 0x07, + 0x06, 0x15, 0x14, 0x16, 0x03, 0x14, 0x17, 0x37, 0x36, 0x36, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x65, 0x75, 0xa5, + 0x61, 0x42, 0xc4, 0xa8, 0x96, 0xc4, 0x59, 0x6f, 0x6b, 0x01, 0x44, 0x44, 0xa7, 0x7b, 0xd0, 0xde, 0x61, 0x4a, 0xc7, + 0x67, 0xd5, 0xfe, 0xfe, 0x01, 0xd7, 0x93, 0x7a, 0xfe, 0x9d, 0x21, 0xa7, 0x99, 0x22, 0x76, 0x76, 0x44, 0x32, 0x64, + 0x4c, 0x52, 0x60, 0x01, 0x87, 0x69, 0xb0, 0x75, 0x76, 0x90, 0x47, 0xa6, 0xbc, 0xaf, 0x85, 0x58, 0x95, 0x52, 0x4f, + 0xfe, 0x7d, 0x82, 0x9f, 0xff, 0xa8, 0xf9, 0x73, 0x42, 0x45, 0xe2, 0x4b, 0x70, 0x01, 0xa9, 0x18, 0x7b, 0x82, 0x76, + 0x8e, 0x03, 0xe5, 0x60, 0x90, 0x53, 0x30, 0x57, 0x3e, 0x43, 0x59, 0x6f, 0x00, 0x01, 0x00, 0x67, 0x04, 0x21, 0x00, + 0xfd, 0x06, 0x00, 0x00, 0x04, 0x00, 0x10, 0x00, 0xb0, 0x03, 0x2f, 0xb2, 0x02, 0x05, 0x03, 0x11, 0x12, 0x39, 0xb0, + 0x02, 0x2f, 0x30, 0x31, 0x13, 0x03, 0x23, 0x13, 0x33, 0xfd, 0x15, 0x81, 0x01, 0x95, 0x05, 0x91, 0xfe, 0x90, 0x01, + 0xdf, 0x00, 0x01, 0x00, 0x85, 0xfe, 0x2a, 0x02, 0x95, 0x06, 0x6b, 0x00, 0x11, 0x00, 0x09, 0x00, 0xb0, 0x0e, 0x2f, + 0xb0, 0x04, 0x2f, 0x30, 0x31, 0x13, 0x34, 0x12, 0x12, 0x37, 0x17, 0x06, 0x02, 0x03, 0x07, 0x10, 0x13, 0x16, 0x17, + 0x07, 0x26, 0x27, 0x02, 0x85, 0x79, 0xf0, 0x81, 0x26, 0x92, 0xbb, 0x09, 0x01, 0x8d, 0x55, 0x75, 0x26, 0x85, 0x79, + 0xec, 0x02, 0x4f, 0xe2, 0x01, 0xa0, 0x01, 0x54, 0x46, 0x7a, 0x70, 0xfe, 0x34, 0xfe, 0xe3, 0x55, 0xfe, 0x7e, 0xfe, + 0xe4, 0xaa, 0x60, 0x71, 0x4a, 0xae, 0x01, 0x54, 0x00, 0x00, 0x01, 0x00, 0x26, 0xfe, 0x2a, 0x02, 0x37, 0x06, 0x6b, + 0x00, 0x11, 0x00, 0x09, 0x00, 0xb0, 0x0e, 0x2f, 0xb0, 0x04, 0x2f, 0x30, 0x31, 0x01, 0x14, 0x02, 0x02, 0x07, 0x27, + 0x36, 0x12, 0x13, 0x35, 0x34, 0x02, 0x02, 0x27, 0x37, 0x16, 0x12, 0x12, 0x02, 0x37, 0x75, 0xf1, 0x84, 0x27, 0x9a, + 0xbb, 0x02, 0x58, 0x9d, 0x62, 0x27, 0x84, 0xef, 0x77, 0x02, 0x45, 0xdf, 0xfe, 0x67, 0xfe, 0xa6, 0x49, 0x71, 0x76, + 0x01, 0xf1, 0x01, 0x2f, 0x20, 0xd2, 0x01, 0x69, 0x01, 0x1e, 0x50, 0x71, 0x49, 0xfe, 0xaa, 0xfe, 0x64, 0x00, 0x01, + 0x00, 0x1c, 0x02, 0x61, 0x03, 0x55, 0x05, 0xb0, 0x00, 0x0e, 0x00, 0x20, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, + 0x2f, 0x1b, 0xb1, 0x04, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0xd0, 0x19, 0xb0, 0x00, 0x2f, 0x18, 0xb0, 0x09, 0xd0, 0x19, + 0xb0, 0x09, 0x2f, 0x18, 0x30, 0x31, 0x01, 0x25, 0x37, 0x05, 0x03, 0x33, 0x03, 0x25, 0x17, 0x05, 0x13, 0x07, 0x03, + 0x03, 0x27, 0x01, 0x4a, 0xfe, 0xd2, 0x2e, 0x01, 0x2e, 0x09, 0x99, 0x0a, 0x01, 0x29, 0x2e, 0xfe, 0xcd, 0xc6, 0x7c, + 0xba, 0xb4, 0x7d, 0x03, 0xd7, 0x5a, 0x97, 0x70, 0x01, 0x58, 0xfe, 0xa3, 0x6e, 0x98, 0x5b, 0xfe, 0xf1, 0x5e, 0x01, + 0x20, 0xfe, 0xe7, 0x5b, 0x00, 0x00, 0x01, 0x00, 0x4e, 0x00, 0x92, 0x04, 0x34, 0x04, 0xb6, 0x00, 0x0b, 0x00, 0x1b, + 0x00, 0xb0, 0x09, 0x2f, 0xb0, 0x00, 0xd0, 0xb0, 0x09, 0x10, 0xb1, 0x06, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0xd0, 0x30, 0x31, 0x01, 0x21, 0x15, 0x21, 0x11, 0x23, 0x11, 0x21, 0x35, 0x21, 0x11, + 0x33, 0x02, 0x9e, 0x01, 0x96, 0xfe, 0x6a, 0xba, 0xfe, 0x6a, 0x01, 0x96, 0xba, 0x03, 0x0d, 0xaf, 0xfe, 0x34, 0x01, + 0xcc, 0xaf, 0x01, 0xa9, 0x00, 0x00, 0x01, 0x00, 0x1d, 0xfe, 0xde, 0x01, 0x34, 0x00, 0xdb, 0x00, 0x08, 0x00, 0x18, + 0x00, 0xb0, 0x09, 0x2f, 0xb1, 0x04, 0x05, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x00, 0xd0, + 0xb0, 0x00, 0x2f, 0x30, 0x31, 0x13, 0x27, 0x36, 0x37, 0x35, 0x33, 0x15, 0x14, 0x06, 0x86, 0x69, 0x5e, 0x04, 0xb5, + 0x63, 0xfe, 0xde, 0x48, 0x83, 0x8b, 0xa7, 0x91, 0x65, 0xca, 0x00, 0x01, 0x00, 0x25, 0x02, 0x1f, 0x02, 0x0d, 0x02, + 0xb6, 0x00, 0x03, 0x00, 0x12, 0x00, 0xb0, 0x02, 0x2f, 0xb1, 0x01, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, 0x35, 0x21, 0x02, 0x0d, 0xfe, 0x18, 0x01, 0xe8, 0x02, 0x1f, 0x97, 0x00, 0x00, + 0x01, 0x00, 0x90, 0xff, 0xf5, 0x01, 0x76, 0x00, 0xd1, 0x00, 0x09, 0x00, 0x1c, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x12, 0x3e, 0x59, 0xb1, 0x02, 0x05, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0x30, 0x31, 0x37, 0x34, 0x36, 0x32, 0x16, 0x15, 0x14, 0x06, 0x22, 0x26, 0x90, 0x39, 0x72, 0x3b, 0x3b, 0x72, + 0x39, 0x61, 0x30, 0x40, 0x40, 0x30, 0x2e, 0x3e, 0x3e, 0x00, 0x00, 0x01, 0x00, 0x12, 0xff, 0x83, 0x03, 0x10, 0x05, + 0xb0, 0x00, 0x03, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, + 0x1e, 0x3e, 0x59, 0x30, 0x31, 0x17, 0x23, 0x01, 0x33, 0xb1, 0x9f, 0x02, 0x60, 0x9e, 0x7d, 0x06, 0x2d, 0x00, 0x00, + 0x02, 0x00, 0x73, 0xff, 0xec, 0x04, 0x0a, 0x05, 0xc4, 0x00, 0x0d, 0x00, 0x1b, 0x00, 0x3b, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, + 0x03, 0x12, 0x3e, 0x59, 0xb0, 0x0a, 0x10, 0xb1, 0x11, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb0, 0x03, 0x10, 0xb1, 0x18, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x10, + 0x02, 0x23, 0x22, 0x02, 0x03, 0x35, 0x10, 0x12, 0x33, 0x32, 0x12, 0x13, 0x27, 0x34, 0x26, 0x23, 0x22, 0x06, 0x07, + 0x11, 0x14, 0x16, 0x33, 0x32, 0x36, 0x37, 0x04, 0x0a, 0xde, 0xec, 0xe9, 0xe0, 0x04, 0xde, 0xed, 0xeb, 0xde, 0x03, + 0xb9, 0x84, 0x8f, 0x8e, 0x82, 0x02, 0x89, 0x8b, 0x89, 0x85, 0x03, 0x02, 0x6d, 0xfe, 0xbb, 0xfe, 0xc4, 0x01, 0x35, + 0x01, 0x33, 0xf7, 0x01, 0x41, 0x01, 0x38, 0xfe, 0xd3, 0xfe, 0xc6, 0x0d, 0xeb, 0xd7, 0xd6, 0xde, 0xfe, 0xd8, 0xec, + 0xe1, 0xd4, 0xe4, 0x00, 0x01, 0x00, 0xaa, 0x00, 0x00, 0x02, 0xd9, 0x05, 0xb7, 0x00, 0x06, 0x00, 0x3a, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, + 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb2, 0x04, 0x00, 0x05, 0x11, 0x12, 0x39, 0xb0, 0x04, 0x2f, 0xb1, 0x03, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x02, 0x03, 0x05, 0x11, 0x12, 0x39, 0x30, 0x31, 0x21, + 0x23, 0x11, 0x05, 0x35, 0x25, 0x33, 0x02, 0xd9, 0xba, 0xfe, 0x8b, 0x02, 0x12, 0x1d, 0x04, 0xd1, 0x89, 0xa8, 0xc7, + 0x00, 0x01, 0x00, 0x5d, 0x00, 0x00, 0x04, 0x33, 0x05, 0xc4, 0x00, 0x17, 0x00, 0x4f, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, + 0x12, 0x3e, 0x59, 0xb1, 0x17, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x02, 0xd0, 0xb2, + 0x03, 0x10, 0x17, 0x11, 0x12, 0x39, 0xb0, 0x10, 0x10, 0xb1, 0x09, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb0, 0x10, 0x10, 0xb0, 0x0c, 0xd0, 0xb2, 0x15, 0x17, 0x10, 0x11, 0x12, 0x39, 0x30, 0x31, 0x21, 0x21, + 0x35, 0x01, 0x36, 0x36, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x23, 0x34, 0x24, 0x33, 0x32, 0x16, 0x15, 0x14, + 0x01, 0x01, 0x21, 0x04, 0x33, 0xfc, 0x46, 0x01, 0xf8, 0x70, 0x55, 0x8a, 0x73, 0x8a, 0x99, 0xb9, 0x01, 0x03, 0xd9, + 0xcb, 0xec, 0xfe, 0xee, 0xfe, 0x7a, 0x02, 0xdb, 0x85, 0x02, 0x30, 0x7f, 0x9f, 0x55, 0x72, 0x92, 0x9d, 0x8c, 0xc9, + 0xf8, 0xd5, 0xb1, 0xd7, 0xfe, 0xd7, 0xfe, 0x59, 0x00, 0x01, 0x00, 0x5e, 0xff, 0xec, 0x03, 0xf9, 0x05, 0xc4, 0x00, + 0x26, 0x00, 0x7b, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1e, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x19, 0x2f, 0x1b, 0xb1, 0x19, 0x12, 0x3e, 0x59, 0xb2, 0x00, 0x0d, 0x19, 0x11, 0x12, 0x39, 0xb0, + 0x00, 0x2f, 0xb2, 0xcf, 0x00, 0x01, 0x5d, 0xb2, 0x9f, 0x00, 0x01, 0x71, 0xb2, 0x2f, 0x00, 0x01, 0x5d, 0xb2, 0x5f, + 0x00, 0x01, 0x72, 0xb0, 0x0d, 0x10, 0xb1, 0x06, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x0d, 0x10, 0xb0, 0x09, 0xd0, 0xb0, 0x00, 0x10, 0xb1, 0x26, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb2, 0x13, 0x26, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x19, 0x10, 0xb0, 0x1c, 0xd0, 0xb0, 0x19, 0x10, 0xb1, 0x1f, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x33, 0x36, 0x36, 0x35, 0x10, 0x23, + 0x22, 0x06, 0x15, 0x23, 0x34, 0x36, 0x33, 0x32, 0x16, 0x15, 0x14, 0x06, 0x07, 0x16, 0x16, 0x15, 0x14, 0x04, 0x20, + 0x24, 0x35, 0x33, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x27, 0x23, 0x01, 0x86, 0x8b, 0x83, 0x96, 0xff, + 0x78, 0x8f, 0xb9, 0xfd, 0xc3, 0xce, 0xea, 0x7b, 0x6a, 0x78, 0x83, 0xff, 0x00, 0xfe, 0x66, 0xfe, 0xff, 0xba, 0x96, + 0x7e, 0x86, 0x8e, 0x9c, 0x93, 0x8b, 0x03, 0x32, 0x02, 0x86, 0x72, 0x01, 0x00, 0x89, 0x71, 0xad, 0xe5, 0xda, 0xc2, + 0x5f, 0xb2, 0x2c, 0x26, 0xb0, 0x7f, 0xc4, 0xe6, 0xde, 0xb6, 0x73, 0x8a, 0x8c, 0x83, 0x7f, 0x88, 0x02, 0x00, 0x00, + 0x02, 0x00, 0x35, 0x00, 0x00, 0x04, 0x50, 0x05, 0xb0, 0x00, 0x0a, 0x00, 0x0e, 0x00, 0x4a, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, + 0x04, 0x12, 0x3e, 0x59, 0xb2, 0x01, 0x09, 0x04, 0x11, 0x12, 0x39, 0xb0, 0x01, 0x2f, 0xb1, 0x02, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x06, 0xd0, 0xb0, 0x01, 0x10, 0xb0, 0x0b, 0xd0, 0xb2, 0x08, 0x06, + 0x0b, 0x11, 0x12, 0x39, 0xb2, 0x0d, 0x09, 0x04, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x33, 0x15, 0x23, 0x11, 0x23, + 0x11, 0x21, 0x35, 0x01, 0x33, 0x01, 0x21, 0x11, 0x07, 0x03, 0x86, 0xca, 0xca, 0xba, 0xfd, 0x69, 0x02, 0x8c, 0xc5, + 0xfd, 0x81, 0x01, 0xc5, 0x16, 0x01, 0xe9, 0x97, 0xfe, 0xae, 0x01, 0x52, 0x6d, 0x03, 0xf1, 0xfc, 0x39, 0x02, 0xca, + 0x28, 0x00, 0x00, 0x01, 0x00, 0x9a, 0xff, 0xec, 0x04, 0x2d, 0x05, 0xb0, 0x00, 0x1d, 0x00, 0x64, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, + 0xb1, 0x0d, 0x12, 0x3e, 0x59, 0xb0, 0x01, 0x10, 0xb1, 0x04, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb2, 0x07, 0x0d, 0x01, 0x11, 0x12, 0x39, 0xb0, 0x07, 0x2f, 0xb1, 0x1a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x05, 0x07, 0x1a, 0x11, 0x12, 0x39, 0xb0, 0x0d, 0x10, 0xb0, 0x11, 0xd0, 0xb0, 0x0d, + 0x10, 0xb1, 0x14, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x07, 0x10, 0xb0, 0x1d, 0xd0, + 0x30, 0x31, 0x13, 0x13, 0x21, 0x15, 0x21, 0x03, 0x36, 0x33, 0x32, 0x12, 0x15, 0x14, 0x02, 0x23, 0x22, 0x26, 0x27, + 0x33, 0x16, 0x16, 0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x23, 0x22, 0x07, 0x07, 0xce, 0x4a, 0x02, 0xea, 0xfd, 0xb3, + 0x2c, 0x6b, 0x88, 0xc7, 0xea, 0xf3, 0xda, 0xc1, 0xf4, 0x11, 0xaf, 0x11, 0x90, 0x76, 0x81, 0x93, 0x9f, 0x84, 0x79, + 0x45, 0x31, 0x02, 0xda, 0x02, 0xd6, 0xab, 0xfe, 0x73, 0x3f, 0xfe, 0xf9, 0xe0, 0xe1, 0xfe, 0xfd, 0xd6, 0xbd, 0x7d, + 0x7f, 0xb0, 0x9b, 0x92, 0xb1, 0x35, 0x28, 0x00, 0x00, 0x02, 0x00, 0x84, 0xff, 0xec, 0x04, 0x1c, 0x05, 0xb1, 0x00, + 0x14, 0x00, 0x21, 0x00, 0x51, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1e, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x10, 0xb1, 0x01, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x07, 0x0d, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x07, 0x2f, + 0xb1, 0x15, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0d, 0x10, 0xb1, 0x1c, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x15, 0x23, 0x06, 0x04, 0x07, 0x36, 0x33, 0x32, + 0x12, 0x15, 0x14, 0x02, 0x23, 0x22, 0x00, 0x35, 0x35, 0x10, 0x00, 0x25, 0x03, 0x22, 0x06, 0x07, 0x15, 0x14, 0x16, + 0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x03, 0x4f, 0x22, 0xd8, 0xff, 0x00, 0x14, 0x73, 0xc7, 0xbe, 0xe3, 0xf5, 0xce, + 0xd1, 0xfe, 0xfc, 0x01, 0x57, 0x01, 0x53, 0xd2, 0x5f, 0xa0, 0x1f, 0xa2, 0x79, 0x7d, 0x8f, 0x91, 0x05, 0xb1, 0x9d, + 0x04, 0xf8, 0xe1, 0x84, 0xfe, 0xf4, 0xd4, 0xe1, 0xfe, 0xf2, 0x01, 0x41, 0xfd, 0x47, 0x01, 0x92, 0x01, 0xa9, 0x05, + 0xfd, 0x70, 0x72, 0x56, 0x44, 0xb4, 0xdc, 0xb8, 0x95, 0x96, 0xb9, 0x00, 0x00, 0x01, 0x00, 0x4d, 0x00, 0x00, 0x04, + 0x25, 0x05, 0xb0, 0x00, 0x06, 0x00, 0x33, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x1e, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x12, 0x3e, 0x59, 0xb0, 0x05, 0x10, 0xb1, + 0x03, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x00, 0x03, 0x05, 0x11, 0x12, 0x39, 0x30, + 0x31, 0x01, 0x01, 0x23, 0x01, 0x21, 0x35, 0x21, 0x04, 0x25, 0xfd, 0xa5, 0xc2, 0x02, 0x59, 0xfc, 0xec, 0x03, 0xd8, + 0x05, 0x48, 0xfa, 0xb8, 0x05, 0x18, 0x98, 0x00, 0x03, 0x00, 0x70, 0xff, 0xec, 0x04, 0x0e, 0x05, 0xc4, 0x00, 0x17, + 0x00, 0x21, 0x00, 0x2b, 0x00, 0x64, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x15, 0x2f, 0x1b, 0xb1, 0x15, 0x1e, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x12, 0x3e, 0x59, 0xb2, 0x27, 0x09, 0x15, 0x11, + 0x12, 0x39, 0xb0, 0x27, 0x2f, 0xb2, 0xcf, 0x27, 0x01, 0x5d, 0xb1, 0x1a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb2, 0x03, 0x1a, 0x27, 0x11, 0x12, 0x39, 0xb2, 0x0f, 0x27, 0x1a, 0x11, 0x12, 0x39, 0xb0, 0x09, + 0x10, 0xb1, 0x1f, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x15, 0x10, 0xb1, 0x22, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x14, 0x06, 0x07, 0x16, 0x16, 0x15, 0x14, + 0x06, 0x23, 0x22, 0x26, 0x35, 0x34, 0x36, 0x37, 0x26, 0x26, 0x35, 0x34, 0x36, 0x33, 0x32, 0x16, 0x03, 0x34, 0x26, + 0x22, 0x06, 0x14, 0x16, 0x33, 0x32, 0x36, 0x01, 0x22, 0x06, 0x15, 0x14, 0x16, 0x32, 0x36, 0x34, 0x26, 0x03, 0xec, + 0x73, 0x62, 0x72, 0x85, 0xff, 0xd0, 0xd2, 0xfd, 0x81, 0x72, 0x61, 0x70, 0xec, 0xc1, 0xc0, 0xed, 0x97, 0x9b, 0xfa, + 0x97, 0x93, 0x83, 0x82, 0x94, 0xfe, 0xea, 0x6d, 0x87, 0x85, 0xde, 0x85, 0x8a, 0x04, 0x34, 0x6d, 0xaa, 0x30, 0x31, + 0xbc, 0x77, 0xbd, 0xe0, 0xe1, 0xbc, 0x76, 0xbe, 0x31, 0x30, 0xaa, 0x6c, 0xb8, 0xd8, 0xd8, 0xfc, 0xa1, 0x7a, 0x9a, + 0x98, 0xf8, 0x8e, 0x8f, 0x04, 0x1a, 0x87, 0x74, 0x6f, 0x89, 0x89, 0xde, 0x8c, 0x00, 0x02, 0x00, 0x64, 0xff, 0xff, + 0x03, 0xf8, 0x05, 0xc4, 0x00, 0x17, 0x00, 0x24, 0x00, 0x5b, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, + 0xb1, 0x0b, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x13, 0x2f, 0x1b, 0xb1, 0x13, 0x12, 0x3e, 0x59, 0xb2, + 0x03, 0x13, 0x0b, 0x11, 0x12, 0x39, 0xb0, 0x03, 0x2f, 0xb2, 0x00, 0x03, 0x0b, 0x11, 0x12, 0x39, 0xb0, 0x13, 0x10, + 0xb1, 0x14, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x18, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0b, 0x10, 0xb1, 0x1f, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x06, 0x06, 0x23, 0x22, 0x26, 0x26, 0x35, 0x34, 0x36, 0x36, 0x33, 0x32, + 0x12, 0x11, 0x15, 0x10, 0x00, 0x05, 0x23, 0x35, 0x33, 0x36, 0x36, 0x25, 0x32, 0x36, 0x37, 0x35, 0x34, 0x26, 0x23, + 0x22, 0x06, 0x15, 0x14, 0x16, 0x03, 0x3e, 0x3a, 0xa1, 0x60, 0x7e, 0xbb, 0x66, 0x6f, 0xcc, 0x88, 0xd8, 0xf9, 0xfe, + 0xb0, 0xfe, 0xad, 0x24, 0x27, 0xe5, 0xf6, 0xfe, 0xee, 0x5d, 0x9d, 0x24, 0x9e, 0x79, 0x7a, 0x94, 0x8f, 0x02, 0x80, + 0x45, 0x54, 0x7c, 0xe1, 0x88, 0x92, 0xea, 0x7c, 0xfe, 0xbd, 0xfe, 0xe9, 0x36, 0xfe, 0x57, 0xfe, 0x79, 0x05, 0x9c, + 0x04, 0xe7, 0xfa, 0x72, 0x54, 0x4a, 0xb6, 0xe4, 0xbb, 0x99, 0x95, 0xc1, 0xff, 0xff, 0x00, 0x86, 0xff, 0xf5, 0x01, + 0x6d, 0x04, 0x44, 0x00, 0x26, 0x00, 0x12, 0xf6, 0x00, 0x01, 0x07, 0x00, 0x12, 0xff, 0xf7, 0x03, 0x73, 0x00, 0x10, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1a, 0x3e, 0x59, 0x30, 0x31, 0xff, 0xff, 0x00, + 0x29, 0xfe, 0xde, 0x01, 0x55, 0x04, 0x44, 0x00, 0x27, 0x00, 0x12, 0xff, 0xdf, 0x03, 0x73, 0x01, 0x06, 0x00, 0x10, + 0x0c, 0x00, 0x00, 0x10, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1a, 0x3e, 0x59, 0x30, + 0x31, 0x00, 0x01, 0x00, 0x48, 0x00, 0xc3, 0x03, 0x7a, 0x04, 0x4a, 0x00, 0x06, 0x00, 0x16, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x1a, 0x3e, 0x59, 0xb0, 0x02, 0xd0, 0xb0, 0x02, 0x2f, 0x30, 0x31, 0x01, + 0x05, 0x15, 0x01, 0x35, 0x01, 0x15, 0x01, 0x08, 0x02, 0x72, 0xfc, 0xce, 0x03, 0x32, 0x02, 0x84, 0xfd, 0xc4, 0x01, + 0x7b, 0x92, 0x01, 0x7a, 0xc4, 0x00, 0x00, 0x02, 0x00, 0x98, 0x01, 0x8f, 0x03, 0xda, 0x03, 0xcf, 0x00, 0x03, 0x00, + 0x07, 0x00, 0x27, 0x00, 0xb0, 0x07, 0x2f, 0xb0, 0x03, 0xd0, 0xb0, 0x03, 0x2f, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x07, 0x10, 0xb1, 0x04, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, 0x35, 0x21, 0x11, 0x21, 0x35, 0x21, 0x03, 0xda, 0xfc, 0xbe, 0x03, 0x42, 0xfc, + 0xbe, 0x03, 0x42, 0x03, 0x2e, 0xa1, 0xfd, 0xc0, 0xa0, 0x00, 0x00, 0x01, 0x00, 0x86, 0x00, 0xc4, 0x03, 0xdc, 0x04, + 0x4b, 0x00, 0x06, 0x00, 0x16, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1a, 0x3e, 0x59, + 0xb0, 0x05, 0xd0, 0xb0, 0x05, 0x2f, 0x30, 0x31, 0x01, 0x01, 0x35, 0x01, 0x15, 0x01, 0x35, 0x03, 0x1b, 0xfd, 0x6b, + 0x03, 0x56, 0xfc, 0xaa, 0x02, 0x8a, 0x01, 0x03, 0xbe, 0xfe, 0x86, 0x92, 0xfe, 0x85, 0xc0, 0x00, 0x02, 0x00, 0x4b, + 0xff, 0xf5, 0x03, 0x76, 0x05, 0xc4, 0x00, 0x18, 0x00, 0x21, 0x00, 0x53, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, + 0x2f, 0x1b, 0xb1, 0x10, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x20, 0x2f, 0x1b, 0xb1, 0x20, 0x12, 0x3e, + 0x59, 0xb1, 0x1b, 0x05, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x00, 0x1b, 0x10, 0x11, 0x12, + 0x39, 0xb2, 0x04, 0x10, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x10, 0x10, 0xb1, 0x09, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x10, 0x10, 0xb0, 0x0c, 0xd0, 0xb2, 0x15, 0x00, 0x10, 0x11, 0x12, 0x39, 0x30, 0x31, + 0x01, 0x36, 0x36, 0x37, 0x37, 0x36, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x23, 0x36, 0x36, 0x33, 0x32, 0x16, + 0x15, 0x14, 0x07, 0x07, 0x06, 0x15, 0x03, 0x34, 0x36, 0x32, 0x16, 0x14, 0x06, 0x22, 0x26, 0x01, 0x65, 0x02, 0x32, + 0x4d, 0x83, 0x54, 0x6e, 0x69, 0x66, 0x7c, 0xb9, 0x02, 0xe3, 0xb6, 0xbd, 0xd3, 0xa2, 0x6d, 0x49, 0xc1, 0x37, 0x6c, + 0x38, 0x38, 0x6c, 0x37, 0x01, 0x9a, 0x77, 0x8a, 0x54, 0x87, 0x5f, 0x6d, 0x69, 0x77, 0x6c, 0x5b, 0xa2, 0xc7, 0xcb, + 0xb1, 0xaf, 0xaa, 0x6c, 0x51, 0x98, 0xfe, 0xc3, 0x2d, 0x3d, 0x3d, 0x5a, 0x3b, 0x3b, 0x00, 0x00, 0x02, 0x00, 0x6a, + 0xfe, 0x3b, 0x06, 0xd6, 0x05, 0x97, 0x00, 0x35, 0x00, 0x42, 0x00, 0x6c, 0x00, 0xb0, 0x32, 0x2f, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x12, 0x3e, 0x59, 0xb0, 0x03, 0xd0, 0xb2, 0x0f, 0x32, 0x08, 0x11, 0x12, + 0x39, 0xb0, 0x0f, 0x2f, 0xb2, 0x05, 0x08, 0x0f, 0x11, 0x12, 0x39, 0xb0, 0x08, 0x10, 0xb1, 0x39, 0x02, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x15, 0xd0, 0xb0, 0x32, 0x10, 0xb1, 0x1b, 0x02, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, 0x10, 0xb0, 0x2a, 0xd0, 0xb0, 0x2a, 0x2f, 0xb1, 0x23, 0x02, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0f, 0x10, 0xb1, 0x40, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x06, 0x02, 0x23, 0x22, 0x27, 0x06, 0x06, 0x23, 0x22, 0x26, 0x37, 0x36, + 0x12, 0x36, 0x33, 0x32, 0x16, 0x17, 0x03, 0x06, 0x33, 0x32, 0x36, 0x37, 0x12, 0x00, 0x21, 0x22, 0x04, 0x02, 0x07, + 0x06, 0x12, 0x04, 0x33, 0x32, 0x36, 0x37, 0x17, 0x06, 0x06, 0x23, 0x22, 0x24, 0x02, 0x13, 0x12, 0x12, 0x24, 0x33, + 0x32, 0x04, 0x12, 0x01, 0x06, 0x16, 0x33, 0x32, 0x36, 0x37, 0x37, 0x13, 0x26, 0x23, 0x22, 0x06, 0x06, 0xca, 0x0c, + 0xd8, 0xb5, 0xbb, 0x35, 0x36, 0x8b, 0x4a, 0x8e, 0x92, 0x13, 0x0f, 0x79, 0xbf, 0x69, 0x51, 0x80, 0x50, 0x34, 0x13, + 0x93, 0x71, 0x8c, 0x06, 0x13, 0xfe, 0xb9, 0xfe, 0xb2, 0xc9, 0xfe, 0xc8, 0xb4, 0x0b, 0x0c, 0x90, 0x01, 0x27, 0xd1, + 0x5a, 0xb5, 0x3c, 0x25, 0x3e, 0xcd, 0x69, 0xfa, 0xfe, 0x98, 0xb3, 0x0c, 0x0c, 0xde, 0x01, 0x7c, 0xef, 0xf9, 0x01, + 0x64, 0xae, 0xfb, 0xf2, 0x0e, 0x51, 0x58, 0x3c, 0x6f, 0x24, 0x01, 0x2e, 0x38, 0x40, 0x75, 0x99, 0x01, 0xf6, 0xf2, + 0xfe, 0xe8, 0xa8, 0x55, 0x53, 0xe8, 0xcd, 0xa5, 0x01, 0x03, 0x94, 0x2b, 0x3f, 0xfd, 0xd6, 0xe7, 0xe0, 0xb4, 0x01, + 0x85, 0x01, 0x98, 0xc7, 0xfe, 0x88, 0xf6, 0xf8, 0xfe, 0x93, 0xc1, 0x2c, 0x23, 0x73, 0x27, 0x32, 0xe1, 0x01, 0xa7, + 0x01, 0x1b, 0x01, 0x13, 0x01, 0xb7, 0xef, 0xe0, 0xfe, 0x5a, 0xfe, 0x90, 0x8e, 0x98, 0x66, 0x5f, 0x09, 0x01, 0xf7, + 0x1d, 0xee, 0x00, 0x00, 0x02, 0x00, 0x1c, 0x00, 0x00, 0x05, 0x1d, 0x05, 0xb0, 0x00, 0x07, 0x00, 0x0a, 0x00, 0x54, + 0xb2, 0x0a, 0x0b, 0x0c, 0x11, 0x12, 0x39, 0xb0, 0x0a, 0x10, 0xb0, 0x04, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x12, 0x3e, 0x59, 0xb2, 0x08, 0x04, 0x02, + 0x11, 0x12, 0x39, 0xb0, 0x08, 0x2f, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, + 0x0a, 0x04, 0x02, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x21, 0x03, 0x23, 0x01, 0x33, 0x01, 0x23, 0x01, 0x21, 0x03, + 0x03, 0xcd, 0xfd, 0x9e, 0x89, 0xc6, 0x02, 0x2c, 0xa8, 0x02, 0x2d, 0xc5, 0xfd, 0x4d, 0x01, 0xef, 0xf8, 0x01, 0x7c, + 0xfe, 0x84, 0x05, 0xb0, 0xfa, 0x50, 0x02, 0x1a, 0x02, 0xa9, 0x00, 0x03, 0x00, 0xa9, 0x00, 0x00, 0x04, 0x88, 0x05, + 0xb0, 0x00, 0x0e, 0x00, 0x16, 0x00, 0x1f, 0x00, 0x58, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, + 0x01, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb2, 0x17, + 0x00, 0x01, 0x11, 0x12, 0x39, 0xb0, 0x17, 0x2f, 0xb1, 0x0f, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb2, 0x08, 0x0f, 0x17, 0x11, 0x12, 0x39, 0xb0, 0x00, 0x10, 0xb1, 0x10, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x01, 0x10, 0xb1, 0x1f, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0x30, 0x31, 0x33, 0x11, 0x21, 0x32, 0x16, 0x15, 0x14, 0x06, 0x07, 0x16, 0x16, 0x15, 0x14, 0x06, 0x23, 0x01, 0x11, + 0x21, 0x32, 0x36, 0x35, 0x10, 0x21, 0x25, 0x21, 0x32, 0x36, 0x35, 0x34, 0x26, 0x23, 0x21, 0xa9, 0x01, 0xdc, 0xed, + 0xef, 0x74, 0x64, 0x76, 0x89, 0xfe, 0xe8, 0xfe, 0xc7, 0x01, 0x3d, 0x86, 0x9b, 0xfe, 0xe2, 0xfe, 0xc0, 0x01, 0x22, + 0x7e, 0x97, 0x8c, 0x8f, 0xfe, 0xe4, 0x05, 0xb0, 0xc4, 0xc0, 0x66, 0x9d, 0x2b, 0x21, 0xb9, 0x80, 0xc4, 0xe0, 0x02, + 0xa9, 0xfd, 0xf4, 0x8b, 0x7a, 0x01, 0x07, 0x9a, 0x7e, 0x6c, 0x78, 0x6d, 0x00, 0x01, 0x00, 0x77, 0xff, 0xec, 0x04, + 0xd8, 0x05, 0xc4, 0x00, 0x1c, 0x00, 0x47, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1e, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x12, 0x3e, 0x59, 0xb0, 0x0b, 0x10, 0xb0, + 0x0f, 0xd0, 0xb0, 0x0b, 0x10, 0xb1, 0x12, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, + 0x10, 0xb1, 0x19, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb0, 0x1c, 0xd0, + 0x30, 0x31, 0x01, 0x06, 0x04, 0x23, 0x20, 0x00, 0x11, 0x35, 0x34, 0x12, 0x24, 0x33, 0x32, 0x00, 0x17, 0x23, 0x26, + 0x26, 0x23, 0x22, 0x02, 0x15, 0x15, 0x14, 0x12, 0x33, 0x32, 0x36, 0x37, 0x04, 0xd8, 0x1b, 0xfe, 0xe1, 0xee, 0xfe, + 0xfe, 0xfe, 0xc9, 0x91, 0x01, 0x0a, 0xaf, 0xe8, 0x01, 0x18, 0x17, 0xc1, 0x19, 0xa7, 0x96, 0xb8, 0xd1, 0xc6, 0xb2, + 0xa0, 0xab, 0x1c, 0x01, 0xce, 0xe7, 0xfb, 0x01, 0x72, 0x01, 0x36, 0x8c, 0xcb, 0x01, 0x34, 0xa5, 0xfe, 0xfd, 0xe5, + 0xae, 0x9c, 0xfe, 0xf0, 0xfb, 0x8d, 0xed, 0xfe, 0xe8, 0x91, 0xb4, 0x00, 0x02, 0x00, 0xa9, 0x00, 0x00, 0x04, 0xc6, + 0x05, 0xb0, 0x00, 0x0b, 0x00, 0x15, 0x00, 0x3b, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, + 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb0, 0x01, 0x10, + 0xb1, 0x0c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x00, 0x10, 0xb1, 0x0d, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x33, 0x11, 0x21, 0x32, 0x04, 0x12, 0x17, 0x15, 0x14, + 0x02, 0x04, 0x07, 0x03, 0x11, 0x33, 0x32, 0x12, 0x35, 0x35, 0x34, 0x02, 0x27, 0xa9, 0x01, 0x9b, 0xbe, 0x01, 0x24, + 0x9f, 0x01, 0x9f, 0xfe, 0xd9, 0xc4, 0xd3, 0xca, 0xde, 0xf7, 0xe9, 0xd6, 0x05, 0xb0, 0xa8, 0xfe, 0xca, 0xc9, 0x5d, + 0xce, 0xfe, 0xca, 0xa6, 0x02, 0x05, 0x12, 0xfb, 0x8b, 0x01, 0x14, 0xff, 0x55, 0xf8, 0x01, 0x13, 0x02, 0x00, 0x00, + 0x01, 0x00, 0xa9, 0x00, 0x00, 0x04, 0x46, 0x05, 0xb0, 0x00, 0x0b, 0x00, 0x51, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, + 0x3e, 0x59, 0xb2, 0x0b, 0x04, 0x06, 0x11, 0x12, 0x39, 0xb0, 0x0b, 0x2f, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0x10, 0xb1, 0x02, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb0, 0x06, 0x10, 0xb1, 0x08, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, + 0x21, 0x11, 0x21, 0x15, 0x21, 0x11, 0x21, 0x15, 0x21, 0x11, 0x21, 0x03, 0xe0, 0xfd, 0x89, 0x02, 0xdd, 0xfc, 0x63, + 0x03, 0x93, 0xfd, 0x2d, 0x02, 0x77, 0x02, 0xa1, 0xfd, 0xfc, 0x9d, 0x05, 0xb0, 0x9e, 0xfe, 0x2c, 0x00, 0x00, 0x01, + 0x00, 0xa9, 0x00, 0x00, 0x04, 0x2f, 0x05, 0xb0, 0x00, 0x09, 0x00, 0x42, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, + 0x2f, 0x1b, 0xb1, 0x04, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, + 0x59, 0xb2, 0x09, 0x02, 0x04, 0x11, 0x12, 0x39, 0xb0, 0x09, 0x2f, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0x10, 0xb1, 0x06, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0x30, 0x31, 0x01, 0x21, 0x11, 0x23, 0x11, 0x21, 0x15, 0x21, 0x11, 0x21, 0x03, 0xcc, 0xfd, 0x9d, 0xc0, 0x03, 0x86, + 0xfd, 0x3a, 0x02, 0x63, 0x02, 0x83, 0xfd, 0x7d, 0x05, 0xb0, 0x9e, 0xfe, 0x0e, 0x00, 0x01, 0x00, 0x7a, 0xff, 0xec, + 0x04, 0xdc, 0x05, 0xc4, 0x00, 0x1f, 0x00, 0x6c, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, + 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x12, 0x3e, 0x59, 0xb0, 0x0b, 0x10, + 0xb0, 0x0f, 0xd0, 0xb0, 0x0b, 0x10, 0xb1, 0x11, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x03, 0x10, 0xb1, 0x18, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x1e, 0x03, 0x0b, 0x11, + 0x12, 0x39, 0xb0, 0x1e, 0x2f, 0xb4, 0xbf, 0x1e, 0xcf, 0x1e, 0x02, 0x5d, 0xb4, 0x0f, 0x1e, 0x1f, 0x1e, 0x02, 0x5d, + 0xb4, 0x3f, 0x1e, 0x4f, 0x1e, 0x02, 0x5d, 0xb1, 0x1d, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0x30, 0x31, 0x25, 0x06, 0x04, 0x23, 0x22, 0x24, 0x02, 0x27, 0x35, 0x10, 0x00, 0x21, 0x32, 0x04, 0x17, 0x23, 0x02, + 0x21, 0x22, 0x02, 0x03, 0x15, 0x14, 0x12, 0x33, 0x32, 0x36, 0x37, 0x11, 0x21, 0x35, 0x21, 0x04, 0xdc, 0x4a, 0xfe, + 0xf7, 0xb0, 0xb2, 0xfe, 0xec, 0x97, 0x02, 0x01, 0x33, 0x01, 0x16, 0xe4, 0x01, 0x16, 0x1f, 0xc0, 0x36, 0xfe, 0xde, + 0xc1, 0xc7, 0x01, 0xe0, 0xbf, 0x6c, 0xa2, 0x35, 0xfe, 0xaf, 0x02, 0x10, 0xbf, 0x6a, 0x69, 0xa7, 0x01, 0x34, 0xcb, + 0x7f, 0x01, 0x49, 0x01, 0x6a, 0xe9, 0xd6, 0x01, 0x21, 0xfe, 0xf1, 0xfe, 0xff, 0x77, 0xf5, 0xfe, 0xdf, 0x30, 0x39, + 0x01, 0x47, 0x9c, 0x00, 0x01, 0x00, 0xa9, 0x00, 0x00, 0x05, 0x08, 0x05, 0xb0, 0x00, 0x0b, 0x00, 0x67, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, + 0x1b, 0xb1, 0x0a, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x10, 0xb0, 0x09, 0xd0, + 0xb0, 0x09, 0x2f, 0xb2, 0xef, 0x09, 0x01, 0x5d, 0xb4, 0xcf, 0x09, 0xdf, 0x09, 0x02, 0x71, 0xb2, 0x8f, 0x09, 0x01, + 0x71, 0xb2, 0x2f, 0x09, 0x01, 0x5d, 0xb2, 0x9f, 0x09, 0x01, 0x72, 0xb1, 0x02, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x21, 0x23, 0x11, 0x21, 0x11, 0x23, 0x11, 0x33, 0x11, 0x21, 0x11, 0x33, 0x05, + 0x08, 0xc1, 0xfd, 0x22, 0xc0, 0xc0, 0x02, 0xde, 0xc1, 0x02, 0xa1, 0xfd, 0x5f, 0x05, 0xb0, 0xfd, 0x8e, 0x02, 0x72, + 0x00, 0x00, 0x01, 0x00, 0xb7, 0x00, 0x00, 0x01, 0x77, 0x05, 0xb0, 0x00, 0x03, 0x00, 0x1d, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, + 0x00, 0x12, 0x3e, 0x59, 0x30, 0x31, 0x21, 0x23, 0x11, 0x33, 0x01, 0x77, 0xc0, 0xc0, 0x05, 0xb0, 0x00, 0x00, 0x01, + 0x00, 0x35, 0xff, 0xec, 0x03, 0xcc, 0x05, 0xb0, 0x00, 0x0f, 0x00, 0x2f, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, + 0x2f, 0x1b, 0xb1, 0x00, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x12, 0x3e, + 0x59, 0xb0, 0x09, 0xd0, 0xb0, 0x05, 0x10, 0xb1, 0x0c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0x30, 0x31, 0x01, 0x33, 0x11, 0x14, 0x06, 0x23, 0x22, 0x26, 0x35, 0x33, 0x14, 0x16, 0x33, 0x32, 0x36, 0x37, 0x03, + 0x0b, 0xc1, 0xfb, 0xd1, 0xd9, 0xf2, 0xc0, 0x89, 0x82, 0x77, 0x93, 0x01, 0x05, 0xb0, 0xfb, 0xf9, 0xd1, 0xec, 0xde, + 0xc8, 0x7d, 0x8c, 0x96, 0x87, 0x00, 0x01, 0x00, 0xa9, 0x00, 0x00, 0x05, 0x05, 0x05, 0xb0, 0x00, 0x0b, 0x00, 0x74, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x12, 0x3e, 0x59, 0xb2, 0x00, 0x02, 0x05, + 0x11, 0x12, 0x39, 0x40, 0x11, 0x4a, 0x00, 0x5a, 0x00, 0x6a, 0x00, 0x7a, 0x00, 0x8a, 0x00, 0x9a, 0x00, 0xaa, 0x00, + 0xba, 0x00, 0x08, 0x5d, 0xb2, 0x39, 0x00, 0x01, 0x5d, 0xb2, 0x06, 0x05, 0x02, 0x11, 0x12, 0x39, 0x40, 0x13, 0x36, + 0x06, 0x46, 0x06, 0x56, 0x06, 0x66, 0x06, 0x76, 0x06, 0x86, 0x06, 0x96, 0x06, 0xa6, 0x06, 0xb6, 0x06, 0x09, 0x5d, + 0x30, 0x31, 0x01, 0x07, 0x11, 0x23, 0x11, 0x33, 0x11, 0x01, 0x33, 0x01, 0x01, 0x23, 0x02, 0x1b, 0xb2, 0xc0, 0xc0, + 0x02, 0x87, 0xe8, 0xfd, 0xc3, 0x02, 0x6a, 0xe6, 0x02, 0xa5, 0xb9, 0xfe, 0x14, 0x05, 0xb0, 0xfd, 0x30, 0x02, 0xd0, + 0xfd, 0x7d, 0xfc, 0xd3, 0x00, 0x01, 0x00, 0xa9, 0x00, 0x00, 0x04, 0x1c, 0x05, 0xb0, 0x00, 0x05, 0x00, 0x29, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, + 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0x30, 0x31, 0x25, 0x21, 0x15, 0x21, 0x11, 0x33, 0x01, 0x6a, 0x02, 0xb2, 0xfc, 0x8d, 0xc1, 0x9d, 0x9d, 0x05, 0xb0, + 0x00, 0x01, 0x00, 0xa9, 0x00, 0x00, 0x06, 0x52, 0x05, 0xb0, 0x00, 0x0e, 0x00, 0x59, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, + 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, + 0x0c, 0x12, 0x3e, 0x59, 0xb2, 0x01, 0x00, 0x04, 0x11, 0x12, 0x39, 0xb2, 0x07, 0x00, 0x04, 0x11, 0x12, 0x39, 0xb2, + 0x0a, 0x00, 0x04, 0x11, 0x12, 0x39, 0x30, 0x31, 0x09, 0x02, 0x33, 0x11, 0x23, 0x11, 0x13, 0x01, 0x23, 0x01, 0x13, + 0x11, 0x23, 0x11, 0x01, 0xa1, 0x01, 0xdc, 0x01, 0xdc, 0xf9, 0xc0, 0x12, 0xfe, 0x22, 0x93, 0xfe, 0x23, 0x13, 0xc0, + 0x05, 0xb0, 0xfb, 0x5c, 0x04, 0xa4, 0xfa, 0x50, 0x02, 0x37, 0x02, 0x64, 0xfb, 0x65, 0x04, 0x98, 0xfd, 0x9f, 0xfd, + 0xc9, 0x05, 0xb0, 0x00, 0x00, 0x01, 0x00, 0xa9, 0x00, 0x00, 0x05, 0x08, 0x05, 0xb0, 0x00, 0x09, 0x00, 0x4c, 0xb2, + 0x01, 0x0a, 0x0b, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x1e, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x12, + 0x3e, 0x59, 0xb2, 0x02, 0x05, 0x00, 0x11, 0x12, 0x39, 0xb2, 0x07, 0x05, 0x00, 0x11, 0x12, 0x39, 0x30, 0x31, 0x21, + 0x23, 0x01, 0x11, 0x23, 0x11, 0x33, 0x01, 0x11, 0x33, 0x05, 0x08, 0xc1, 0xfd, 0x23, 0xc1, 0xc1, 0x02, 0xdf, 0xbf, + 0x04, 0x62, 0xfb, 0x9e, 0x05, 0xb0, 0xfb, 0x99, 0x04, 0x67, 0x00, 0x02, 0x00, 0x76, 0xff, 0xec, 0x05, 0x09, 0x05, + 0xc4, 0x00, 0x11, 0x00, 0x1f, 0x00, 0x3b, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1e, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb0, 0x0d, 0x10, 0xb1, + 0x15, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0x10, 0xb1, 0x1c, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x14, 0x02, 0x04, 0x23, 0x22, 0x24, 0x02, 0x27, 0x35, + 0x34, 0x12, 0x24, 0x33, 0x32, 0x04, 0x12, 0x15, 0x27, 0x10, 0x02, 0x23, 0x22, 0x02, 0x07, 0x15, 0x14, 0x12, 0x33, + 0x32, 0x12, 0x37, 0x05, 0x09, 0x90, 0xfe, 0xf8, 0xb0, 0xac, 0xfe, 0xf6, 0x93, 0x02, 0x92, 0x01, 0x0b, 0xac, 0xaf, + 0x01, 0x0b, 0x90, 0xbf, 0xd0, 0xbb, 0xb6, 0xd1, 0x03, 0xd3, 0xb9, 0xba, 0xcc, 0x03, 0x02, 0xa9, 0xd6, 0xfe, 0xc1, + 0xa8, 0xa9, 0x01, 0x39, 0xce, 0x69, 0xd2, 0x01, 0x42, 0xab, 0xa9, 0xfe, 0xbf, 0xd5, 0x02, 0x01, 0x03, 0x01, 0x15, + 0xfe, 0xeb, 0xf6, 0x6b, 0xfb, 0xfe, 0xe1, 0x01, 0x0f, 0xfd, 0x00, 0x00, 0x02, 0x00, 0xa9, 0x00, 0x00, 0x04, 0xc0, + 0x05, 0xb0, 0x00, 0x0a, 0x00, 0x13, 0x00, 0x4f, 0xb2, 0x0a, 0x14, 0x15, 0x11, 0x12, 0x39, 0xb0, 0x0a, 0x10, 0xb0, + 0x0c, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x12, 0x3e, 0x59, 0xb2, 0x0b, 0x03, 0x01, 0x11, 0x12, 0x39, 0xb0, 0x0b, + 0x2f, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x12, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x11, 0x23, 0x11, 0x21, 0x32, 0x04, 0x15, + 0x14, 0x04, 0x23, 0x25, 0x21, 0x32, 0x36, 0x35, 0x34, 0x26, 0x27, 0x21, 0x01, 0x69, 0xc0, 0x02, 0x19, 0xef, 0x01, + 0x0f, 0xfe, 0xf7, 0xf7, 0xfe, 0xa9, 0x01, 0x59, 0x9a, 0xa4, 0xa4, 0x8f, 0xfe, 0x9c, 0x02, 0x3a, 0xfd, 0xc6, 0x05, + 0xb0, 0xf4, 0xc9, 0xd4, 0xe5, 0x9d, 0x91, 0x89, 0x82, 0x9c, 0x03, 0x00, 0x02, 0x00, 0x6d, 0xff, 0x0a, 0x05, 0x06, + 0x05, 0xc4, 0x00, 0x15, 0x00, 0x22, 0x00, 0x4f, 0xb2, 0x08, 0x23, 0x24, 0x11, 0x12, 0x39, 0xb0, 0x08, 0x10, 0xb0, + 0x19, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x11, 0x2f, 0x1b, 0xb1, 0x11, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x12, 0x3e, 0x59, 0xb2, 0x03, 0x08, 0x11, 0x11, 0x12, 0x39, 0xb0, 0x11, + 0x10, 0xb1, 0x19, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, 0x10, 0xb1, 0x20, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x14, 0x02, 0x07, 0x05, 0x07, 0x25, 0x06, + 0x23, 0x22, 0x24, 0x02, 0x27, 0x35, 0x34, 0x12, 0x24, 0x33, 0x32, 0x04, 0x12, 0x15, 0x27, 0x10, 0x02, 0x23, 0x22, + 0x02, 0x07, 0x15, 0x14, 0x12, 0x20, 0x12, 0x37, 0x05, 0x01, 0x86, 0x79, 0x01, 0x04, 0x83, 0xfe, 0xcd, 0x48, 0x50, + 0xac, 0xfe, 0xf6, 0x93, 0x02, 0x92, 0x01, 0x0b, 0xac, 0xb0, 0x01, 0x0b, 0x90, 0xc0, 0xcd, 0xbe, 0xb5, 0xd1, 0x03, + 0xd1, 0x01, 0x74, 0xcc, 0x03, 0x02, 0xa9, 0xd3, 0xfe, 0xcf, 0x56, 0xcc, 0x79, 0xf4, 0x12, 0xa9, 0x01, 0x39, 0xce, + 0x69, 0xd2, 0x01, 0x42, 0xab, 0xaa, 0xfe, 0xc1, 0xd5, 0x01, 0x01, 0x01, 0x01, 0x17, 0xfe, 0xeb, 0xf6, 0x6b, 0xfa, + 0xfe, 0xe0, 0x01, 0x0f, 0xfd, 0x00, 0x00, 0x02, 0x00, 0xa8, 0x00, 0x00, 0x04, 0xc9, 0x05, 0xb0, 0x00, 0x0e, 0x00, + 0x17, 0x00, 0x63, 0xb2, 0x05, 0x18, 0x19, 0x11, 0x12, 0x39, 0xb0, 0x05, 0x10, 0xb0, 0x16, 0xd0, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, + 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x12, 0x3e, 0x59, 0xb2, + 0x10, 0x04, 0x02, 0x11, 0x12, 0x39, 0xb0, 0x10, 0x2f, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb2, 0x0b, 0x00, 0x04, 0x11, 0x12, 0x39, 0xb0, 0x04, 0x10, 0xb1, 0x16, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, 0x11, 0x23, 0x11, 0x21, 0x32, 0x04, 0x15, 0x14, 0x06, 0x07, + 0x01, 0x15, 0x23, 0x01, 0x21, 0x32, 0x36, 0x35, 0x34, 0x26, 0x27, 0x21, 0x02, 0xbf, 0xfe, 0xaa, 0xc1, 0x01, 0xe2, + 0xf6, 0x01, 0x09, 0x93, 0x83, 0x01, 0x56, 0xce, 0xfd, 0x6e, 0x01, 0x27, 0x8f, 0xa9, 0xa1, 0x98, 0xfe, 0xda, 0x02, + 0x4d, 0xfd, 0xb3, 0x05, 0xb0, 0xe0, 0xd6, 0x88, 0xca, 0x32, 0xfd, 0x96, 0x0c, 0x02, 0xea, 0x94, 0x7c, 0x87, 0x90, + 0x01, 0x00, 0x00, 0x01, 0x00, 0x50, 0xff, 0xec, 0x04, 0x72, 0x05, 0xc4, 0x00, 0x26, 0x00, 0x64, 0xb2, 0x00, 0x27, + 0x28, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x1a, 0x2f, 0x1b, 0xb1, 0x1a, 0x12, 0x3e, 0x59, 0xb0, 0x06, 0x10, 0xb0, 0x0b, 0xd0, 0xb0, + 0x06, 0x10, 0xb1, 0x0e, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x26, 0x1a, 0x06, 0x11, + 0x12, 0x39, 0xb0, 0x26, 0x10, 0xb1, 0x14, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x1a, + 0x10, 0xb0, 0x1f, 0xd0, 0xb0, 0x1a, 0x10, 0xb1, 0x22, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0x30, 0x31, 0x01, 0x26, 0x26, 0x35, 0x34, 0x24, 0x33, 0x32, 0x16, 0x16, 0x15, 0x23, 0x34, 0x26, 0x23, 0x22, 0x06, + 0x15, 0x14, 0x16, 0x04, 0x16, 0x16, 0x15, 0x14, 0x04, 0x23, 0x22, 0x24, 0x26, 0x35, 0x33, 0x14, 0x16, 0x33, 0x32, + 0x36, 0x34, 0x26, 0x02, 0x56, 0xf7, 0xe1, 0x01, 0x13, 0xdc, 0x96, 0xeb, 0x81, 0xc1, 0xa8, 0x99, 0x8e, 0x9f, 0x97, + 0x01, 0x6b, 0xcd, 0x63, 0xfe, 0xec, 0xe7, 0x96, 0xfe, 0xfc, 0x8d, 0xc1, 0xc3, 0xa3, 0x98, 0xa2, 0x96, 0x02, 0x89, + 0x47, 0xcf, 0x98, 0xac, 0xe1, 0x74, 0xcc, 0x79, 0x84, 0x97, 0x7d, 0x6f, 0x59, 0x7b, 0x66, 0x7b, 0xa4, 0x6f, 0xb1, + 0xd5, 0x73, 0xc8, 0x7f, 0x84, 0x99, 0x7c, 0xd6, 0x75, 0x00, 0x01, 0x00, 0x31, 0x00, 0x00, 0x04, 0x97, 0x05, 0xb0, + 0x00, 0x07, 0x00, 0x2f, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x06, 0x10, 0xb1, 0x00, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0xd0, 0x30, 0x31, 0x01, 0x21, 0x11, 0x23, 0x11, 0x21, + 0x35, 0x21, 0x04, 0x97, 0xfe, 0x2c, 0xbf, 0xfe, 0x2d, 0x04, 0x66, 0x05, 0x12, 0xfa, 0xee, 0x05, 0x12, 0x9e, 0x00, + 0x00, 0x01, 0x00, 0x8c, 0xff, 0xec, 0x04, 0xaa, 0x05, 0xb0, 0x00, 0x12, 0x00, 0x3d, 0xb2, 0x05, 0x13, 0x14, 0x11, + 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, + 0x05, 0x12, 0x3e, 0x59, 0xb1, 0x0e, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, + 0x11, 0x06, 0x00, 0x07, 0x07, 0x22, 0x00, 0x27, 0x11, 0x33, 0x11, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x11, 0x04, + 0xaa, 0x01, 0xfe, 0xff, 0xdc, 0x33, 0xef, 0xfe, 0xe4, 0x02, 0xbe, 0xae, 0xa1, 0xa3, 0xad, 0x05, 0xb0, 0xfc, 0x22, + 0xce, 0xfe, 0xfa, 0x10, 0x02, 0x01, 0x02, 0xe2, 0x03, 0xe0, 0xfc, 0x26, 0x9e, 0xaf, 0xae, 0x9e, 0x03, 0xdb, 0x00, + 0x01, 0x00, 0x1c, 0x00, 0x00, 0x04, 0xfd, 0x05, 0xb0, 0x00, 0x06, 0x00, 0x38, 0xb2, 0x00, 0x07, 0x08, 0x11, 0x12, + 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, + 0x12, 0x3e, 0x59, 0xb2, 0x00, 0x01, 0x03, 0x11, 0x12, 0x39, 0x30, 0x31, 0x25, 0x01, 0x33, 0x01, 0x23, 0x01, 0x33, + 0x02, 0x8b, 0x01, 0xa0, 0xd2, 0xfd, 0xe4, 0xaa, 0xfd, 0xe5, 0xd1, 0xff, 0x04, 0xb1, 0xfa, 0x50, 0x05, 0xb0, 0x00, + 0x00, 0x01, 0x00, 0x3d, 0x00, 0x00, 0x06, 0xed, 0x05, 0xb0, 0x00, 0x12, 0x00, 0x59, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, + 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x11, 0x2f, 0x1b, 0xb1, 0x11, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0f, 0x2f, 0x1b, 0xb1, + 0x0f, 0x12, 0x3e, 0x59, 0xb2, 0x01, 0x03, 0x0a, 0x11, 0x12, 0x39, 0xb2, 0x06, 0x03, 0x0a, 0x11, 0x12, 0x39, 0xb2, + 0x0d, 0x03, 0x0a, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x17, 0x37, 0x01, 0x33, 0x01, 0x17, 0x37, 0x13, 0x33, 0x01, + 0x23, 0x01, 0x27, 0x07, 0x01, 0x23, 0x01, 0x33, 0x01, 0xe3, 0x1c, 0x29, 0x01, 0x20, 0xa2, 0x01, 0x19, 0x28, 0x1f, + 0xe2, 0xc1, 0xfe, 0x9f, 0xaf, 0xfe, 0xd4, 0x17, 0x17, 0xfe, 0xc9, 0xaf, 0xfe, 0xa0, 0xc0, 0x01, 0xcb, 0xc0, 0xad, + 0x03, 0xf8, 0xfc, 0x08, 0xb0, 0xc4, 0x03, 0xe4, 0xfa, 0x50, 0x04, 0x25, 0x6f, 0x6f, 0xfb, 0xdb, 0x05, 0xb0, 0x00, + 0x01, 0x00, 0x39, 0x00, 0x00, 0x04, 0xce, 0x05, 0xb0, 0x00, 0x0b, 0x00, 0x6b, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1e, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x12, 0x3e, 0x59, 0xb2, 0x00, 0x01, 0x04, 0x11, 0x12, 0x39, 0x40, 0x09, 0x86, + 0x00, 0x96, 0x00, 0xa6, 0x00, 0xb6, 0x00, 0x04, 0x5d, 0xb2, 0x06, 0x01, 0x04, 0x11, 0x12, 0x39, 0x40, 0x09, 0x89, + 0x06, 0x99, 0x06, 0xa9, 0x06, 0xb9, 0x06, 0x04, 0x5d, 0xb2, 0x03, 0x00, 0x06, 0x11, 0x12, 0x39, 0xb2, 0x09, 0x06, + 0x00, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x01, 0x33, 0x01, 0x01, 0x23, 0x01, 0x01, 0x23, 0x01, 0x01, 0x33, 0x02, + 0x84, 0x01, 0x5d, 0xe2, 0xfe, 0x34, 0x01, 0xd7, 0xe4, 0xfe, 0x9a, 0xfe, 0x98, 0xe3, 0x01, 0xd8, 0xfe, 0x33, 0xe1, + 0x03, 0x82, 0x02, 0x2e, 0xfd, 0x2e, 0xfd, 0x22, 0x02, 0x38, 0xfd, 0xc8, 0x02, 0xde, 0x02, 0xd2, 0x00, 0x00, 0x01, + 0x00, 0x0f, 0x00, 0x00, 0x04, 0xbb, 0x05, 0xb0, 0x00, 0x08, 0x00, 0x31, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, + 0x2f, 0x1b, 0xb1, 0x01, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1e, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb2, 0x00, 0x01, 0x04, 0x11, + 0x12, 0x39, 0x30, 0x31, 0x01, 0x01, 0x33, 0x01, 0x11, 0x23, 0x11, 0x01, 0x33, 0x02, 0x65, 0x01, 0x7c, 0xda, 0xfe, + 0x0a, 0xc0, 0xfe, 0x0a, 0xdc, 0x02, 0xd5, 0x02, 0xdb, 0xfc, 0x6f, 0xfd, 0xe1, 0x02, 0x1f, 0x03, 0x91, 0x00, 0x00, + 0x01, 0x00, 0x56, 0x00, 0x00, 0x04, 0x7a, 0x05, 0xb0, 0x00, 0x09, 0x00, 0x46, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, + 0x3e, 0x59, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x04, 0x00, 0x02, 0x11, + 0x12, 0x39, 0xb0, 0x07, 0x10, 0xb1, 0x05, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x09, + 0x05, 0x07, 0x11, 0x12, 0x39, 0x30, 0x31, 0x25, 0x21, 0x15, 0x21, 0x35, 0x01, 0x21, 0x35, 0x21, 0x15, 0x01, 0x39, + 0x03, 0x41, 0xfb, 0xdc, 0x03, 0x1e, 0xfc, 0xef, 0x03, 0xf7, 0x9d, 0x9d, 0x90, 0x04, 0x82, 0x9e, 0x8d, 0x00, 0x00, + 0x01, 0x00, 0x92, 0xfe, 0xc8, 0x02, 0x0b, 0x06, 0x80, 0x00, 0x07, 0x00, 0x24, 0x00, 0xb0, 0x04, 0x2f, 0xb0, 0x07, + 0x2f, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0x10, 0xb1, 0x03, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x23, 0x11, 0x33, 0x15, 0x21, 0x11, 0x21, + 0x02, 0x0b, 0xbf, 0xbf, 0xfe, 0x87, 0x01, 0x79, 0x05, 0xe8, 0xf9, 0x78, 0x98, 0x07, 0xb8, 0x00, 0x00, 0x01, 0x00, + 0x28, 0xff, 0x83, 0x03, 0x38, 0x05, 0xb0, 0x00, 0x03, 0x00, 0x13, 0x00, 0xb0, 0x02, 0x2f, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1e, 0x3e, 0x59, 0x30, 0x31, 0x13, 0x33, 0x01, 0x23, 0x28, 0xb0, 0x02, 0x60, + 0xb0, 0x05, 0xb0, 0xf9, 0xd3, 0x00, 0x01, 0x00, 0x09, 0xfe, 0xc8, 0x01, 0x83, 0x06, 0x80, 0x00, 0x07, 0x00, 0x27, + 0x00, 0xb0, 0x02, 0x2f, 0xb0, 0x01, 0x2f, 0xb0, 0x02, 0x10, 0xb1, 0x05, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x01, 0x10, 0xb1, 0x06, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, + 0x31, 0x13, 0x21, 0x11, 0x21, 0x35, 0x33, 0x11, 0x23, 0x09, 0x01, 0x7a, 0xfe, 0x86, 0xc1, 0xc1, 0x06, 0x80, 0xf8, + 0x48, 0x98, 0x06, 0x88, 0x00, 0x00, 0x01, 0x00, 0x40, 0x02, 0xd9, 0x03, 0x14, 0x05, 0xb0, 0x00, 0x06, 0x00, 0x27, + 0xb2, 0x00, 0x07, 0x08, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1e, + 0x3e, 0x59, 0xb0, 0x00, 0xd0, 0xb2, 0x01, 0x07, 0x03, 0x11, 0x12, 0x39, 0xb0, 0x01, 0x2f, 0xb0, 0x05, 0xd0, 0x30, + 0x31, 0x01, 0x03, 0x23, 0x01, 0x33, 0x01, 0x23, 0x01, 0xaa, 0xbe, 0xac, 0x01, 0x2b, 0x7f, 0x01, 0x2a, 0xab, 0x04, + 0xbb, 0xfe, 0x1e, 0x02, 0xd7, 0xfd, 0x29, 0x00, 0x01, 0x00, 0x04, 0xff, 0x69, 0x03, 0x98, 0x00, 0x00, 0x00, 0x03, + 0x00, 0x1c, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x12, 0x3e, 0x59, 0xb1, 0x00, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x05, 0x21, 0x35, 0x21, 0x03, 0x98, 0xfc, 0x6c, + 0x03, 0x94, 0x97, 0x97, 0x00, 0x01, 0x00, 0x39, 0x04, 0xda, 0x01, 0xda, 0x06, 0x00, 0x00, 0x03, 0x00, 0x23, 0x00, + 0xb0, 0x01, 0x2f, 0xb2, 0x0f, 0x01, 0x01, 0x5d, 0xb0, 0x00, 0xd0, 0x19, 0xb0, 0x00, 0x2f, 0x18, 0xb0, 0x01, 0x10, + 0xb0, 0x02, 0xd0, 0xb0, 0x02, 0x2f, 0xb4, 0x0f, 0x02, 0x1f, 0x02, 0x02, 0x5d, 0x30, 0x31, 0x01, 0x23, 0x01, 0x33, + 0x01, 0xda, 0x9f, 0xfe, 0xfe, 0xdf, 0x04, 0xda, 0x01, 0x26, 0x00, 0x00, 0x02, 0x00, 0x6d, 0xff, 0xec, 0x03, 0xea, + 0x04, 0x4e, 0x00, 0x1e, 0x00, 0x28, 0x00, 0x7c, 0xb2, 0x17, 0x29, 0x2a, 0x11, 0x12, 0x39, 0xb0, 0x17, 0x10, 0xb0, + 0x20, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x17, 0x2f, 0x1b, 0xb1, 0x17, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, + 0x00, 0x12, 0x3e, 0x59, 0xb2, 0x02, 0x17, 0x04, 0x11, 0x12, 0x39, 0xb2, 0x0b, 0x17, 0x04, 0x11, 0x12, 0x39, 0xb0, + 0x0b, 0x2f, 0xb0, 0x17, 0x10, 0xb1, 0x0f, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x12, + 0x0b, 0x17, 0x11, 0x12, 0x39, 0xb0, 0x04, 0x10, 0xb1, 0x1f, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb0, 0x0b, 0x10, 0xb1, 0x23, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x21, + 0x26, 0x27, 0x06, 0x23, 0x22, 0x26, 0x35, 0x34, 0x24, 0x33, 0x33, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x23, + 0x34, 0x36, 0x36, 0x33, 0x32, 0x16, 0x17, 0x11, 0x14, 0x17, 0x15, 0x25, 0x32, 0x36, 0x37, 0x35, 0x23, 0x20, 0x15, + 0x14, 0x16, 0x03, 0x28, 0x10, 0x0a, 0x81, 0xb3, 0xa0, 0xcd, 0x01, 0x01, 0xe9, 0xb4, 0x74, 0x71, 0x63, 0x86, 0xba, + 0x73, 0xc5, 0x76, 0xbb, 0xd4, 0x04, 0x26, 0xfe, 0x0b, 0x57, 0x9c, 0x23, 0x91, 0xfe, 0xac, 0x74, 0x20, 0x52, 0x86, + 0xb5, 0x8b, 0xa9, 0xbb, 0x55, 0x61, 0x73, 0x64, 0x47, 0x51, 0x97, 0x58, 0xbb, 0xa4, 0xfe, 0x0e, 0x95, 0x58, 0x10, + 0x8d, 0x5a, 0x48, 0xde, 0xc7, 0x57, 0x62, 0x00, 0x00, 0x02, 0x00, 0x8c, 0xff, 0xec, 0x04, 0x20, 0x06, 0x00, 0x00, + 0x0e, 0x00, 0x19, 0x00, 0x66, 0xb2, 0x12, 0x1a, 0x1b, 0x11, 0x12, 0x39, 0xb0, 0x12, 0x10, 0xb0, 0x03, 0xd0, 0x00, + 0xb0, 0x08, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, + 0x06, 0x12, 0x3e, 0x59, 0xb2, 0x05, 0x08, 0x03, 0x11, 0x12, 0x39, 0xb2, 0x0a, 0x0c, 0x03, 0x11, 0x12, 0x39, 0xb0, + 0x0c, 0x10, 0xb1, 0x12, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x17, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x14, 0x02, 0x23, 0x22, 0x27, 0x07, + 0x23, 0x11, 0x33, 0x11, 0x36, 0x20, 0x12, 0x11, 0x27, 0x34, 0x26, 0x23, 0x22, 0x07, 0x11, 0x16, 0x33, 0x32, 0x36, + 0x04, 0x20, 0xe4, 0xc0, 0xcd, 0x70, 0x09, 0xaa, 0xb9, 0x70, 0x01, 0x8a, 0xe1, 0xb9, 0x92, 0x89, 0xb7, 0x50, 0x55, + 0xb4, 0x85, 0x94, 0x02, 0x11, 0xf8, 0xfe, 0xd3, 0x91, 0x7d, 0x06, 0x00, 0xfd, 0xc3, 0x8b, 0xfe, 0xd6, 0xfe, 0xfd, + 0x05, 0xbd, 0xce, 0xaa, 0xfe, 0x2c, 0xaa, 0xce, 0x00, 0x01, 0x00, 0x5c, 0xff, 0xec, 0x03, 0xec, 0x04, 0x4e, 0x00, + 0x1d, 0x00, 0x4b, 0xb2, 0x10, 0x1e, 0x1f, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, + 0xb1, 0x10, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x12, 0x3e, 0x59, 0xb1, + 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, 0x10, 0xb0, 0x03, 0xd0, 0xb0, 0x10, + 0x10, 0xb0, 0x14, 0xd0, 0xb0, 0x10, 0x10, 0xb1, 0x17, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0x30, 0x31, 0x25, 0x32, 0x36, 0x37, 0x33, 0x0e, 0x02, 0x23, 0x22, 0x00, 0x11, 0x35, 0x34, 0x36, 0x36, 0x33, 0x32, + 0x16, 0x17, 0x23, 0x26, 0x26, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x02, 0x3e, 0x63, 0x94, 0x08, 0xaf, 0x05, + 0x76, 0xc5, 0x6e, 0xdd, 0xfe, 0xfb, 0x74, 0xd9, 0x94, 0xb6, 0xf1, 0x08, 0xaf, 0x08, 0x8f, 0x69, 0x8d, 0x9b, 0x9a, + 0x83, 0x78, 0x5a, 0x5d, 0xa8, 0x64, 0x01, 0x27, 0x01, 0x00, 0x1f, 0x9e, 0xf6, 0x88, 0xda, 0xae, 0x69, 0x87, 0xcb, + 0xc0, 0x23, 0xbb, 0xca, 0x00, 0x00, 0x02, 0x00, 0x5f, 0xff, 0xec, 0x03, 0xf0, 0x06, 0x00, 0x00, 0x0f, 0x00, 0x1a, + 0x00, 0x66, 0xb2, 0x18, 0x1b, 0x1c, 0x11, 0x12, 0x39, 0xb0, 0x18, 0x10, 0xb0, 0x03, 0xd0, 0x00, 0xb0, 0x06, 0x2f, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, + 0x2f, 0x1b, 0xb1, 0x0c, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x12, 0x3e, + 0x59, 0xb2, 0x05, 0x03, 0x0c, 0x11, 0x12, 0x39, 0xb2, 0x0a, 0x03, 0x0c, 0x11, 0x12, 0x39, 0xb0, 0x0c, 0x10, 0xb1, + 0x13, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x18, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x13, 0x34, 0x12, 0x33, 0x32, 0x17, 0x11, 0x33, 0x11, 0x23, + 0x27, 0x06, 0x23, 0x22, 0x02, 0x35, 0x17, 0x14, 0x16, 0x33, 0x32, 0x37, 0x11, 0x26, 0x23, 0x22, 0x06, 0x5f, 0xec, + 0xbf, 0xbe, 0x6f, 0xb9, 0xaa, 0x09, 0x6f, 0xc6, 0xbc, 0xed, 0xb9, 0x98, 0x86, 0xb0, 0x51, 0x53, 0xac, 0x88, 0x98, + 0x02, 0x26, 0xf9, 0x01, 0x2f, 0x82, 0x02, 0x34, 0xfa, 0x00, 0x74, 0x88, 0x01, 0x34, 0xf8, 0x07, 0xb8, 0xd0, 0x9e, + 0x01, 0xf1, 0x99, 0xd2, 0x00, 0x00, 0x02, 0x00, 0x5d, 0xff, 0xec, 0x03, 0xf3, 0x04, 0x4e, 0x00, 0x15, 0x00, 0x1d, + 0x00, 0x6c, 0xb2, 0x08, 0x1e, 0x1f, 0x11, 0x12, 0x39, 0xb0, 0x08, 0x10, 0xb0, 0x16, 0xd0, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, + 0x00, 0x12, 0x3e, 0x59, 0xb2, 0x1a, 0x08, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x1a, 0x2f, 0xb4, 0xbf, 0x1a, 0xcf, 0x1a, + 0x02, 0x5d, 0xb1, 0x0c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x00, 0x10, 0xb1, 0x10, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x13, 0x08, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x08, + 0x10, 0xb1, 0x16, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x05, 0x22, 0x00, 0x35, + 0x35, 0x34, 0x36, 0x36, 0x33, 0x32, 0x12, 0x11, 0x15, 0x21, 0x16, 0x16, 0x33, 0x32, 0x36, 0x37, 0x17, 0x06, 0x01, + 0x22, 0x06, 0x07, 0x21, 0x35, 0x26, 0x26, 0x02, 0x4d, 0xdc, 0xfe, 0xec, 0x7b, 0xdd, 0x81, 0xd3, 0xea, 0xfd, 0x23, + 0x04, 0xb3, 0x8a, 0x62, 0x88, 0x33, 0x71, 0x88, 0xfe, 0xd9, 0x70, 0x98, 0x12, 0x02, 0x1e, 0x08, 0x88, 0x14, 0x01, + 0x21, 0xf2, 0x22, 0xa1, 0xfd, 0x8f, 0xfe, 0xea, 0xfe, 0xfd, 0x4d, 0xa0, 0xc5, 0x50, 0x42, 0x58, 0xd1, 0x03, 0xca, + 0xa3, 0x93, 0x0e, 0x8d, 0x9b, 0x00, 0x00, 0x01, 0x00, 0x3c, 0x00, 0x00, 0x02, 0xca, 0x06, 0x15, 0x00, 0x15, 0x00, + 0x65, 0xb2, 0x0f, 0x16, 0x17, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, + 0x20, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x11, 0x2f, 0x1b, 0xb1, 0x11, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, + 0x00, 0x12, 0x3e, 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x01, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb0, 0x08, 0x10, 0xb1, 0x0d, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x01, 0x10, 0xb0, + 0x13, 0xd0, 0xb0, 0x14, 0xd0, 0x30, 0x31, 0x33, 0x11, 0x23, 0x35, 0x33, 0x35, 0x34, 0x36, 0x33, 0x32, 0x17, 0x07, + 0x26, 0x23, 0x22, 0x06, 0x15, 0x15, 0x33, 0x15, 0x23, 0x11, 0xe7, 0xab, 0xab, 0xba, 0xaa, 0x40, 0x3f, 0x0a, 0x2f, + 0x35, 0x5a, 0x62, 0xe7, 0xe7, 0x03, 0xab, 0x8f, 0x6f, 0xae, 0xbe, 0x11, 0x96, 0x09, 0x69, 0x62, 0x72, 0x8f, 0xfc, + 0x55, 0x00, 0x02, 0x00, 0x60, 0xfe, 0x56, 0x03, 0xf2, 0x04, 0x4e, 0x00, 0x19, 0x00, 0x24, 0x00, 0x86, 0xb2, 0x22, + 0x25, 0x26, 0x11, 0x12, 0x39, 0xb0, 0x22, 0x10, 0xb0, 0x0b, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, + 0x1b, 0xb1, 0x03, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1a, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x14, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x17, + 0x2f, 0x1b, 0xb1, 0x17, 0x12, 0x3e, 0x59, 0xb2, 0x05, 0x03, 0x17, 0x11, 0x12, 0x39, 0xb2, 0x0f, 0x17, 0x0b, 0x11, + 0x12, 0x39, 0xb0, 0x0b, 0x10, 0xb1, 0x11, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x15, + 0x03, 0x17, 0x11, 0x12, 0x39, 0xb0, 0x17, 0x10, 0xb1, 0x1d, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x22, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x13, + 0x34, 0x12, 0x33, 0x32, 0x17, 0x37, 0x33, 0x11, 0x14, 0x06, 0x23, 0x22, 0x26, 0x27, 0x37, 0x16, 0x33, 0x32, 0x36, + 0x35, 0x35, 0x06, 0x23, 0x22, 0x02, 0x37, 0x14, 0x16, 0x33, 0x32, 0x37, 0x11, 0x26, 0x23, 0x22, 0x06, 0x60, 0xea, + 0xc1, 0xc6, 0x6f, 0x09, 0xa9, 0xf9, 0xd2, 0x75, 0xe0, 0x3b, 0x60, 0x77, 0xac, 0x87, 0x97, 0x6f, 0xc0, 0xbe, 0xeb, + 0xba, 0x96, 0x87, 0xaf, 0x52, 0x55, 0xaa, 0x87, 0x98, 0x02, 0x26, 0xfd, 0x01, 0x2b, 0x8c, 0x78, 0xfb, 0xe0, 0xd2, + 0xf2, 0x64, 0x57, 0x6f, 0x93, 0x98, 0x8a, 0x5d, 0x80, 0x01, 0x32, 0xf3, 0xb7, 0xd1, 0x9f, 0x01, 0xee, 0x9b, 0xd2, + 0x00, 0x01, 0x00, 0x8c, 0x00, 0x00, 0x03, 0xdf, 0x06, 0x00, 0x00, 0x11, 0x00, 0x4a, 0xb2, 0x0a, 0x12, 0x13, 0x11, + 0x12, 0x39, 0x00, 0xb0, 0x10, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1a, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0e, + 0x2f, 0x1b, 0xb1, 0x0e, 0x12, 0x3e, 0x59, 0xb2, 0x00, 0x02, 0x05, 0x11, 0x12, 0x39, 0xb0, 0x02, 0x10, 0xb1, 0x0a, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x36, 0x33, 0x20, 0x13, 0x11, 0x23, + 0x11, 0x26, 0x26, 0x23, 0x22, 0x06, 0x07, 0x11, 0x23, 0x11, 0x33, 0x01, 0x45, 0x7b, 0xc5, 0x01, 0x57, 0x03, 0xb9, + 0x01, 0x69, 0x6f, 0x5a, 0x88, 0x26, 0xb9, 0xb9, 0x03, 0xb7, 0x97, 0xfe, 0x7d, 0xfd, 0x35, 0x02, 0xcc, 0x75, 0x70, + 0x60, 0x4e, 0xfc, 0xfd, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x8d, 0x00, 0x00, 0x01, 0x68, 0x05, 0xc4, 0x00, 0x03, + 0x00, 0x0c, 0x00, 0x3f, 0xb2, 0x06, 0x0d, 0x0e, 0x11, 0x12, 0x39, 0xb0, 0x06, 0x10, 0xb0, 0x01, 0xd0, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, + 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb0, 0x02, 0x10, 0xb0, 0x0a, 0xd0, 0xb0, 0x0a, 0x2f, 0xb1, 0x06, 0x05, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x21, 0x23, 0x11, 0x33, 0x03, 0x34, 0x36, 0x32, 0x16, + 0x14, 0x06, 0x22, 0x26, 0x01, 0x55, 0xb9, 0xb9, 0xc8, 0x37, 0x6c, 0x38, 0x38, 0x6c, 0x37, 0x04, 0x3a, 0x01, 0x1f, + 0x2d, 0x3e, 0x3e, 0x5a, 0x3c, 0x3c, 0x00, 0x00, 0x02, 0xff, 0xbf, 0xfe, 0x4b, 0x01, 0x59, 0x05, 0xc4, 0x00, 0x0c, + 0x00, 0x16, 0x00, 0x4b, 0xb2, 0x10, 0x17, 0x18, 0x11, 0x12, 0x39, 0xb0, 0x10, 0x10, 0xb0, 0x00, 0xd0, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, + 0x1b, 0xb1, 0x03, 0x14, 0x3e, 0x59, 0xb1, 0x08, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x0c, 0x10, 0xb0, 0x15, 0xd0, 0xb0, 0x15, 0x2f, 0xb1, 0x10, 0x05, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0x30, 0x31, 0x01, 0x11, 0x10, 0x21, 0x22, 0x27, 0x35, 0x16, 0x33, 0x32, 0x36, 0x35, 0x11, 0x03, 0x34, 0x36, + 0x33, 0x32, 0x16, 0x14, 0x06, 0x22, 0x26, 0x01, 0x4b, 0xfe, 0xe5, 0x3d, 0x34, 0x20, 0x34, 0x3e, 0x41, 0x13, 0x37, + 0x35, 0x36, 0x38, 0x38, 0x6c, 0x36, 0x04, 0x3a, 0xfb, 0x49, 0xfe, 0xc8, 0x12, 0x94, 0x08, 0x43, 0x53, 0x04, 0xbb, + 0x01, 0x1f, 0x2c, 0x3f, 0x3e, 0x5a, 0x3c, 0x3c, 0x00, 0x00, 0x01, 0x00, 0x8d, 0x00, 0x00, 0x04, 0x0c, 0x06, 0x00, + 0x00, 0x0c, 0x00, 0x75, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x20, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, + 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x12, 0x3e, 0x59, + 0xb2, 0x00, 0x08, 0x02, 0x11, 0x12, 0x39, 0x40, 0x15, 0x3a, 0x00, 0x4a, 0x00, 0x5a, 0x00, 0x6a, 0x00, 0x7a, 0x00, + 0x8a, 0x00, 0x9a, 0x00, 0xaa, 0x00, 0xba, 0x00, 0xca, 0x00, 0x0a, 0x5d, 0xb2, 0x06, 0x08, 0x02, 0x11, 0x12, 0x39, + 0x40, 0x15, 0x36, 0x06, 0x46, 0x06, 0x56, 0x06, 0x66, 0x06, 0x76, 0x06, 0x86, 0x06, 0x96, 0x06, 0xa6, 0x06, 0xb6, + 0x06, 0xc6, 0x06, 0x0a, 0x5d, 0x30, 0x31, 0x01, 0x07, 0x11, 0x23, 0x11, 0x33, 0x11, 0x37, 0x01, 0x33, 0x01, 0x01, + 0x23, 0x01, 0xba, 0x74, 0xb9, 0xb9, 0x63, 0x01, 0x51, 0xe1, 0xfe, 0x5b, 0x01, 0xd6, 0xd9, 0x01, 0xf5, 0x79, 0xfe, + 0x84, 0x06, 0x00, 0xfc, 0x5f, 0x77, 0x01, 0x64, 0xfe, 0x3c, 0xfd, 0x8a, 0x00, 0x01, 0x00, 0x9c, 0x00, 0x00, 0x01, + 0x55, 0x06, 0x00, 0x00, 0x03, 0x00, 0x1d, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x20, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0x30, 0x31, 0x21, 0x23, + 0x11, 0x33, 0x01, 0x55, 0xb9, 0xb9, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x8b, 0x00, 0x00, 0x06, 0x78, 0x04, 0x4e, + 0x00, 0x1d, 0x00, 0x78, 0xb2, 0x04, 0x1e, 0x1f, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, + 0x1b, 0xb1, 0x03, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, + 0x2f, 0x1b, 0xb1, 0x0b, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x14, 0x2f, 0x1b, 0xb1, 0x14, 0x12, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x1b, 0x2f, 0x1b, 0xb1, 0x1b, 0x12, 0x3e, 0x59, 0xb2, 0x01, 0x08, 0x0b, 0x11, + 0x12, 0x39, 0xb2, 0x05, 0x08, 0x0b, 0x11, 0x12, 0x39, 0xb0, 0x08, 0x10, 0xb1, 0x10, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x18, 0xd0, 0x30, 0x31, 0x01, 0x17, 0x36, 0x33, 0x32, 0x17, 0x36, 0x36, 0x33, + 0x20, 0x13, 0x11, 0x23, 0x11, 0x34, 0x26, 0x23, 0x22, 0x06, 0x07, 0x11, 0x23, 0x11, 0x34, 0x23, 0x22, 0x07, 0x11, + 0x23, 0x11, 0x01, 0x3a, 0x05, 0x77, 0xca, 0xe3, 0x52, 0x36, 0xad, 0x76, 0x01, 0x64, 0x06, 0xb9, 0x6a, 0x7d, 0x67, + 0x88, 0x0b, 0xba, 0xe7, 0xb6, 0x43, 0xb9, 0x04, 0x3a, 0x78, 0x8c, 0xae, 0x4e, 0x60, 0xfe, 0x87, 0xfd, 0x2b, 0x02, + 0xca, 0x74, 0x73, 0x7b, 0x68, 0xfd, 0x32, 0x02, 0xc5, 0xec, 0x9b, 0xfc, 0xea, 0x04, 0x3a, 0x00, 0x00, 0x01, 0x00, + 0x8c, 0x00, 0x00, 0x03, 0xdf, 0x04, 0x4e, 0x00, 0x11, 0x00, 0x54, 0xb2, 0x0b, 0x12, 0x13, 0x11, 0x12, 0x39, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, + 0x2f, 0x1b, 0xb1, 0x00, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x12, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0f, 0x2f, 0x1b, 0xb1, 0x0f, 0x12, 0x3e, 0x59, 0xb2, 0x01, 0x03, 0x06, 0x11, + 0x12, 0x39, 0xb0, 0x03, 0x10, 0xb1, 0x0b, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, + 0x01, 0x17, 0x36, 0x33, 0x20, 0x13, 0x11, 0x23, 0x11, 0x26, 0x26, 0x23, 0x22, 0x06, 0x07, 0x11, 0x23, 0x11, 0x01, + 0x3b, 0x06, 0x7c, 0xc8, 0x01, 0x57, 0x03, 0xb9, 0x01, 0x69, 0x6f, 0x5a, 0x88, 0x26, 0xb9, 0x04, 0x3a, 0x88, 0x9c, + 0xfe, 0x7d, 0xfd, 0x35, 0x02, 0xcc, 0x75, 0x70, 0x60, 0x4e, 0xfc, 0xfd, 0x04, 0x3a, 0x00, 0x02, 0x00, 0x5b, 0xff, + 0xec, 0x04, 0x34, 0x04, 0x4e, 0x00, 0x0f, 0x00, 0x1b, 0x00, 0x45, 0xb2, 0x0c, 0x1c, 0x1d, 0x11, 0x12, 0x39, 0xb0, + 0x0c, 0x10, 0xb0, 0x13, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x12, 0x3e, 0x59, 0xb1, 0x13, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0x10, 0xb1, 0x19, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0x30, 0x31, 0x13, 0x34, 0x36, 0x36, 0x33, 0x32, 0x00, 0x15, 0x15, 0x14, 0x06, 0x06, 0x23, 0x22, 0x00, + 0x35, 0x17, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x5b, 0x7d, 0xdf, 0x8f, 0xdd, 0x01, + 0x11, 0x79, 0xe1, 0x92, 0xdc, 0xfe, 0xef, 0xba, 0xa7, 0x8c, 0x8d, 0xa6, 0xa9, 0x8c, 0x89, 0xa8, 0x02, 0x27, 0x9f, + 0xfe, 0x8a, 0xfe, 0xce, 0xfe, 0x0d, 0x9e, 0xfb, 0x8c, 0x01, 0x32, 0xfc, 0x09, 0xb4, 0xda, 0xdd, 0xc7, 0xb2, 0xdd, + 0xda, 0x00, 0x02, 0x00, 0x8c, 0xfe, 0x60, 0x04, 0x1e, 0x04, 0x4e, 0x00, 0x0f, 0x00, 0x1a, 0x00, 0x70, 0xb2, 0x13, + 0x1b, 0x1c, 0x11, 0x12, 0x39, 0xb0, 0x13, 0x10, 0xb0, 0x0c, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, + 0x1b, 0xb1, 0x0c, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x1a, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x14, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, + 0x2f, 0x1b, 0xb1, 0x03, 0x12, 0x3e, 0x59, 0xb2, 0x05, 0x0c, 0x03, 0x11, 0x12, 0x39, 0xb2, 0x0a, 0x0c, 0x03, 0x11, + 0x12, 0x39, 0xb0, 0x0c, 0x10, 0xb1, 0x13, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, + 0x10, 0xb1, 0x18, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x14, 0x02, 0x23, + 0x22, 0x27, 0x11, 0x23, 0x11, 0x33, 0x17, 0x36, 0x33, 0x32, 0x12, 0x11, 0x27, 0x34, 0x26, 0x23, 0x22, 0x07, 0x11, + 0x16, 0x33, 0x32, 0x36, 0x04, 0x1e, 0xe2, 0xc1, 0xc5, 0x71, 0xb9, 0xa9, 0x09, 0x71, 0xc9, 0xc3, 0xe3, 0xb9, 0x9c, + 0x88, 0xa8, 0x54, 0x53, 0xab, 0x85, 0x9d, 0x02, 0x11, 0xf7, 0xfe, 0xd2, 0x7d, 0xfd, 0xf7, 0x05, 0xda, 0x78, 0x8c, + 0xfe, 0xda, 0xfe, 0xfa, 0x04, 0xb7, 0xd4, 0x95, 0xfd, 0xfb, 0x94, 0xd3, 0x00, 0x00, 0x02, 0x00, 0x5f, 0xfe, 0x60, + 0x03, 0xef, 0x04, 0x4e, 0x00, 0x0f, 0x00, 0x1a, 0x00, 0x6d, 0xb2, 0x18, 0x1b, 0x1c, 0x11, 0x12, 0x39, 0xb0, 0x18, + 0x10, 0xb0, 0x03, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1a, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, + 0x1b, 0xb1, 0x08, 0x14, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x12, 0x3e, 0x59, + 0xb2, 0x05, 0x03, 0x0c, 0x11, 0x12, 0x39, 0xb2, 0x0a, 0x03, 0x0c, 0x11, 0x12, 0x39, 0xb1, 0x13, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x18, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x13, 0x34, 0x12, 0x33, 0x32, 0x17, 0x37, 0x33, 0x11, 0x23, 0x11, 0x06, 0x23, 0x22, + 0x02, 0x35, 0x17, 0x14, 0x16, 0x33, 0x32, 0x37, 0x11, 0x26, 0x23, 0x22, 0x06, 0x5f, 0xea, 0xc5, 0xc0, 0x6f, 0x08, + 0xaa, 0xb9, 0x70, 0xba, 0xc4, 0xe9, 0xb9, 0x9d, 0x85, 0xa5, 0x57, 0x58, 0xa2, 0x86, 0x9e, 0x02, 0x26, 0xff, 0x01, + 0x29, 0x81, 0x6d, 0xfa, 0x26, 0x02, 0x04, 0x78, 0x01, 0x31, 0xfc, 0x08, 0xba, 0xd4, 0x92, 0x02, 0x12, 0x8f, 0xd5, + 0x00, 0x01, 0x00, 0x8c, 0x00, 0x00, 0x02, 0x97, 0x04, 0x4e, 0x00, 0x0d, 0x00, 0x47, 0xb2, 0x04, 0x0e, 0x0f, 0x11, + 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, + 0x05, 0x12, 0x3e, 0x59, 0xb0, 0x0b, 0x10, 0xb1, 0x02, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb2, 0x09, 0x0b, 0x05, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x26, 0x23, 0x22, 0x07, 0x11, 0x23, 0x11, 0x33, 0x17, + 0x36, 0x33, 0x32, 0x17, 0x02, 0x97, 0x2a, 0x31, 0xb6, 0x41, 0xb9, 0xb4, 0x03, 0x5b, 0xa7, 0x36, 0x1c, 0x03, 0x94, + 0x07, 0x9b, 0xfd, 0x00, 0x04, 0x3a, 0x7d, 0x91, 0x0e, 0x00, 0x00, 0x01, 0x00, 0x5f, 0xff, 0xec, 0x03, 0xbb, 0x04, + 0x4e, 0x00, 0x26, 0x00, 0x64, 0xb2, 0x09, 0x27, 0x28, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, + 0x2f, 0x1b, 0xb1, 0x09, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x1c, 0x2f, 0x1b, 0xb1, 0x1c, 0x12, 0x3e, + 0x59, 0xb2, 0x03, 0x1c, 0x09, 0x11, 0x12, 0x39, 0xb0, 0x09, 0x10, 0xb0, 0x0d, 0xd0, 0xb0, 0x09, 0x10, 0xb1, 0x10, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x15, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x1c, 0x10, 0xb0, 0x21, 0xd0, 0xb0, 0x1c, 0x10, 0xb1, 0x24, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x34, 0x26, 0x24, 0x26, 0x26, 0x35, 0x34, 0x36, + 0x33, 0x32, 0x16, 0x15, 0x23, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x14, 0x16, 0x04, 0x16, 0x16, 0x15, 0x14, 0x06, + 0x23, 0x22, 0x26, 0x26, 0x35, 0x33, 0x16, 0x16, 0x33, 0x32, 0x36, 0x03, 0x02, 0x71, 0xfe, 0xe7, 0xa5, 0x4f, 0xe1, + 0xaf, 0xb8, 0xe5, 0xba, 0x81, 0x62, 0x65, 0x72, 0x6a, 0x01, 0x15, 0xac, 0x53, 0xe8, 0xb9, 0x82, 0xc8, 0x71, 0xb9, + 0x05, 0x8b, 0x72, 0x69, 0x7f, 0x01, 0x1f, 0x4b, 0x53, 0x3c, 0x54, 0x74, 0x50, 0x85, 0xb8, 0xbe, 0x94, 0x4c, 0x6e, + 0x58, 0x47, 0x43, 0x44, 0x3e, 0x56, 0x79, 0x57, 0x91, 0xaf, 0x5c, 0xa5, 0x60, 0x5d, 0x6d, 0x55, 0x00, 0x00, 0x01, + 0x00, 0x09, 0xff, 0xec, 0x02, 0x56, 0x05, 0x40, 0x00, 0x15, 0x00, 0x61, 0xb2, 0x0e, 0x16, 0x17, 0x11, 0x12, 0x39, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x13, 0x2f, 0x1b, 0xb1, 0x13, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x12, + 0x3e, 0x59, 0xb0, 0x01, 0x10, 0xb0, 0x00, 0xd0, 0xb0, 0x00, 0x2f, 0xb0, 0x01, 0x10, 0xb1, 0x03, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0d, 0x10, 0xb1, 0x08, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb0, 0x11, 0xd0, 0xb0, 0x12, 0xd0, 0x30, 0x31, 0x01, 0x11, 0x33, 0x15, 0x23, + 0x11, 0x14, 0x16, 0x33, 0x32, 0x37, 0x15, 0x06, 0x23, 0x22, 0x26, 0x35, 0x11, 0x23, 0x35, 0x33, 0x11, 0x01, 0x87, + 0xca, 0xca, 0x36, 0x41, 0x20, 0x38, 0x49, 0x45, 0x7c, 0x7e, 0xc5, 0xc5, 0x05, 0x40, 0xfe, 0xfa, 0x8f, 0xfd, 0x61, + 0x41, 0x41, 0x0c, 0x96, 0x14, 0x96, 0x8a, 0x02, 0x9f, 0x8f, 0x01, 0x06, 0x00, 0x01, 0x00, 0x88, 0xff, 0xec, 0x03, + 0xdc, 0x04, 0x3a, 0x00, 0x10, 0x00, 0x54, 0xb2, 0x0a, 0x11, 0x12, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, + 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x12, 0x3e, 0x59, 0xb2, 0x00, 0x0d, 0x02, 0x11, 0x12, 0x39, 0xb0, 0x02, + 0x10, 0xb1, 0x0a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x25, 0x06, 0x23, 0x22, + 0x26, 0x27, 0x11, 0x33, 0x11, 0x14, 0x33, 0x32, 0x37, 0x11, 0x33, 0x11, 0x23, 0x03, 0x28, 0x6c, 0xd1, 0xad, 0xb5, + 0x01, 0xb9, 0xc8, 0xd4, 0x46, 0xb9, 0xb0, 0x6b, 0x7f, 0xc9, 0xc5, 0x02, 0xc0, 0xfd, 0x45, 0xf6, 0x9e, 0x03, 0x13, + 0xfb, 0xc6, 0x00, 0x01, 0x00, 0x21, 0x00, 0x00, 0x03, 0xba, 0x04, 0x3a, 0x00, 0x06, 0x00, 0x38, 0xb2, 0x00, 0x07, + 0x08, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x1a, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, + 0x1b, 0xb1, 0x03, 0x12, 0x3e, 0x59, 0xb2, 0x00, 0x05, 0x03, 0x11, 0x12, 0x39, 0x30, 0x31, 0x25, 0x01, 0x33, 0x01, + 0x23, 0x01, 0x33, 0x01, 0xf1, 0x01, 0x0c, 0xbd, 0xfe, 0x7c, 0x8d, 0xfe, 0x78, 0xbd, 0xfb, 0x03, 0x3f, 0xfb, 0xc6, + 0x04, 0x3a, 0x00, 0x00, 0x01, 0x00, 0x2b, 0x00, 0x00, 0x05, 0xd3, 0x04, 0x3a, 0x00, 0x0c, 0x00, 0x60, 0xb2, 0x05, + 0x0d, 0x0e, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x1a, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, + 0x2f, 0x1b, 0xb1, 0x0b, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x12, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x12, 0x3e, 0x59, 0xb2, 0x00, 0x0b, 0x03, 0x11, + 0x12, 0x39, 0xb2, 0x05, 0x0b, 0x03, 0x11, 0x12, 0x39, 0xb2, 0x0a, 0x0b, 0x03, 0x11, 0x12, 0x39, 0x30, 0x31, 0x25, + 0x13, 0x33, 0x01, 0x23, 0x01, 0x01, 0x23, 0x01, 0x33, 0x13, 0x13, 0x33, 0x04, 0x4a, 0xd0, 0xb9, 0xfe, 0xc5, 0x96, + 0xfe, 0xf9, 0xff, 0x00, 0x96, 0xfe, 0xc6, 0xb8, 0xd5, 0xfc, 0x95, 0xff, 0x03, 0x3b, 0xfb, 0xc6, 0x03, 0x34, 0xfc, + 0xcc, 0x04, 0x3a, 0xfc, 0xd6, 0x03, 0x2a, 0x00, 0x01, 0x00, 0x29, 0x00, 0x00, 0x03, 0xca, 0x04, 0x3a, 0x00, 0x0b, + 0x00, 0x53, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, + 0x04, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x12, 0x3e, 0x59, 0xb2, 0x00, + 0x0a, 0x04, 0x11, 0x12, 0x39, 0xb2, 0x06, 0x0a, 0x04, 0x11, 0x12, 0x39, 0xb2, 0x03, 0x00, 0x06, 0x11, 0x12, 0x39, + 0xb2, 0x09, 0x06, 0x00, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x13, 0x33, 0x01, 0x01, 0x23, 0x03, 0x03, 0x23, 0x01, + 0x01, 0x33, 0x01, 0xf7, 0xf0, 0xd8, 0xfe, 0x9e, 0x01, 0x6d, 0xd6, 0xfa, 0xfa, 0xd7, 0x01, 0x6d, 0xfe, 0x9e, 0xd6, + 0x02, 0xaf, 0x01, 0x8b, 0xfd, 0xe9, 0xfd, 0xdd, 0x01, 0x95, 0xfe, 0x6b, 0x02, 0x23, 0x02, 0x17, 0x00, 0x01, 0x00, + 0x16, 0xfe, 0x4b, 0x03, 0xb0, 0x04, 0x3a, 0x00, 0x0f, 0x00, 0x4a, 0xb2, 0x00, 0x10, 0x11, 0x11, 0x12, 0x39, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0e, + 0x2f, 0x1b, 0xb1, 0x0e, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x14, 0x3e, + 0x59, 0xb2, 0x00, 0x0e, 0x05, 0x11, 0x12, 0x39, 0xb1, 0x09, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb0, 0x00, 0x10, 0xb0, 0x0d, 0xd0, 0x30, 0x31, 0x01, 0x13, 0x33, 0x01, 0x02, 0x23, 0x27, 0x27, 0x35, 0x17, + 0x32, 0x36, 0x37, 0x37, 0x01, 0x33, 0x01, 0xee, 0xfc, 0xc6, 0xfe, 0x4d, 0x65, 0xdc, 0x23, 0x45, 0x32, 0x5e, 0x69, + 0x22, 0x29, 0xfe, 0x7e, 0xca, 0x01, 0x0f, 0x03, 0x2b, 0xfb, 0x1f, 0xfe, 0xf2, 0x03, 0x0d, 0x96, 0x04, 0x4c, 0x65, + 0x6e, 0x04, 0x2e, 0x00, 0x00, 0x01, 0x00, 0x58, 0x00, 0x00, 0x03, 0xb3, 0x04, 0x3a, 0x00, 0x09, 0x00, 0x46, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, + 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb2, 0x04, 0x00, 0x02, 0x11, 0x12, 0x39, 0xb0, 0x07, 0x10, 0xb1, 0x05, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb2, 0x09, 0x05, 0x07, 0x11, 0x12, 0x39, 0x30, 0x31, 0x25, 0x21, 0x15, 0x21, 0x35, 0x01, 0x21, + 0x35, 0x21, 0x15, 0x01, 0x3a, 0x02, 0x79, 0xfc, 0xa5, 0x02, 0x55, 0xfd, 0xb4, 0x03, 0x34, 0x97, 0x97, 0x88, 0x03, + 0x19, 0x99, 0x83, 0x00, 0x00, 0x01, 0x00, 0x40, 0xfe, 0x92, 0x02, 0x9e, 0x06, 0x3d, 0x00, 0x18, 0x00, 0x32, 0xb2, + 0x13, 0x19, 0x1a, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x0d, 0x2f, 0xb0, 0x00, 0x2f, 0xb2, 0x07, 0x0d, 0x00, 0x11, 0x12, + 0x39, 0xb0, 0x07, 0x2f, 0xb2, 0x1f, 0x07, 0x01, 0x5d, 0xb1, 0x06, 0x03, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb2, 0x13, 0x06, 0x07, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x26, 0x26, 0x35, 0x35, 0x34, 0x23, 0x35, + 0x32, 0x35, 0x35, 0x36, 0x36, 0x37, 0x17, 0x06, 0x11, 0x15, 0x14, 0x07, 0x16, 0x15, 0x15, 0x12, 0x17, 0x02, 0x78, + 0xb1, 0xb3, 0xd4, 0xd4, 0x02, 0xaf, 0xb3, 0x26, 0xd1, 0xa7, 0xa7, 0x03, 0xce, 0xfe, 0x92, 0x32, 0xe5, 0xbc, 0xc7, + 0xf3, 0x91, 0xf2, 0xd0, 0xb7, 0xe1, 0x33, 0x73, 0x43, 0xfe, 0xe6, 0xca, 0xe3, 0x59, 0x5a, 0xe5, 0xce, 0xfe, 0xed, + 0x42, 0x00, 0x01, 0x00, 0xaf, 0xfe, 0xf2, 0x01, 0x44, 0x05, 0xb0, 0x00, 0x03, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x2f, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1e, 0x3e, 0x59, 0x30, 0x31, 0x01, 0x23, 0x11, 0x33, + 0x01, 0x44, 0x95, 0x95, 0xfe, 0xf2, 0x06, 0xbe, 0x00, 0x00, 0x01, 0x00, 0x13, 0xfe, 0x92, 0x02, 0x72, 0x06, 0x3d, + 0x00, 0x18, 0x00, 0x32, 0xb2, 0x05, 0x19, 0x1a, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x0b, 0x2f, 0xb0, 0x18, 0x2f, 0xb2, + 0x11, 0x0b, 0x18, 0x11, 0x12, 0x39, 0xb0, 0x11, 0x2f, 0xb2, 0x1f, 0x11, 0x01, 0x5d, 0xb1, 0x12, 0x03, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x05, 0x12, 0x11, 0x11, 0x12, 0x39, 0x30, 0x31, 0x17, 0x36, 0x13, + 0x35, 0x34, 0x37, 0x26, 0x35, 0x35, 0x10, 0x27, 0x37, 0x16, 0x16, 0x17, 0x15, 0x14, 0x33, 0x15, 0x22, 0x15, 0x15, + 0x14, 0x06, 0x07, 0x13, 0xcb, 0x07, 0xb5, 0xb5, 0xd1, 0x26, 0xb1, 0xb2, 0x01, 0xd4, 0xd4, 0xb5, 0xaf, 0xfb, 0x41, + 0x01, 0x0a, 0xdc, 0xe7, 0x54, 0x52, 0xe9, 0xcb, 0x01, 0x1a, 0x43, 0x73, 0x32, 0xe1, 0xb9, 0xd2, 0xef, 0x91, 0xf3, + 0xca, 0xbc, 0xe2, 0x32, 0x00, 0x01, 0x00, 0x83, 0x01, 0x92, 0x04, 0xef, 0x03, 0x22, 0x00, 0x17, 0x00, 0x44, 0xb2, + 0x11, 0x18, 0x19, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0f, 0x2f, 0x1b, 0xb1, 0x0f, 0x18, 0x3e, + 0x59, 0xb0, 0x00, 0xd0, 0xb0, 0x0f, 0x10, 0xb0, 0x14, 0xd0, 0xb0, 0x14, 0x2f, 0xb1, 0x03, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0f, 0x10, 0xb1, 0x08, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb0, 0x0b, 0xd0, 0x30, 0x31, 0x01, 0x14, 0x06, 0x23, 0x22, 0x2e, 0x02, 0x23, 0x22, + 0x06, 0x15, 0x07, 0x34, 0x36, 0x33, 0x32, 0x16, 0x16, 0x17, 0x17, 0x32, 0x36, 0x35, 0x04, 0xef, 0xbb, 0x89, 0x48, + 0x80, 0xa9, 0x4a, 0x2a, 0x4e, 0x54, 0xa1, 0xb8, 0x8b, 0x4c, 0x8c, 0xb0, 0x40, 0x1d, 0x4c, 0x5f, 0x03, 0x09, 0x9e, + 0xd9, 0x35, 0x94, 0x24, 0x6b, 0x5e, 0x02, 0xa0, 0xce, 0x40, 0xa1, 0x0a, 0x02, 0x74, 0x5f, 0x00, 0x02, 0x00, 0x8b, + 0xfe, 0x98, 0x01, 0x66, 0x04, 0x4d, 0x00, 0x03, 0x00, 0x0c, 0x00, 0x33, 0xb2, 0x06, 0x0d, 0x0e, 0x11, 0x12, 0x39, + 0xb0, 0x06, 0x10, 0xb0, 0x00, 0xd0, 0x00, 0xb0, 0x02, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, + 0x0b, 0x1a, 0x3e, 0x59, 0xb1, 0x06, 0x05, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x01, 0x02, + 0x06, 0x11, 0x12, 0x39, 0x30, 0x31, 0x13, 0x33, 0x13, 0x23, 0x13, 0x14, 0x06, 0x22, 0x26, 0x34, 0x36, 0x32, 0x16, + 0xaa, 0xa8, 0x0d, 0xc2, 0xc9, 0x37, 0x6c, 0x38, 0x38, 0x6c, 0x37, 0x02, 0xac, 0xfb, 0xec, 0x05, 0x4c, 0x2d, 0x3e, + 0x3e, 0x5a, 0x3c, 0x3c, 0x00, 0x00, 0x01, 0x00, 0x69, 0xff, 0x0b, 0x03, 0xf9, 0x05, 0x26, 0x00, 0x21, 0x00, 0x54, + 0xb2, 0x00, 0x22, 0x23, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x14, 0x2f, 0x1b, 0xb1, 0x14, 0x1a, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x12, 0x3e, 0x59, 0xb0, 0x07, 0xd0, 0xb1, + 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0a, 0x10, 0xb0, 0x03, 0xd0, 0xb0, 0x14, + 0x10, 0xb0, 0x11, 0xd0, 0xb0, 0x14, 0x10, 0xb0, 0x18, 0xd0, 0xb0, 0x14, 0x10, 0xb1, 0x1b, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x25, 0x32, 0x36, 0x37, 0x33, 0x06, 0x06, 0x07, 0x15, 0x23, 0x35, + 0x26, 0x02, 0x35, 0x35, 0x34, 0x12, 0x37, 0x35, 0x33, 0x15, 0x16, 0x16, 0x17, 0x23, 0x26, 0x26, 0x23, 0x22, 0x06, + 0x15, 0x15, 0x14, 0x16, 0x02, 0x4a, 0x64, 0x94, 0x08, 0xaf, 0x06, 0xc6, 0x90, 0xb9, 0xb3, 0xc8, 0xca, 0xb1, 0xb9, + 0x96, 0xc0, 0x06, 0xaf, 0x08, 0x8f, 0x69, 0x8d, 0x9b, 0x9b, 0x83, 0x79, 0x59, 0x7e, 0xc9, 0x1a, 0xe9, 0xea, 0x22, + 0x01, 0x1c, 0xdc, 0x23, 0xd4, 0x01, 0x1d, 0x21, 0xe2, 0xdf, 0x17, 0xd4, 0x96, 0x69, 0x87, 0xcb, 0xc0, 0x23, 0xbb, + 0xca, 0x00, 0x01, 0x00, 0x5b, 0x00, 0x00, 0x04, 0x68, 0x05, 0xc4, 0x00, 0x21, 0x00, 0x7f, 0xb2, 0x1c, 0x22, 0x23, + 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x14, 0x2f, 0x1b, 0xb1, 0x14, 0x1e, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x12, 0x3e, 0x59, 0xb2, 0x1f, 0x14, 0x05, 0x11, 0x12, 0x39, 0xb0, + 0x1f, 0x2f, 0xb2, 0x5f, 0x1f, 0x01, 0x72, 0xb2, 0x8f, 0x1f, 0x01, 0x71, 0xb2, 0xbf, 0x1f, 0x01, 0x5d, 0xb1, 0x00, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x05, 0x10, 0xb1, 0x03, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x07, 0xd0, 0xb0, 0x08, 0xd0, 0xb0, 0x00, 0x10, 0xb0, 0x0d, 0xd0, 0xb0, + 0x1f, 0x10, 0xb0, 0x0f, 0xd0, 0xb0, 0x14, 0x10, 0xb0, 0x18, 0xd0, 0xb0, 0x14, 0x10, 0xb1, 0x1b, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x17, 0x14, 0x07, 0x21, 0x07, 0x21, 0x35, 0x33, 0x36, + 0x36, 0x37, 0x35, 0x27, 0x23, 0x35, 0x33, 0x03, 0x34, 0x36, 0x33, 0x32, 0x16, 0x15, 0x23, 0x34, 0x26, 0x23, 0x22, + 0x06, 0x15, 0x13, 0x21, 0x15, 0x01, 0xc1, 0x08, 0x3e, 0x02, 0xdd, 0x01, 0xfb, 0xf8, 0x4d, 0x28, 0x32, 0x02, 0x08, + 0xa5, 0xa0, 0x09, 0xf5, 0xc8, 0xbe, 0xde, 0xbf, 0x7f, 0x6f, 0x69, 0x82, 0x09, 0x01, 0x3f, 0x02, 0x6e, 0xdc, 0x9a, + 0x5b, 0x9d, 0x9d, 0x09, 0x83, 0x60, 0x08, 0xdd, 0x9d, 0x01, 0x04, 0xc7, 0xee, 0xd4, 0xb1, 0x6b, 0x7c, 0x9a, 0x7d, + 0xfe, 0xfc, 0x9d, 0x00, 0x02, 0x00, 0x69, 0xff, 0xe5, 0x05, 0x5b, 0x04, 0xf1, 0x00, 0x1b, 0x00, 0x2a, 0x00, 0x41, + 0xb2, 0x02, 0x2b, 0x2c, 0x11, 0x12, 0x39, 0xb0, 0x02, 0x10, 0xb0, 0x27, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x10, 0xd0, 0xb0, 0x10, 0x2f, 0xb0, 0x02, 0x10, 0xb1, 0x1f, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x10, 0x10, 0xb1, 0x27, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x25, 0x06, 0x23, 0x22, 0x27, 0x07, 0x27, 0x37, 0x26, 0x35, 0x34, + 0x37, 0x27, 0x37, 0x17, 0x36, 0x33, 0x32, 0x17, 0x37, 0x17, 0x07, 0x16, 0x15, 0x14, 0x07, 0x17, 0x07, 0x01, 0x14, + 0x16, 0x16, 0x32, 0x36, 0x36, 0x35, 0x34, 0x26, 0x26, 0x23, 0x22, 0x06, 0x06, 0x04, 0x4f, 0x9f, 0xd1, 0xcf, 0x9f, + 0x86, 0x82, 0x8b, 0x68, 0x70, 0x93, 0x82, 0x93, 0x9e, 0xc3, 0xc4, 0x9f, 0x95, 0x84, 0x97, 0x6e, 0x66, 0x8f, 0x84, + 0xfc, 0x60, 0x73, 0xc4, 0xe2, 0xc4, 0x71, 0x71, 0xc5, 0x70, 0x71, 0xc4, 0x73, 0x70, 0x84, 0x82, 0x88, 0x87, 0x8d, + 0x9c, 0xca, 0xce, 0xa3, 0x97, 0x88, 0x96, 0x78, 0x79, 0x98, 0x89, 0x9a, 0xa3, 0xcb, 0xc4, 0x9f, 0x90, 0x88, 0x02, + 0x7b, 0x7b, 0xd4, 0x7a, 0x7b, 0xd3, 0x7b, 0x7a, 0xd3, 0x79, 0x78, 0xd4, 0x00, 0x00, 0x01, 0x00, 0x0f, 0x00, 0x00, + 0x04, 0x24, 0x05, 0xb0, 0x00, 0x16, 0x00, 0x71, 0xb2, 0x00, 0x17, 0x18, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, + 0x0b, 0x12, 0x3e, 0x59, 0xb2, 0x00, 0x0b, 0x01, 0x11, 0x12, 0x39, 0xb2, 0x07, 0x01, 0x0b, 0x11, 0x12, 0x39, 0xb0, + 0x07, 0x2f, 0xb0, 0x03, 0xd0, 0xb0, 0x03, 0x2f, 0xb1, 0x05, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb0, 0x07, 0x10, 0xb1, 0x09, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0d, 0xd0, + 0xb0, 0x07, 0x10, 0xb0, 0x0f, 0xd0, 0xb0, 0x05, 0x10, 0xb0, 0x11, 0xd0, 0xb0, 0x03, 0x10, 0xb0, 0x13, 0xd0, 0xb0, + 0x01, 0x10, 0xb0, 0x15, 0xd0, 0x30, 0x31, 0x01, 0x01, 0x33, 0x01, 0x21, 0x15, 0x21, 0x15, 0x21, 0x15, 0x21, 0x11, + 0x23, 0x11, 0x21, 0x35, 0x21, 0x35, 0x21, 0x35, 0x21, 0x01, 0x33, 0x02, 0x1b, 0x01, 0x34, 0xd5, 0xfe, 0x91, 0x01, + 0x05, 0xfe, 0xbc, 0x01, 0x44, 0xfe, 0xbc, 0xc1, 0xfe, 0xc2, 0x01, 0x3e, 0xfe, 0xc2, 0x01, 0x07, 0xfe, 0x91, 0xd8, + 0x03, 0x19, 0x02, 0x97, 0xfd, 0x30, 0x7d, 0xa5, 0x7c, 0xfe, 0xbe, 0x01, 0x42, 0x7c, 0xa5, 0x7d, 0x02, 0xd0, 0x00, + 0x00, 0x02, 0x00, 0x93, 0xfe, 0xf2, 0x01, 0x4d, 0x05, 0xb0, 0x00, 0x03, 0x00, 0x07, 0x00, 0x18, 0x00, 0xb0, 0x00, + 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb2, 0x05, 0x01, 0x03, 0x2b, + 0x30, 0x31, 0x13, 0x11, 0x33, 0x11, 0x11, 0x23, 0x11, 0x33, 0x93, 0xba, 0xba, 0xba, 0xfe, 0xf2, 0x03, 0x17, 0xfc, + 0xe9, 0x03, 0xc8, 0x02, 0xf6, 0x00, 0x02, 0x00, 0x5a, 0xfe, 0x11, 0x04, 0x79, 0x05, 0xc4, 0x00, 0x34, 0x00, 0x44, + 0x00, 0x84, 0xb2, 0x23, 0x45, 0x46, 0x11, 0x12, 0x39, 0xb0, 0x23, 0x10, 0xb0, 0x35, 0xd0, 0x00, 0xb0, 0x08, 0x2f, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x23, 0x2f, 0x1b, 0xb1, 0x23, 0x1e, 0x3e, 0x59, 0xb2, 0x16, 0x08, 0x23, 0x11, 0x12, + 0x39, 0xb0, 0x16, 0x10, 0xb1, 0x3f, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x02, 0x16, + 0x3f, 0x11, 0x12, 0x39, 0xb0, 0x08, 0x10, 0xb0, 0x0e, 0xd0, 0xb0, 0x08, 0x10, 0xb1, 0x11, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x30, 0x23, 0x08, 0x11, 0x12, 0x39, 0xb0, 0x30, 0x10, 0xb1, 0x37, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x1d, 0x37, 0x30, 0x11, 0x12, 0x39, 0xb0, 0x23, 0x10, + 0xb0, 0x27, 0xd0, 0xb0, 0x23, 0x10, 0xb1, 0x2a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, + 0x31, 0x01, 0x14, 0x07, 0x16, 0x16, 0x15, 0x14, 0x04, 0x23, 0x22, 0x26, 0x27, 0x26, 0x35, 0x37, 0x14, 0x16, 0x33, + 0x32, 0x36, 0x35, 0x34, 0x26, 0x27, 0x2e, 0x02, 0x35, 0x34, 0x37, 0x26, 0x26, 0x35, 0x34, 0x24, 0x33, 0x32, 0x04, + 0x15, 0x23, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x14, 0x16, 0x16, 0x04, 0x1e, 0x02, 0x25, 0x26, 0x27, 0x06, 0x06, + 0x15, 0x14, 0x16, 0x16, 0x04, 0x17, 0x36, 0x36, 0x35, 0x34, 0x26, 0x04, 0x79, 0xba, 0x45, 0x48, 0xfe, 0xfc, 0xe4, + 0x70, 0xc9, 0x46, 0x8b, 0xba, 0xb4, 0x9c, 0x88, 0xa6, 0x8e, 0xd1, 0xb6, 0xc0, 0x5d, 0xb6, 0x42, 0x47, 0x01, 0x0b, + 0xde, 0xe8, 0x01, 0x04, 0xb9, 0xa8, 0x8b, 0x8e, 0xa1, 0x38, 0x87, 0x01, 0x1f, 0xa9, 0x71, 0x3a, 0xfd, 0xe1, 0x5a, + 0x4b, 0x50, 0x4b, 0x36, 0x85, 0x01, 0x1c, 0x2c, 0x4e, 0x54, 0x8b, 0x01, 0xaf, 0xbd, 0x55, 0x31, 0x88, 0x64, 0xa8, + 0xc7, 0x38, 0x39, 0x71, 0xcd, 0x02, 0x82, 0x97, 0x75, 0x60, 0x59, 0x69, 0x3e, 0x30, 0x6f, 0x9b, 0x6f, 0xba, 0x58, + 0x31, 0x88, 0x64, 0xa6, 0xc8, 0xe2, 0xcd, 0x7d, 0x9b, 0x73, 0x62, 0x45, 0x50, 0x41, 0x50, 0x48, 0x61, 0x81, 0xab, + 0x18, 0x1b, 0x13, 0x65, 0x45, 0x46, 0x50, 0x42, 0x52, 0x11, 0x14, 0x65, 0x45, 0x58, 0x6d, 0x00, 0x00, 0x02, 0x00, + 0x65, 0x04, 0xf0, 0x02, 0xee, 0x05, 0xc5, 0x00, 0x08, 0x00, 0x11, 0x00, 0x1e, 0x00, 0xb0, 0x07, 0x2f, 0xb1, 0x02, + 0x05, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0b, 0xd0, 0xb0, 0x07, 0x10, 0xb0, 0x10, 0xd0, + 0xb0, 0x10, 0x2f, 0x30, 0x31, 0x13, 0x34, 0x36, 0x32, 0x16, 0x14, 0x06, 0x22, 0x26, 0x25, 0x34, 0x36, 0x32, 0x16, + 0x14, 0x06, 0x22, 0x26, 0x65, 0x37, 0x6c, 0x38, 0x38, 0x6c, 0x37, 0x01, 0xae, 0x37, 0x6c, 0x38, 0x38, 0x6c, 0x37, + 0x05, 0x5b, 0x2d, 0x3d, 0x3d, 0x5a, 0x3c, 0x3c, 0x2b, 0x2d, 0x3e, 0x3e, 0x5a, 0x3c, 0x3c, 0x00, 0x03, 0x00, 0x5b, + 0xff, 0xeb, 0x05, 0xe6, 0x05, 0xc4, 0x00, 0x1b, 0x00, 0x2a, 0x00, 0x39, 0x00, 0x99, 0xb2, 0x27, 0x3a, 0x3b, 0x11, + 0x12, 0x39, 0xb0, 0x27, 0x10, 0xb0, 0x03, 0xd0, 0xb0, 0x27, 0x10, 0xb0, 0x36, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x2e, 0x2f, 0x1b, 0xb1, 0x2e, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x36, 0x2f, 0x1b, 0xb1, 0x36, + 0x12, 0x3e, 0x59, 0xb2, 0x03, 0x36, 0x2e, 0x11, 0x12, 0x39, 0xb0, 0x03, 0x2f, 0xb4, 0x0f, 0x03, 0x1f, 0x03, 0x02, + 0x5d, 0xb2, 0x0a, 0x2e, 0x36, 0x11, 0x12, 0x39, 0xb0, 0x0a, 0x2f, 0xb4, 0x00, 0x0a, 0x10, 0x0a, 0x02, 0x5d, 0xb2, + 0x0e, 0x0a, 0x03, 0x11, 0x12, 0x39, 0xb1, 0x11, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x03, 0x10, 0xb1, 0x18, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x1b, 0x03, 0x0a, 0x11, + 0x12, 0x39, 0xb0, 0x36, 0x10, 0xb1, 0x20, 0x04, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x2e, + 0x10, 0xb1, 0x27, 0x04, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x14, 0x06, 0x23, + 0x22, 0x26, 0x35, 0x35, 0x34, 0x36, 0x33, 0x32, 0x16, 0x15, 0x23, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14, + 0x16, 0x33, 0x32, 0x36, 0x35, 0x25, 0x14, 0x12, 0x04, 0x20, 0x24, 0x12, 0x35, 0x34, 0x02, 0x24, 0x23, 0x22, 0x04, + 0x02, 0x07, 0x34, 0x12, 0x24, 0x20, 0x04, 0x12, 0x15, 0x14, 0x02, 0x04, 0x23, 0x22, 0x24, 0x02, 0x04, 0x5f, 0xad, + 0x9e, 0x9d, 0xbd, 0xbf, 0x9b, 0xa0, 0xac, 0x92, 0x5f, 0x5b, 0x5e, 0x6c, 0x6c, 0x5e, 0x5c, 0x5d, 0xfd, 0x01, 0xa0, + 0x01, 0x13, 0x01, 0x40, 0x01, 0x12, 0xa0, 0x9e, 0xfe, 0xed, 0xa1, 0xa0, 0xfe, 0xec, 0x9f, 0x73, 0xbb, 0x01, 0x4b, + 0x01, 0x80, 0x01, 0x4a, 0xbb, 0xb4, 0xfe, 0xb5, 0xc6, 0xc5, 0xfe, 0xb5, 0xb6, 0x02, 0x55, 0x99, 0xa1, 0xd3, 0xb6, + 0x6e, 0xb0, 0xd3, 0xa4, 0x95, 0x63, 0x55, 0x8a, 0x7b, 0x71, 0x78, 0x8a, 0x54, 0x65, 0x84, 0xac, 0xfe, 0xdb, 0xa6, + 0xa6, 0x01, 0x25, 0xac, 0xaa, 0x01, 0x22, 0xa7, 0xa5, 0xfe, 0xdc, 0xaa, 0xca, 0x01, 0x5a, 0xc7, 0xc7, 0xfe, 0xa6, + 0xca, 0xc5, 0xfe, 0xa8, 0xd1, 0xcf, 0x01, 0x58, 0x00, 0x00, 0x02, 0x00, 0x93, 0x02, 0xb3, 0x03, 0x0f, 0x05, 0xc4, + 0x00, 0x1b, 0x00, 0x25, 0x00, 0x6f, 0xb2, 0x0e, 0x26, 0x27, 0x11, 0x12, 0x39, 0xb0, 0x0e, 0x10, 0xb0, 0x1d, 0xd0, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x15, 0x2f, 0x1b, 0xb1, 0x15, 0x1e, 0x3e, 0x59, 0xb2, 0x04, 0x26, 0x15, 0x11, + 0x12, 0x39, 0xb0, 0x04, 0x2f, 0xb0, 0x00, 0xd0, 0xb2, 0x02, 0x04, 0x15, 0x11, 0x12, 0x39, 0xb2, 0x0b, 0x04, 0x15, + 0x11, 0x12, 0x39, 0xb0, 0x0b, 0x2f, 0xb0, 0x15, 0x10, 0xb1, 0x0e, 0x03, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb2, 0x11, 0x0b, 0x15, 0x11, 0x12, 0x39, 0xb0, 0x04, 0x10, 0xb1, 0x1c, 0x03, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0b, 0x10, 0xb1, 0x20, 0x04, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0x30, 0x31, 0x01, 0x26, 0x27, 0x06, 0x23, 0x22, 0x26, 0x35, 0x34, 0x36, 0x33, 0x33, 0x35, 0x34, 0x23, 0x22, + 0x06, 0x15, 0x27, 0x34, 0x36, 0x33, 0x32, 0x16, 0x15, 0x11, 0x14, 0x17, 0x25, 0x32, 0x36, 0x37, 0x35, 0x23, 0x06, + 0x06, 0x15, 0x14, 0x02, 0x6a, 0x0c, 0x06, 0x4c, 0x80, 0x77, 0x82, 0xa7, 0xac, 0x6c, 0x7c, 0x45, 0x4f, 0xa1, 0xac, + 0x89, 0x85, 0x9a, 0x1a, 0xfe, 0xa4, 0x2b, 0x58, 0x1c, 0x70, 0x53, 0x59, 0x02, 0xc1, 0x22, 0x26, 0x56, 0x7c, 0x67, + 0x6f, 0x78, 0x34, 0x87, 0x36, 0x33, 0x0c, 0x67, 0x82, 0x8f, 0x86, 0xfe, 0xc4, 0x61, 0x51, 0x7b, 0x28, 0x1b, 0x8e, + 0x01, 0x3f, 0x33, 0x5e, 0x00, 0xff, 0xff, 0x00, 0x66, 0x00, 0x97, 0x03, 0x64, 0x03, 0xb3, 0x00, 0x26, 0x01, 0x92, + 0xfa, 0xfe, 0x00, 0x07, 0x01, 0x92, 0x01, 0x44, 0xff, 0xfe, 0x00, 0x01, 0x00, 0x7f, 0x01, 0x77, 0x03, 0xbe, 0x03, + 0x20, 0x00, 0x05, 0x00, 0x1b, 0x00, 0xb0, 0x04, 0x2f, 0xb0, 0x01, 0xd0, 0xb0, 0x01, 0x2f, 0xb0, 0x04, 0x10, 0xb1, + 0x02, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x23, 0x11, 0x21, 0x35, 0x21, + 0x03, 0xbe, 0xba, 0xfd, 0x7b, 0x03, 0x3f, 0x01, 0x77, 0x01, 0x08, 0xa1, 0x00, 0x00, 0x04, 0x00, 0x5a, 0xff, 0xeb, + 0x05, 0xe5, 0x05, 0xc4, 0x00, 0x0e, 0x00, 0x1e, 0x00, 0x34, 0x00, 0x3d, 0x00, 0xad, 0xb2, 0x36, 0x3e, 0x3f, 0x11, + 0x12, 0x39, 0xb0, 0x36, 0x10, 0xb0, 0x0b, 0xd0, 0xb0, 0x36, 0x10, 0xb0, 0x13, 0xd0, 0xb0, 0x36, 0x10, 0xb0, 0x23, + 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x12, 0x3e, 0x59, 0xb1, 0x13, 0x04, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x1b, 0x04, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x20, + 0x0b, 0x03, 0x11, 0x12, 0x39, 0xb0, 0x20, 0x2f, 0xb2, 0x22, 0x03, 0x0b, 0x11, 0x12, 0x39, 0xb0, 0x22, 0x2f, 0xb4, + 0x00, 0x22, 0x10, 0x22, 0x02, 0x5d, 0xb2, 0x35, 0x20, 0x22, 0x11, 0x12, 0x39, 0xb0, 0x35, 0x2f, 0xb2, 0xbf, 0x35, + 0x01, 0x5d, 0xb4, 0x00, 0x35, 0x10, 0x35, 0x02, 0x5d, 0xb1, 0x1f, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb2, 0x28, 0x1f, 0x35, 0x11, 0x12, 0x39, 0xb0, 0x20, 0x10, 0xb0, 0x2f, 0xd0, 0xb0, 0x2f, 0x2f, 0xb0, + 0x22, 0x10, 0xb1, 0x3d, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x13, 0x34, 0x12, + 0x24, 0x20, 0x04, 0x12, 0x15, 0x14, 0x02, 0x04, 0x23, 0x22, 0x24, 0x02, 0x37, 0x14, 0x12, 0x04, 0x33, 0x32, 0x24, + 0x12, 0x35, 0x34, 0x02, 0x24, 0x23, 0x22, 0x04, 0x02, 0x05, 0x11, 0x23, 0x11, 0x21, 0x32, 0x16, 0x15, 0x14, 0x07, + 0x16, 0x17, 0x15, 0x14, 0x17, 0x15, 0x23, 0x26, 0x34, 0x27, 0x26, 0x27, 0x27, 0x33, 0x36, 0x36, 0x35, 0x34, 0x26, + 0x23, 0x23, 0x5a, 0xbb, 0x01, 0x4b, 0x01, 0x80, 0x01, 0x4a, 0xbb, 0xb4, 0xfe, 0xb5, 0xc6, 0xc5, 0xfe, 0xb5, 0xb6, + 0x73, 0xa0, 0x01, 0x13, 0xa0, 0xa1, 0x01, 0x14, 0x9d, 0x9d, 0xfe, 0xec, 0xa1, 0xa0, 0xfe, 0xec, 0x9f, 0x01, 0xc0, + 0x8d, 0x01, 0x14, 0x99, 0xa9, 0x80, 0x7a, 0x01, 0x11, 0x91, 0x0e, 0x03, 0x10, 0x73, 0xb0, 0x9c, 0x48, 0x58, 0x4e, + 0x64, 0x8a, 0x02, 0xd9, 0xca, 0x01, 0x5a, 0xc7, 0xc7, 0xfe, 0xa6, 0xca, 0xc5, 0xfe, 0xa8, 0xd1, 0xcf, 0x01, 0x58, + 0xc7, 0xac, 0xfe, 0xdb, 0xa6, 0xa9, 0x01, 0x22, 0xac, 0xab, 0x01, 0x21, 0xa7, 0xa5, 0xfe, 0xdc, 0xf5, 0xfe, 0xae, + 0x03, 0x51, 0x83, 0x7d, 0x7b, 0x41, 0x32, 0x9a, 0x3d, 0x56, 0x26, 0x10, 0x24, 0xb9, 0x11, 0x60, 0x04, 0x80, 0x02, + 0x42, 0x36, 0x49, 0x3d, 0x00, 0x00, 0x01, 0x00, 0x8e, 0x05, 0x16, 0x03, 0x2e, 0x05, 0xa5, 0x00, 0x03, 0x00, 0x19, + 0xb2, 0x01, 0x04, 0x05, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x02, 0x2f, 0xb1, 0x00, 0x10, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, 0x35, 0x21, 0x03, 0x2e, 0xfd, 0x60, 0x02, 0xa0, 0x05, 0x16, 0x8f, + 0x00, 0x02, 0x00, 0x82, 0x03, 0xc0, 0x02, 0x7c, 0x05, 0xc4, 0x00, 0x0b, 0x00, 0x16, 0x00, 0x31, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1e, 0x3e, 0x59, 0xb0, 0x0c, 0xd0, 0xb0, 0x0c, 0x2f, 0xb1, 0x09, + 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x12, 0x02, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x13, 0x34, 0x36, 0x33, 0x32, 0x16, 0x15, 0x14, 0x06, 0x23, 0x22, + 0x26, 0x17, 0x32, 0x36, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x14, 0x16, 0x82, 0x95, 0x6a, 0x68, 0x93, 0x93, 0x68, + 0x69, 0x96, 0xff, 0x36, 0x4a, 0x4a, 0x36, 0x37, 0x4b, 0x4b, 0x04, 0xc0, 0x68, 0x9c, 0x9b, 0x69, 0x6a, 0x96, 0x96, + 0x16, 0x47, 0x39, 0x3a, 0x4b, 0x4f, 0x6c, 0x4a, 0x00, 0x02, 0x00, 0x61, 0x00, 0x00, 0x03, 0xf5, 0x04, 0xf3, 0x00, + 0x0b, 0x00, 0x0f, 0x00, 0x48, 0x00, 0xb0, 0x09, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, + 0x12, 0x3e, 0x59, 0xb0, 0x09, 0x10, 0xb0, 0x00, 0xd0, 0xb0, 0x09, 0x10, 0xb1, 0x06, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0xd0, 0xb0, 0x0d, 0x10, 0xb1, 0x0e, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x05, 0x0e, 0x06, 0x11, 0x12, 0x39, 0xb4, 0x0b, 0x05, 0x1b, 0x05, 0x02, 0x5d, 0x30, + 0x31, 0x01, 0x21, 0x15, 0x21, 0x11, 0x23, 0x11, 0x21, 0x35, 0x21, 0x11, 0x33, 0x01, 0x21, 0x35, 0x21, 0x02, 0x89, + 0x01, 0x6c, 0xfe, 0x94, 0xa7, 0xfe, 0x7f, 0x01, 0x81, 0xa7, 0x01, 0x41, 0xfc, 0xbd, 0x03, 0x43, 0x03, 0x56, 0x97, + 0xfe, 0x62, 0x01, 0x9e, 0x97, 0x01, 0x9d, 0xfb, 0x0d, 0x98, 0x00, 0x00, 0x01, 0x00, 0x42, 0x02, 0x9b, 0x02, 0xab, + 0x05, 0xbb, 0x00, 0x16, 0x00, 0x56, 0xb2, 0x08, 0x17, 0x18, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x0e, 0x2f, 0x1b, 0xb1, 0x0e, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x16, + 0x3e, 0x59, 0xb1, 0x16, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x02, 0xd0, 0xb2, 0x03, + 0x0e, 0x16, 0x11, 0x12, 0x39, 0xb0, 0x0e, 0x10, 0xb1, 0x08, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb0, 0x0e, 0x10, 0xb0, 0x0b, 0xd0, 0xb2, 0x14, 0x16, 0x0e, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x21, 0x35, + 0x01, 0x36, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x23, 0x34, 0x36, 0x20, 0x16, 0x15, 0x14, 0x0f, 0x02, 0x21, + 0x02, 0xab, 0xfd, 0xa9, 0x01, 0x2c, 0x6d, 0x40, 0x3c, 0x4b, 0x47, 0x9d, 0xa7, 0x01, 0x08, 0x9a, 0x6b, 0x54, 0xb0, + 0x01, 0x8f, 0x02, 0x9b, 0x6c, 0x01, 0x1a, 0x66, 0x45, 0x31, 0x3d, 0x4c, 0x39, 0x72, 0x94, 0x7f, 0x6e, 0x68, 0x6b, + 0x4f, 0x91, 0x00, 0x01, 0x00, 0x3e, 0x02, 0x90, 0x02, 0x9a, 0x05, 0xbb, 0x00, 0x26, 0x00, 0x8c, 0xb2, 0x20, 0x27, + 0x28, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0e, 0x2f, 0x1b, 0xb1, 0x0e, 0x1e, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x19, 0x2f, 0x1b, 0xb1, 0x19, 0x16, 0x3e, 0x59, 0xb2, 0x00, 0x19, 0x0e, 0x11, 0x12, 0x39, + 0xb0, 0x00, 0x2f, 0xb6, 0x6f, 0x00, 0x7f, 0x00, 0x8f, 0x00, 0x03, 0x5d, 0xb2, 0x3f, 0x00, 0x01, 0x71, 0xb6, 0x0f, + 0x00, 0x1f, 0x00, 0x2f, 0x00, 0x03, 0x5d, 0xb2, 0x5f, 0x00, 0x01, 0x72, 0xb0, 0x0e, 0x10, 0xb1, 0x07, 0x02, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x0a, 0x0e, 0x19, 0x11, 0x12, 0x39, 0xb0, 0x00, 0x10, 0xb1, + 0x26, 0x04, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x14, 0x26, 0x00, 0x11, 0x12, 0x39, 0xb2, + 0x1d, 0x19, 0x0e, 0x11, 0x12, 0x39, 0xb0, 0x19, 0x10, 0xb1, 0x20, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0x30, 0x31, 0x01, 0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x23, 0x34, 0x36, 0x33, + 0x32, 0x16, 0x15, 0x14, 0x06, 0x07, 0x16, 0x15, 0x14, 0x06, 0x23, 0x22, 0x26, 0x35, 0x33, 0x14, 0x16, 0x33, 0x32, + 0x36, 0x35, 0x34, 0x27, 0x23, 0x01, 0x09, 0x54, 0x4a, 0x48, 0x3f, 0x46, 0x39, 0x4b, 0x9d, 0xa3, 0x7c, 0x89, 0x9c, + 0x46, 0x42, 0x95, 0xaa, 0x88, 0x84, 0xa6, 0x9e, 0x4f, 0x43, 0x46, 0x49, 0x9c, 0x58, 0x04, 0x66, 0x3d, 0x30, 0x2d, + 0x3a, 0x33, 0x29, 0x62, 0x7b, 0x79, 0x68, 0x37, 0x5b, 0x19, 0x29, 0x8f, 0x6a, 0x7d, 0x7e, 0x6b, 0x2d, 0x3c, 0x3c, + 0x33, 0x71, 0x02, 0x00, 0x01, 0x00, 0x7b, 0x04, 0xda, 0x02, 0x1c, 0x06, 0x00, 0x00, 0x03, 0x00, 0x23, 0x00, 0xb0, + 0x02, 0x2f, 0xb2, 0x0f, 0x02, 0x01, 0x5d, 0xb0, 0x00, 0xd0, 0xb0, 0x00, 0x2f, 0xb4, 0x0f, 0x00, 0x1f, 0x00, 0x02, + 0x5d, 0xb0, 0x02, 0x10, 0xb0, 0x03, 0xd0, 0x19, 0xb0, 0x03, 0x2f, 0x18, 0x30, 0x31, 0x01, 0x33, 0x01, 0x23, 0x01, + 0x3c, 0xe0, 0xfe, 0xf4, 0x95, 0x06, 0x00, 0xfe, 0xda, 0x00, 0x00, 0x01, 0x00, 0x9a, 0xfe, 0x60, 0x03, 0xee, 0x04, + 0x3a, 0x00, 0x12, 0x00, 0x51, 0xb2, 0x0d, 0x13, 0x14, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, + 0x2f, 0x1b, 0xb1, 0x00, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1a, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x14, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x12, 0x3e, 0x59, 0xb1, 0x04, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb2, 0x0b, 0x07, 0x0d, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x11, 0x16, 0x16, 0x33, 0x32, 0x37, 0x11, 0x33, + 0x11, 0x23, 0x27, 0x06, 0x23, 0x22, 0x27, 0x11, 0x23, 0x11, 0x01, 0x53, 0x01, 0x67, 0x74, 0xc7, 0x3e, 0xba, 0xa7, + 0x09, 0x5d, 0xaa, 0x93, 0x51, 0xb9, 0x04, 0x3a, 0xfd, 0x87, 0xa3, 0x9c, 0x98, 0x03, 0x20, 0xfb, 0xc6, 0x73, 0x87, + 0x49, 0xfe, 0x2b, 0x05, 0xda, 0x00, 0x00, 0x01, 0x00, 0x43, 0x00, 0x00, 0x03, 0x40, 0x05, 0xb0, 0x00, 0x0a, 0x00, + 0x2b, 0xb2, 0x02, 0x0b, 0x0c, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, + 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb2, 0x01, 0x00, + 0x08, 0x11, 0x12, 0x39, 0x30, 0x31, 0x21, 0x11, 0x23, 0x22, 0x24, 0x35, 0x34, 0x24, 0x33, 0x21, 0x11, 0x02, 0x86, + 0x54, 0xe6, 0xfe, 0xf7, 0x01, 0x0a, 0xe6, 0x01, 0x0d, 0x02, 0x08, 0xfe, 0xd6, 0xd5, 0xff, 0xfa, 0x50, 0x00, 0x00, + 0x01, 0x00, 0x93, 0x02, 0x6b, 0x01, 0x79, 0x03, 0x49, 0x00, 0x09, 0x00, 0x17, 0xb2, 0x03, 0x0a, 0x0b, 0x11, 0x12, + 0x39, 0x00, 0xb0, 0x02, 0x2f, 0xb0, 0x08, 0xb0, 0x0a, 0x2b, 0x58, 0xd8, 0x1b, 0xdc, 0x59, 0x30, 0x31, 0x13, 0x34, + 0x36, 0x32, 0x16, 0x15, 0x14, 0x06, 0x22, 0x26, 0x93, 0x39, 0x72, 0x3b, 0x3b, 0x72, 0x39, 0x02, 0xd9, 0x30, 0x40, + 0x40, 0x30, 0x2f, 0x3f, 0x3f, 0x00, 0x00, 0x01, 0x00, 0x74, 0xfe, 0x4d, 0x01, 0xaa, 0x00, 0x00, 0x00, 0x0e, 0x00, + 0x42, 0xb2, 0x05, 0x0f, 0x10, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, + 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x14, 0x3e, 0x59, 0xb4, 0x13, 0x06, + 0x23, 0x06, 0x02, 0x5d, 0xb2, 0x01, 0x06, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x07, 0xb0, 0x0a, 0x2b, 0x58, 0xd8, 0x1b, + 0xdc, 0x59, 0xb0, 0x01, 0x10, 0xb0, 0x0d, 0xd0, 0x30, 0x31, 0x21, 0x07, 0x16, 0x15, 0x14, 0x06, 0x23, 0x27, 0x32, + 0x36, 0x35, 0x34, 0x26, 0x27, 0x37, 0x01, 0x1d, 0x0c, 0x99, 0xa0, 0x8f, 0x07, 0x4f, 0x57, 0x40, 0x62, 0x20, 0x34, + 0x1b, 0x92, 0x61, 0x71, 0x6b, 0x34, 0x2f, 0x2c, 0x2a, 0x09, 0x86, 0x00, 0x00, 0x01, 0x00, 0x7a, 0x02, 0x9b, 0x01, + 0xef, 0x05, 0xb0, 0x00, 0x06, 0x00, 0x41, 0xb2, 0x01, 0x07, 0x08, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, + 0x16, 0x3e, 0x59, 0xb2, 0x04, 0x00, 0x05, 0x11, 0x12, 0x39, 0xb0, 0x04, 0x2f, 0xb1, 0x03, 0x02, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x02, 0x03, 0x05, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x23, 0x11, 0x07, + 0x35, 0x25, 0x33, 0x01, 0xef, 0x9d, 0xd8, 0x01, 0x63, 0x12, 0x02, 0x9b, 0x02, 0x59, 0x39, 0x80, 0x75, 0x00, 0x02, + 0x00, 0x7a, 0x02, 0xb2, 0x03, 0x27, 0x05, 0xc4, 0x00, 0x0c, 0x00, 0x1a, 0x00, 0x42, 0xb2, 0x03, 0x1b, 0x1c, 0x11, + 0x12, 0x39, 0xb0, 0x03, 0x10, 0xb0, 0x10, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, + 0x1e, 0x3e, 0x59, 0xb2, 0x0a, 0x1b, 0x03, 0x11, 0x12, 0x39, 0xb0, 0x0a, 0x2f, 0xb1, 0x10, 0x03, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x17, 0x03, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0x30, 0x31, 0x13, 0x34, 0x36, 0x33, 0x32, 0x16, 0x15, 0x15, 0x14, 0x06, 0x20, 0x26, 0x35, 0x17, 0x14, + 0x16, 0x33, 0x32, 0x36, 0x35, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x07, 0x7a, 0xbc, 0x9a, 0x9b, 0xbc, 0xbb, 0xfe, + 0xcc, 0xbe, 0xa3, 0x61, 0x54, 0x53, 0x5f, 0x61, 0x53, 0x51, 0x60, 0x02, 0x04, 0x63, 0x9e, 0xc3, 0xc1, 0xa6, 0x4a, + 0x9f, 0xc2, 0xc2, 0xa5, 0x06, 0x64, 0x72, 0x73, 0x65, 0x4e, 0x63, 0x72, 0x6e, 0x61, 0x00, 0xff, 0xff, 0x00, 0x66, + 0x00, 0x98, 0x03, 0x78, 0x03, 0xb5, 0x00, 0x26, 0x01, 0x93, 0x0d, 0x00, 0x00, 0x07, 0x01, 0x93, 0x01, 0x6a, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x55, 0x00, 0x00, 0x05, 0x91, 0x05, 0xad, 0x00, 0x27, 0x01, 0xc6, 0xff, 0xdb, 0x02, 0x98, + 0x00, 0x27, 0x01, 0x94, 0x01, 0x18, 0x00, 0x08, 0x01, 0x07, 0x02, 0x20, 0x02, 0xd6, 0x00, 0x00, 0x00, 0x10, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x1e, 0x3e, 0x59, 0x30, 0x31, 0xff, 0xff, 0x00, 0x50, + 0x00, 0x00, 0x05, 0xc9, 0x05, 0xad, 0x00, 0x27, 0x01, 0x94, 0x00, 0xec, 0x00, 0x08, 0x00, 0x27, 0x01, 0xc6, 0xff, + 0xd6, 0x02, 0x98, 0x01, 0x07, 0x01, 0xc5, 0x03, 0x1e, 0x00, 0x00, 0x00, 0x10, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x1e, 0x3e, 0x59, 0x30, 0x31, 0xff, 0xff, 0x00, 0x6f, 0x00, 0x00, 0x05, 0xed, 0x05, + 0xbb, 0x00, 0x27, 0x01, 0x94, 0x01, 0x97, 0x00, 0x08, 0x00, 0x27, 0x02, 0x20, 0x03, 0x32, 0x00, 0x00, 0x01, 0x07, + 0x02, 0x1f, 0x00, 0x31, 0x02, 0x9b, 0x00, 0x10, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x21, 0x2f, 0x1b, 0xb1, 0x21, + 0x1e, 0x3e, 0x59, 0x30, 0x31, 0x00, 0x02, 0x00, 0x44, 0xfe, 0x7f, 0x03, 0x78, 0x04, 0x4d, 0x00, 0x18, 0x00, 0x22, + 0x00, 0x59, 0xb2, 0x09, 0x23, 0x24, 0x11, 0x12, 0x39, 0xb0, 0x09, 0x10, 0xb0, 0x1c, 0xd0, 0x00, 0xb0, 0x10, 0x2f, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x21, 0x2f, 0x1b, 0xb1, 0x21, 0x1a, 0x3e, 0x59, 0xb2, 0x00, 0x10, 0x21, 0x11, 0x12, + 0x39, 0xb2, 0x03, 0x10, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x10, 0x10, 0xb1, 0x09, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x10, 0x10, 0xb0, 0x0c, 0xd0, 0xb2, 0x15, 0x00, 0x10, 0x11, 0x12, 0x39, 0xb0, 0x21, + 0x10, 0xb1, 0x1b, 0x05, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x0e, 0x03, 0x07, + 0x07, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x33, 0x06, 0x06, 0x23, 0x22, 0x26, 0x35, 0x34, 0x37, 0x37, 0x36, 0x35, + 0x13, 0x14, 0x06, 0x22, 0x26, 0x35, 0x34, 0x36, 0x32, 0x16, 0x02, 0x4c, 0x01, 0x29, 0x60, 0xb8, 0x0b, 0x02, 0x74, + 0x6d, 0x64, 0x7d, 0xb9, 0x02, 0xe1, 0xb7, 0xc4, 0xd6, 0xa0, 0x6d, 0x42, 0xc1, 0x37, 0x6c, 0x38, 0x38, 0x6c, 0x37, + 0x02, 0xa8, 0x6a, 0x7f, 0x76, 0xc1, 0x63, 0x25, 0x6d, 0x73, 0x71, 0x5b, 0xa1, 0xcc, 0xc9, 0xb3, 0xad, 0xaf, 0x71, + 0x4e, 0x92, 0x01, 0x3d, 0x2d, 0x3e, 0x3e, 0x2d, 0x2c, 0x3c, 0x3c, 0x00, 0x02, 0xff, 0xf2, 0x00, 0x00, 0x07, 0x57, + 0x05, 0xb0, 0x00, 0x0f, 0x00, 0x12, 0x00, 0x7b, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, + 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb2, 0x11, 0x06, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x11, + 0x2f, 0xb1, 0x02, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x06, 0x10, 0xb1, 0x08, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x0b, 0x00, 0x06, 0x11, 0x12, 0x39, 0xb0, 0x0b, 0x2f, + 0xb1, 0x0c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x00, 0x10, 0xb1, 0x0e, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x12, 0x06, 0x00, 0x11, 0x12, 0x39, 0x30, 0x31, 0x21, 0x21, + 0x03, 0x21, 0x03, 0x23, 0x01, 0x21, 0x15, 0x21, 0x13, 0x21, 0x15, 0x21, 0x13, 0x21, 0x01, 0x21, 0x03, 0x07, 0x57, + 0xfc, 0x8d, 0x0f, 0xfd, 0xcc, 0xcd, 0xe2, 0x03, 0x70, 0x03, 0xb7, 0xfd, 0x4d, 0x14, 0x02, 0x4e, 0xfd, 0xb8, 0x16, + 0x02, 0xc1, 0xfa, 0xaf, 0x01, 0xc8, 0x1f, 0x01, 0x61, 0xfe, 0x9f, 0x05, 0xb0, 0x98, 0xfe, 0x29, 0x97, 0xfd, 0xed, + 0x01, 0x78, 0x02, 0xdd, 0x00, 0x01, 0x00, 0x59, 0x00, 0xce, 0x03, 0xdd, 0x04, 0x63, 0x00, 0x0b, 0x00, 0x38, 0x00, + 0xb0, 0x03, 0x2f, 0xb2, 0x09, 0x0c, 0x03, 0x11, 0x12, 0x39, 0xb0, 0x09, 0x2f, 0xb2, 0x0a, 0x09, 0x03, 0x11, 0x12, + 0x39, 0xb2, 0x04, 0x03, 0x09, 0x11, 0x12, 0x39, 0xb2, 0x01, 0x0a, 0x04, 0x11, 0x12, 0x39, 0xb0, 0x03, 0x10, 0xb0, + 0x05, 0xd0, 0xb2, 0x07, 0x04, 0x0a, 0x11, 0x12, 0x39, 0xb0, 0x09, 0x10, 0xb0, 0x0b, 0xd0, 0x30, 0x31, 0x13, 0x01, + 0x01, 0x37, 0x01, 0x01, 0x17, 0x01, 0x01, 0x07, 0x01, 0x01, 0x59, 0x01, 0x4a, 0xfe, 0xb8, 0x77, 0x01, 0x49, 0x01, + 0x49, 0x77, 0xfe, 0xb8, 0x01, 0x4a, 0x77, 0xfe, 0xb5, 0xfe, 0xb5, 0x01, 0x49, 0x01, 0x50, 0x01, 0x4f, 0x7b, 0xfe, + 0xb1, 0x01, 0x4f, 0x7b, 0xfe, 0xb1, 0xfe, 0xb0, 0x7b, 0x01, 0x51, 0xfe, 0xaf, 0x00, 0x00, 0x03, 0x00, 0x76, 0xff, + 0xa3, 0x05, 0x1d, 0x05, 0xec, 0x00, 0x17, 0x00, 0x20, 0x00, 0x29, 0x00, 0x68, 0xb2, 0x04, 0x2a, 0x2b, 0x11, 0x12, + 0x39, 0xb0, 0x04, 0x10, 0xb0, 0x1d, 0xd0, 0xb0, 0x04, 0x10, 0xb0, 0x26, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, + 0x3e, 0x59, 0xb2, 0x1a, 0x10, 0x04, 0x11, 0x12, 0x39, 0xb2, 0x23, 0x10, 0x04, 0x11, 0x12, 0x39, 0xb0, 0x23, 0x10, + 0xb0, 0x1b, 0xd0, 0xb0, 0x10, 0x10, 0xb1, 0x1d, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x1a, 0x10, 0xb0, 0x24, 0xd0, 0xb0, 0x04, 0x10, 0xb1, 0x26, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0x30, 0x31, 0x01, 0x14, 0x02, 0x04, 0x23, 0x22, 0x27, 0x07, 0x23, 0x37, 0x26, 0x11, 0x35, 0x34, 0x12, 0x24, + 0x33, 0x32, 0x17, 0x37, 0x33, 0x07, 0x16, 0x13, 0x05, 0x14, 0x17, 0x01, 0x26, 0x23, 0x22, 0x02, 0x07, 0x05, 0x34, + 0x27, 0x01, 0x16, 0x33, 0x32, 0x12, 0x37, 0x05, 0x09, 0x90, 0xfe, 0xf8, 0xb0, 0xab, 0x83, 0x61, 0x8e, 0x90, 0xbe, + 0x92, 0x01, 0x0b, 0xac, 0xd6, 0x94, 0x67, 0x8d, 0x9f, 0x89, 0x02, 0xfc, 0x2c, 0x62, 0x02, 0x34, 0x66, 0xa6, 0xb6, + 0xd1, 0x03, 0x03, 0x15, 0x38, 0xfd, 0xdb, 0x5b, 0x79, 0xba, 0xcc, 0x03, 0x02, 0xa9, 0xd6, 0xfe, 0xc1, 0xa8, 0x52, + 0x9b, 0xe7, 0xc0, 0x01, 0x68, 0x53, 0xd2, 0x01, 0x42, 0xab, 0x7d, 0xa5, 0xff, 0xbb, 0xfe, 0xda, 0x63, 0xf4, 0x8d, + 0x03, 0x88, 0x6f, 0xfe, 0xeb, 0xf6, 0x0d, 0xb6, 0x83, 0xfc, 0x8f, 0x40, 0x01, 0x0f, 0xfd, 0x00, 0x02, 0x00, 0xa6, + 0x00, 0x00, 0x04, 0x5d, 0x05, 0xb0, 0x00, 0x0d, 0x00, 0x16, 0x00, 0x59, 0xb2, 0x09, 0x17, 0x18, 0x11, 0x12, 0x39, + 0xb0, 0x09, 0x10, 0xb0, 0x10, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1e, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x12, 0x3e, 0x59, 0xb2, 0x01, 0x00, 0x0b, 0x11, + 0x12, 0x39, 0xb0, 0x01, 0x2f, 0xb2, 0x10, 0x00, 0x0b, 0x11, 0x12, 0x39, 0xb0, 0x10, 0x2f, 0xb1, 0x09, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x01, 0x10, 0xb1, 0x0e, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x11, 0x21, 0x32, 0x16, 0x16, 0x15, 0x14, 0x04, 0x23, 0x21, 0x11, 0x23, + 0x11, 0x13, 0x11, 0x21, 0x32, 0x36, 0x35, 0x34, 0x26, 0x27, 0x01, 0x60, 0x01, 0x17, 0x93, 0xdc, 0x77, 0xfe, 0xf8, + 0xe3, 0xfe, 0xee, 0xba, 0xba, 0x01, 0x15, 0x8e, 0xa0, 0xa0, 0x88, 0x05, 0xb0, 0xfe, 0xdb, 0x69, 0xc2, 0x7e, 0xc2, + 0xe7, 0xfe, 0xc7, 0x05, 0xb0, 0xfe, 0x43, 0xfd, 0xde, 0x97, 0x78, 0x7b, 0x97, 0x01, 0x00, 0x01, 0x00, 0x8b, 0xff, + 0xec, 0x04, 0x6a, 0x06, 0x12, 0x00, 0x2a, 0x00, 0x6b, 0xb2, 0x21, 0x2b, 0x2c, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x20, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x13, 0x2f, 0x1b, + 0xb1, 0x13, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb2, + 0x0a, 0x13, 0x05, 0x11, 0x12, 0x39, 0xb2, 0x0e, 0x05, 0x13, 0x11, 0x12, 0x39, 0xb0, 0x13, 0x10, 0xb1, 0x1a, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x20, 0x13, 0x05, 0x11, 0x12, 0x39, 0xb2, 0x23, 0x05, + 0x13, 0x11, 0x12, 0x39, 0xb0, 0x05, 0x10, 0xb1, 0x28, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0x30, 0x31, 0x21, 0x23, 0x11, 0x34, 0x36, 0x33, 0x32, 0x16, 0x15, 0x14, 0x06, 0x15, 0x14, 0x1e, 0x02, 0x15, 0x14, + 0x06, 0x23, 0x22, 0x26, 0x27, 0x37, 0x16, 0x16, 0x33, 0x32, 0x36, 0x35, 0x34, 0x2e, 0x02, 0x35, 0x34, 0x36, 0x35, + 0x34, 0x26, 0x23, 0x22, 0x11, 0x01, 0x44, 0xb9, 0xcf, 0xba, 0xb4, 0xc5, 0x80, 0x4b, 0xbc, 0x56, 0xcb, 0xb6, 0x51, + 0xb5, 0x26, 0x2b, 0x31, 0x87, 0x35, 0x6b, 0x71, 0x4a, 0xbd, 0x57, 0x8b, 0x68, 0x58, 0xda, 0x04, 0x57, 0xd0, 0xeb, + 0xb3, 0x9f, 0x7d, 0xcb, 0x45, 0x33, 0x5f, 0x90, 0x88, 0x4c, 0x9f, 0xb2, 0x2c, 0x1c, 0x9b, 0x20, 0x2c, 0x5e, 0x52, + 0x34, 0x60, 0x93, 0x8a, 0x51, 0x59, 0xcf, 0x54, 0x5e, 0x6b, 0xfe, 0xdb, 0x00, 0x03, 0x00, 0x4e, 0xff, 0xec, 0x06, + 0x7c, 0x04, 0x4e, 0x00, 0x2a, 0x00, 0x35, 0x00, 0x3d, 0x00, 0xca, 0xb2, 0x02, 0x3e, 0x3f, 0x11, 0x12, 0x39, 0xb0, + 0x02, 0x10, 0xb0, 0x2e, 0xd0, 0xb0, 0x02, 0x10, 0xb0, 0x39, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x17, 0x2f, + 0x1b, 0xb1, 0x17, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x1d, 0x2f, 0x1b, 0xb1, 0x1d, 0x1a, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, + 0x2f, 0x1b, 0xb1, 0x05, 0x12, 0x3e, 0x59, 0xb2, 0x02, 0x1d, 0x00, 0x11, 0x12, 0x39, 0xb2, 0x0c, 0x05, 0x17, 0x11, + 0x12, 0x39, 0xb0, 0x0c, 0x2f, 0xb4, 0xbf, 0x0c, 0xcf, 0x0c, 0x02, 0x5d, 0xb0, 0x17, 0x10, 0xb1, 0x10, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x13, 0x0c, 0x17, 0x11, 0x12, 0x39, 0xb2, 0x1a, 0x1d, 0x00, + 0x11, 0x12, 0x39, 0xb2, 0x3a, 0x1d, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x3a, 0x2f, 0xb4, 0xbf, 0x3a, 0xcf, 0x3a, 0x02, + 0x5d, 0xb1, 0x21, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x00, 0x10, 0xb1, 0x25, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x28, 0x1d, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x2b, 0xd0, + 0xb0, 0x0c, 0x10, 0xb1, 0x2f, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x10, 0x10, 0xb0, + 0x36, 0xd0, 0x30, 0x31, 0x05, 0x20, 0x27, 0x06, 0x06, 0x23, 0x22, 0x26, 0x35, 0x34, 0x36, 0x33, 0x33, 0x35, 0x34, + 0x26, 0x23, 0x22, 0x06, 0x15, 0x27, 0x34, 0x36, 0x33, 0x32, 0x16, 0x17, 0x36, 0x36, 0x33, 0x32, 0x12, 0x15, 0x15, + 0x21, 0x16, 0x16, 0x33, 0x32, 0x37, 0x37, 0x17, 0x06, 0x25, 0x32, 0x36, 0x37, 0x35, 0x23, 0x06, 0x06, 0x15, 0x14, + 0x16, 0x01, 0x22, 0x06, 0x07, 0x21, 0x35, 0x34, 0x26, 0x04, 0xee, 0xfe, 0xfb, 0x88, 0x41, 0xe2, 0x8d, 0xa7, 0xbc, + 0xe3, 0xdd, 0xdf, 0x6e, 0x68, 0x69, 0x8c, 0xb8, 0xf2, 0xbb, 0x73, 0xb0, 0x32, 0x3f, 0xae, 0x69, 0xd2, 0xe8, 0xfd, + 0x28, 0x07, 0xae, 0x95, 0x94, 0x79, 0x2f, 0x40, 0x9e, 0xfc, 0x09, 0x48, 0x9e, 0x32, 0xe4, 0x75, 0x8c, 0x6a, 0x03, + 0x50, 0x73, 0x95, 0x11, 0x02, 0x1a, 0x86, 0x14, 0xb4, 0x56, 0x5e, 0xad, 0x97, 0x9d, 0xae, 0x55, 0x6b, 0x7b, 0x6e, + 0x51, 0x13, 0x8f, 0xb5, 0x53, 0x53, 0x4f, 0x57, 0xfe, 0xff, 0xe9, 0x73, 0xb0, 0xbf, 0x4c, 0x1f, 0x88, 0x79, 0x96, + 0x4a, 0x36, 0xed, 0x02, 0x6e, 0x53, 0x4d, 0x5d, 0x03, 0x34, 0xab, 0x8b, 0x1f, 0x84, 0x93, 0x00, 0x00, 0x02, 0x00, + 0x7e, 0xff, 0xec, 0x04, 0x2d, 0x06, 0x2c, 0x00, 0x1d, 0x00, 0x2b, 0x00, 0x56, 0xb2, 0x07, 0x2c, 0x2d, 0x11, 0x12, + 0x39, 0xb0, 0x07, 0x10, 0xb0, 0x28, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x19, 0x2f, 0x1b, 0xb1, 0x19, 0x20, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x12, 0x3e, 0x59, 0xb2, 0x0f, 0x19, 0x07, + 0x11, 0x12, 0x39, 0xb0, 0x0f, 0x2f, 0xb2, 0x11, 0x19, 0x07, 0x11, 0x12, 0x39, 0xb1, 0x22, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x07, 0x10, 0xb1, 0x28, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0x30, 0x31, 0x01, 0x12, 0x11, 0x15, 0x14, 0x06, 0x06, 0x23, 0x22, 0x26, 0x26, 0x35, 0x34, 0x36, 0x36, + 0x33, 0x32, 0x17, 0x26, 0x27, 0x07, 0x27, 0x37, 0x26, 0x27, 0x37, 0x16, 0x17, 0x37, 0x17, 0x03, 0x27, 0x26, 0x26, + 0x23, 0x22, 0x06, 0x15, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x03, 0x34, 0xf9, 0x75, 0xd8, 0x86, 0x87, 0xdc, 0x79, + 0x70, 0xcf, 0x81, 0xa3, 0x79, 0x30, 0x8d, 0xda, 0x49, 0xc0, 0x84, 0xb7, 0x39, 0xef, 0xaf, 0xbd, 0x49, 0x68, 0x02, + 0x21, 0x8b, 0x5c, 0x91, 0xa2, 0xa7, 0x80, 0x7d, 0x99, 0x05, 0x15, 0xfe, 0xf8, 0xfe, 0x67, 0x5d, 0x9e, 0xfd, 0x90, + 0x81, 0xe0, 0x86, 0x93, 0xe9, 0x82, 0x72, 0xc3, 0x8d, 0x94, 0x63, 0x83, 0x5b, 0x31, 0x9f, 0x36, 0x8b, 0x81, 0x64, + 0xfc, 0xf3, 0x38, 0x3d, 0x49, 0xbf, 0xa7, 0x8c, 0xc4, 0xe2, 0xb8, 0x00, 0x00, 0x03, 0x00, 0x47, 0x00, 0xac, 0x04, + 0x2d, 0x04, 0xba, 0x00, 0x03, 0x00, 0x0d, 0x00, 0x17, 0x00, 0x53, 0xb2, 0x07, 0x18, 0x19, 0x11, 0x12, 0x39, 0xb0, + 0x07, 0x10, 0xb0, 0x00, 0xd0, 0xb0, 0x07, 0x10, 0xb0, 0x11, 0xd0, 0x00, 0xb0, 0x02, 0x2f, 0xb1, 0x01, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x02, 0x10, 0xb0, 0x0c, 0xb0, 0x0a, 0x2b, 0x58, 0xd8, 0x1b, + 0xdc, 0x59, 0xb0, 0x06, 0xb0, 0x0a, 0x2b, 0x58, 0xd8, 0x1b, 0xdc, 0x59, 0xb0, 0x01, 0x10, 0xb0, 0x10, 0xb0, 0x0a, + 0x2b, 0x58, 0xd8, 0x1b, 0xdc, 0x59, 0xb0, 0x16, 0xb0, 0x0a, 0x2b, 0x58, 0xd8, 0x1b, 0xdc, 0x59, 0x30, 0x31, 0x01, + 0x21, 0x35, 0x21, 0x01, 0x34, 0x36, 0x32, 0x16, 0x15, 0x14, 0x06, 0x22, 0x26, 0x11, 0x34, 0x36, 0x32, 0x16, 0x15, + 0x14, 0x06, 0x22, 0x26, 0x04, 0x2d, 0xfc, 0x1a, 0x03, 0xe6, 0xfd, 0xa0, 0x39, 0x72, 0x3b, 0x3b, 0x72, 0x39, 0x39, + 0x72, 0x3b, 0x3b, 0x72, 0x39, 0x02, 0x58, 0xb8, 0x01, 0x3a, 0x30, 0x40, 0x40, 0x30, 0x2f, 0x3e, 0x3e, 0xfc, 0xfe, + 0x30, 0x40, 0x40, 0x30, 0x2e, 0x3f, 0x3f, 0x00, 0x03, 0x00, 0x5b, 0xff, 0x7a, 0x04, 0x34, 0x04, 0xb8, 0x00, 0x15, + 0x00, 0x1d, 0x00, 0x26, 0x00, 0x65, 0xb2, 0x04, 0x27, 0x28, 0x11, 0x12, 0x39, 0xb0, 0x04, 0x10, 0xb0, 0x1b, 0xd0, + 0xb0, 0x04, 0x10, 0xb0, 0x23, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0f, 0x2f, 0x1b, 0xb1, 0x0f, 0x12, 0x3e, 0x59, 0xb1, 0x23, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x21, 0x23, 0x04, 0x11, 0x12, 0x39, 0xb0, 0x21, 0x10, 0xb0, 0x18, + 0xd0, 0xb0, 0x04, 0x10, 0xb1, 0x1b, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x19, 0x1b, + 0x0f, 0x11, 0x12, 0x39, 0xb0, 0x19, 0x10, 0xb0, 0x20, 0xd0, 0x30, 0x31, 0x13, 0x34, 0x36, 0x36, 0x33, 0x32, 0x17, + 0x37, 0x33, 0x07, 0x16, 0x11, 0x14, 0x06, 0x06, 0x23, 0x22, 0x27, 0x07, 0x23, 0x37, 0x26, 0x13, 0x14, 0x17, 0x01, + 0x26, 0x23, 0x22, 0x06, 0x05, 0x34, 0x27, 0x01, 0x16, 0x33, 0x32, 0x36, 0x35, 0x5b, 0x7b, 0xe1, 0x8f, 0x6e, 0x5e, + 0x49, 0x7c, 0x66, 0xc3, 0x7c, 0xe0, 0x90, 0x68, 0x56, 0x4a, 0x7c, 0x64, 0xcd, 0xb9, 0x61, 0x01, 0x57, 0x3e, 0x48, + 0x8a, 0xa8, 0x02, 0x66, 0x57, 0xfe, 0xac, 0x37, 0x42, 0x8b, 0xa7, 0x02, 0x27, 0x9f, 0xfd, 0x8b, 0x2a, 0x94, 0xcd, + 0x9a, 0xfe, 0xc0, 0x9e, 0xfe, 0x89, 0x23, 0x95, 0xcb, 0x95, 0x01, 0x37, 0xc2, 0x6f, 0x02, 0xb6, 0x20, 0xda, 0xb5, + 0xb6, 0x6f, 0xfd, 0x50, 0x19, 0xdb, 0xb9, 0x00, 0x02, 0x00, 0x95, 0xfe, 0x60, 0x04, 0x27, 0x06, 0x00, 0x00, 0x0f, + 0x00, 0x1a, 0x00, 0x66, 0xb2, 0x18, 0x1b, 0x1c, 0x11, 0x12, 0x39, 0xb0, 0x18, 0x10, 0xb0, 0x0c, 0xd0, 0x00, 0xb0, + 0x08, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x14, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, + 0x12, 0x3e, 0x59, 0xb2, 0x05, 0x0c, 0x03, 0x11, 0x12, 0x39, 0xb2, 0x0a, 0x0c, 0x03, 0x11, 0x12, 0x39, 0xb0, 0x0c, + 0x10, 0xb1, 0x13, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x18, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x14, 0x02, 0x23, 0x22, 0x27, 0x11, 0x23, + 0x11, 0x33, 0x11, 0x36, 0x33, 0x32, 0x12, 0x11, 0x27, 0x34, 0x26, 0x23, 0x22, 0x07, 0x11, 0x16, 0x33, 0x32, 0x36, + 0x04, 0x27, 0xe2, 0xc1, 0xc5, 0x71, 0xb9, 0xb9, 0x71, 0xc2, 0xc3, 0xe3, 0xb9, 0x9c, 0x88, 0xa8, 0x54, 0x53, 0xab, + 0x85, 0x9d, 0x02, 0x11, 0xf7, 0xfe, 0xd2, 0x7d, 0xfd, 0xf7, 0x07, 0xa0, 0xfd, 0xca, 0x84, 0xfe, 0xda, 0xfe, 0xfa, + 0x04, 0xb7, 0xd4, 0x95, 0xfd, 0xfb, 0x94, 0xd3, 0x00, 0x00, 0x02, 0x00, 0x5f, 0xff, 0xec, 0x04, 0xac, 0x06, 0x00, + 0x00, 0x17, 0x00, 0x22, 0x00, 0x82, 0x00, 0xb0, 0x14, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, + 0x0d, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x12, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x12, 0x3e, 0x59, 0xb2, 0x0f, 0x14, 0x01, 0x5d, 0xb2, 0x2f, 0x14, + 0x01, 0x5d, 0xb2, 0x13, 0x03, 0x14, 0x11, 0x12, 0x39, 0xb0, 0x13, 0x2f, 0xb1, 0x10, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x01, 0xd0, 0xb2, 0x04, 0x06, 0x0d, 0x11, 0x12, 0x39, 0xb2, 0x0f, 0x0d, 0x06, + 0x11, 0x12, 0x39, 0xb0, 0x13, 0x10, 0xb0, 0x16, 0xd0, 0xb0, 0x06, 0x10, 0xb1, 0x1b, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0d, 0x10, 0xb1, 0x20, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0x30, 0x31, 0x01, 0x23, 0x11, 0x23, 0x27, 0x06, 0x23, 0x22, 0x02, 0x35, 0x35, 0x34, 0x12, 0x33, 0x32, 0x17, + 0x11, 0x21, 0x35, 0x21, 0x35, 0x33, 0x15, 0x33, 0x01, 0x14, 0x16, 0x33, 0x32, 0x37, 0x11, 0x26, 0x23, 0x22, 0x06, + 0x04, 0xac, 0xbc, 0xaa, 0x09, 0x6f, 0xc6, 0xbc, 0xed, 0xec, 0xbf, 0xbe, 0x6f, 0xfe, 0xf8, 0x01, 0x08, 0xb9, 0xbc, + 0xfc, 0x6c, 0x98, 0x86, 0xb0, 0x51, 0x53, 0xac, 0x88, 0x98, 0x04, 0xd1, 0xfb, 0x2f, 0x74, 0x88, 0x01, 0x34, 0xf8, + 0x0e, 0xf9, 0x01, 0x2f, 0x82, 0x01, 0x05, 0x97, 0x98, 0x98, 0xfc, 0xa9, 0xb8, 0xd0, 0x9e, 0x01, 0xf1, 0x99, 0xd2, + 0x00, 0x02, 0x00, 0x1d, 0x00, 0x00, 0x05, 0x88, 0x05, 0xb0, 0x00, 0x13, 0x00, 0x17, 0x00, 0x6d, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x0f, 0x2f, 0x1b, 0xb1, 0x0f, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, + 0xb1, 0x08, 0x12, 0x3e, 0x59, 0xb2, 0x14, 0x08, 0x0f, 0x11, 0x12, 0x39, 0xb0, 0x14, 0x2f, 0xb2, 0x10, 0x14, 0x0f, + 0x11, 0x12, 0x39, 0xb0, 0x10, 0x2f, 0xb0, 0x00, 0xd0, 0xb0, 0x10, 0x10, 0xb1, 0x17, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0xd0, 0xb0, 0x08, 0x10, 0xb0, 0x05, 0xd0, 0xb0, 0x14, 0x10, 0xb1, 0x07, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x17, 0x10, 0xb0, 0x0a, 0xd0, 0xb0, 0x10, 0x10, + 0xb0, 0x0d, 0xd0, 0xb0, 0x0f, 0x10, 0xb0, 0x12, 0xd0, 0x30, 0x31, 0x01, 0x33, 0x15, 0x23, 0x11, 0x23, 0x11, 0x21, + 0x11, 0x23, 0x11, 0x23, 0x35, 0x33, 0x11, 0x33, 0x11, 0x21, 0x11, 0x33, 0x01, 0x21, 0x35, 0x21, 0x05, 0x02, 0x86, + 0x86, 0xc1, 0xfd, 0x23, 0xc1, 0x86, 0x86, 0xc1, 0x02, 0xdd, 0xc1, 0xfc, 0x62, 0x02, 0xdd, 0xfd, 0x23, 0x04, 0x8e, + 0x8e, 0xfc, 0x00, 0x02, 0xa1, 0xfd, 0x5f, 0x04, 0x00, 0x8e, 0x01, 0x22, 0xfe, 0xde, 0x01, 0x22, 0xfd, 0x8e, 0xc2, + 0x00, 0x01, 0x00, 0x9b, 0x00, 0x00, 0x01, 0x55, 0x04, 0x3a, 0x00, 0x03, 0x00, 0x1d, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, + 0x12, 0x3e, 0x59, 0x30, 0x31, 0x21, 0x23, 0x11, 0x33, 0x01, 0x55, 0xba, 0xba, 0x04, 0x3a, 0x00, 0x00, 0x01, 0x00, + 0x9a, 0x00, 0x00, 0x04, 0x3f, 0x04, 0x3a, 0x00, 0x0c, 0x00, 0x69, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, + 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, + 0x2f, 0x1b, 0xb1, 0x0b, 0x12, 0x3e, 0x59, 0xb0, 0x02, 0x10, 0xb0, 0x06, 0xd0, 0xb0, 0x06, 0x2f, 0xb2, 0x9f, 0x06, + 0x01, 0x5d, 0xb4, 0xbf, 0x06, 0xcf, 0x06, 0x02, 0x5d, 0xb2, 0x2f, 0x06, 0x01, 0x5d, 0xb2, 0xff, 0x06, 0x01, 0x5d, + 0xb1, 0x01, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x0a, 0x01, 0x06, 0x11, 0x12, 0x39, + 0x30, 0x31, 0x01, 0x23, 0x11, 0x23, 0x11, 0x33, 0x11, 0x33, 0x01, 0x33, 0x01, 0x01, 0x23, 0x01, 0xbf, 0x6b, 0xba, + 0xba, 0x5b, 0x01, 0x8d, 0xdf, 0xfe, 0x3c, 0x01, 0xe8, 0xe9, 0x01, 0xcd, 0xfe, 0x33, 0x04, 0x3a, 0xfe, 0x36, 0x01, + 0xca, 0xfd, 0xf3, 0xfd, 0xd3, 0x00, 0x01, 0x00, 0x22, 0x00, 0x00, 0x04, 0x1b, 0x05, 0xb0, 0x00, 0x0d, 0x00, 0x5d, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x12, 0x3e, 0x59, 0xb2, 0x01, 0x0c, 0x06, 0x11, 0x12, 0x39, 0xb0, 0x01, 0x2f, 0xb0, + 0x00, 0xd0, 0xb0, 0x01, 0x10, 0xb1, 0x02, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, + 0xd0, 0xb0, 0x06, 0x10, 0xb1, 0x04, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, + 0xb0, 0x08, 0xd0, 0xb0, 0x09, 0xd0, 0xb0, 0x00, 0x10, 0xb0, 0x0b, 0xd0, 0xb0, 0x0a, 0xd0, 0x30, 0x31, 0x01, 0x25, + 0x15, 0x05, 0x11, 0x21, 0x15, 0x21, 0x11, 0x07, 0x35, 0x37, 0x11, 0x33, 0x01, 0x69, 0x01, 0x07, 0xfe, 0xf9, 0x02, + 0xb2, 0xfc, 0x8d, 0x86, 0x86, 0xc1, 0x03, 0x4b, 0x54, 0x7d, 0x54, 0xfd, 0xcf, 0x9d, 0x02, 0x91, 0x2a, 0x7d, 0x2a, + 0x02, 0xa2, 0x00, 0x00, 0x01, 0x00, 0x22, 0x00, 0x00, 0x02, 0x0a, 0x06, 0x00, 0x00, 0x0b, 0x00, 0x4b, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x20, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, + 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb2, 0x01, 0x04, 0x0a, 0x11, 0x12, 0x39, 0xb0, 0x01, 0x2f, 0xb0, 0x00, 0xd0, + 0xb0, 0x01, 0x10, 0xb1, 0x02, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0xd0, 0xb0, + 0x06, 0xd0, 0xb0, 0x07, 0xd0, 0xb0, 0x00, 0x10, 0xb0, 0x09, 0xd0, 0xb0, 0x08, 0xd0, 0x30, 0x31, 0x01, 0x37, 0x15, + 0x07, 0x11, 0x23, 0x11, 0x07, 0x35, 0x37, 0x11, 0x33, 0x01, 0x6c, 0x9e, 0x9e, 0xba, 0x90, 0x90, 0xba, 0x03, 0x65, + 0x3d, 0x7b, 0x3d, 0xfd, 0x16, 0x02, 0xa3, 0x37, 0x7b, 0x37, 0x02, 0xe2, 0x00, 0x00, 0x01, 0x00, 0xa2, 0xfe, 0x4b, + 0x04, 0xf1, 0x05, 0xb0, 0x00, 0x13, 0x00, 0x5b, 0xb2, 0x06, 0x14, 0x15, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, + 0x10, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x14, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x0e, 0x2f, 0x1b, 0xb1, 0x0e, 0x12, 0x3e, 0x59, 0xb0, 0x04, 0x10, 0xb1, 0x09, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x39, 0xb2, 0x12, 0x0e, 0x00, 0x11, + 0x12, 0x39, 0x30, 0x31, 0x01, 0x11, 0x14, 0x06, 0x23, 0x22, 0x27, 0x37, 0x16, 0x33, 0x32, 0x35, 0x35, 0x01, 0x11, + 0x23, 0x11, 0x33, 0x01, 0x11, 0x04, 0xf1, 0xab, 0x9c, 0x3d, 0x36, 0x0e, 0x25, 0x3d, 0x88, 0xfd, 0x33, 0xc0, 0xc0, + 0x02, 0xcd, 0x05, 0xb0, 0xf9, 0xfd, 0xa8, 0xba, 0x12, 0x9a, 0x0e, 0xd0, 0x47, 0x04, 0x6a, 0xfb, 0x96, 0x05, 0xb0, + 0xfb, 0x98, 0x04, 0x68, 0x00, 0x01, 0x00, 0x91, 0xfe, 0x4b, 0x03, 0xf0, 0x04, 0x4e, 0x00, 0x1a, 0x00, 0x63, 0xb2, + 0x0d, 0x1b, 0x1c, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1a, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x14, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x18, 0x2f, 0x1b, 0xb1, 0x18, 0x12, + 0x3e, 0x59, 0xb2, 0x01, 0x18, 0x03, 0x11, 0x12, 0x39, 0xb0, 0x0a, 0x10, 0xb1, 0x0f, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x15, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0x30, 0x31, 0x01, 0x17, 0x36, 0x33, 0x32, 0x16, 0x17, 0x11, 0x14, 0x06, 0x23, 0x22, 0x27, 0x37, 0x16, 0x33, + 0x32, 0x35, 0x11, 0x34, 0x26, 0x23, 0x22, 0x07, 0x11, 0x23, 0x11, 0x01, 0x37, 0x0d, 0x74, 0xcb, 0xb3, 0xb8, 0x02, + 0xa7, 0x9b, 0x3d, 0x36, 0x0e, 0x23, 0x42, 0x89, 0x6f, 0x7d, 0xaf, 0x51, 0xba, 0x04, 0x3a, 0x9a, 0xae, 0xd0, 0xcb, + 0xfc, 0xf4, 0xa4, 0xb8, 0x12, 0x9d, 0x0d, 0xc2, 0x02, 0xf7, 0x8b, 0x80, 0x85, 0xfc, 0xd4, 0x04, 0x3a, 0x00, 0x02, + 0x00, 0x68, 0xff, 0xeb, 0x07, 0x09, 0x05, 0xc4, 0x00, 0x17, 0x00, 0x23, 0x00, 0x96, 0xb2, 0x01, 0x24, 0x25, 0x11, + 0x12, 0x39, 0xb0, 0x01, 0x10, 0xb0, 0x1a, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, + 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0e, 0x2f, 0x1b, 0xb1, 0x0e, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, + 0x03, 0x12, 0x3e, 0x59, 0xb0, 0x0e, 0x10, 0xb1, 0x10, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb2, 0x13, 0x00, 0x0e, 0x11, 0x12, 0x39, 0xb0, 0x13, 0x2f, 0xb1, 0x14, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x00, 0x10, 0xb1, 0x16, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x03, 0x10, 0xb1, 0x18, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0c, 0x10, 0xb1, 0x1d, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x21, 0x21, 0x06, 0x23, 0x22, 0x26, 0x02, + 0x27, 0x11, 0x34, 0x12, 0x36, 0x33, 0x32, 0x17, 0x21, 0x15, 0x21, 0x11, 0x21, 0x15, 0x21, 0x11, 0x21, 0x05, 0x32, + 0x37, 0x11, 0x26, 0x23, 0x22, 0x06, 0x07, 0x11, 0x14, 0x16, 0x07, 0x09, 0xfc, 0xb0, 0xb2, 0x72, 0xa2, 0xfe, 0x8c, + 0x01, 0x8b, 0xfe, 0xa2, 0x7c, 0xaa, 0x03, 0x46, 0xfd, 0x2d, 0x02, 0x77, 0xfd, 0x89, 0x02, 0xdd, 0xfb, 0x8c, 0x71, + 0x66, 0x6d, 0x6c, 0xad, 0xc2, 0x02, 0xc3, 0x15, 0x96, 0x01, 0x0f, 0xab, 0x01, 0x35, 0xac, 0x01, 0x11, 0x97, 0x14, + 0x9e, 0xfe, 0x2c, 0x9d, 0xfd, 0xfc, 0x1b, 0x0e, 0x04, 0x8e, 0x0f, 0xe5, 0xcf, 0xfe, 0xc7, 0xd3, 0xeb, 0x00, 0x03, + 0x00, 0x61, 0xff, 0xec, 0x07, 0x00, 0x04, 0x4e, 0x00, 0x20, 0x00, 0x2c, 0x00, 0x34, 0x00, 0x99, 0xb2, 0x06, 0x35, + 0x36, 0x11, 0x12, 0x39, 0xb0, 0x06, 0x10, 0xb0, 0x26, 0xd0, 0xb0, 0x06, 0x10, 0xb0, 0x30, 0xd0, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, + 0xb1, 0x0a, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x17, 0x2f, 0x1b, 0xb1, 0x17, 0x12, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x1d, 0x2f, 0x1b, 0xb1, 0x1d, 0x12, 0x3e, 0x59, 0xb2, 0x07, 0x0a, 0x17, 0x11, 0x12, 0x39, + 0xb2, 0x31, 0x0a, 0x17, 0x11, 0x12, 0x39, 0xb0, 0x31, 0x2f, 0xb1, 0x0e, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x17, 0x10, 0xb1, 0x12, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, + 0x14, 0x0a, 0x17, 0x11, 0x12, 0x39, 0xb2, 0x1a, 0x0a, 0x17, 0x11, 0x12, 0x39, 0xb0, 0x24, 0xd0, 0xb0, 0x04, 0x10, + 0xb1, 0x2a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x2d, 0xd0, 0x30, 0x31, 0x13, 0x34, + 0x36, 0x36, 0x33, 0x32, 0x16, 0x17, 0x36, 0x36, 0x33, 0x32, 0x16, 0x15, 0x15, 0x21, 0x16, 0x16, 0x33, 0x32, 0x37, + 0x17, 0x06, 0x23, 0x22, 0x26, 0x27, 0x06, 0x06, 0x23, 0x22, 0x00, 0x35, 0x17, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, + 0x34, 0x26, 0x23, 0x22, 0x06, 0x25, 0x22, 0x06, 0x07, 0x21, 0x35, 0x34, 0x26, 0x61, 0x79, 0xdb, 0x8e, 0x89, 0xc9, + 0x3d, 0x41, 0xc4, 0x70, 0xcf, 0xea, 0xfd, 0x32, 0x07, 0xa4, 0x86, 0xbc, 0x78, 0x4a, 0x89, 0xf5, 0x87, 0xcd, 0x3f, + 0x3e, 0xc7, 0x86, 0xdc, 0xfe, 0xf8, 0xb9, 0xa0, 0x8b, 0x89, 0xa0, 0xa1, 0x8a, 0x87, 0xa2, 0x04, 0x2d, 0x63, 0x96, + 0x16, 0x02, 0x0e, 0x89, 0x02, 0x27, 0xa0, 0xfe, 0x89, 0x75, 0x64, 0x66, 0x73, 0xfe, 0xeb, 0x74, 0xaa, 0xc5, 0x6c, + 0x7e, 0x84, 0x70, 0x64, 0x63, 0x71, 0x01, 0x30, 0xfe, 0x09, 0xb7, 0xd8, 0xd7, 0xce, 0xb6, 0xd9, 0xd6, 0xd6, 0xa3, + 0x8a, 0x1a, 0x7d, 0x96, 0x00, 0x01, 0x00, 0xa0, 0x00, 0x00, 0x02, 0x82, 0x06, 0x15, 0x00, 0x0c, 0x00, 0x33, 0xb2, + 0x03, 0x0d, 0x0e, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x20, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb0, 0x04, 0x10, 0xb1, 0x09, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x33, 0x11, 0x36, 0x36, 0x33, 0x32, 0x17, + 0x07, 0x26, 0x23, 0x22, 0x15, 0x11, 0xa0, 0x01, 0xb0, 0xa2, 0x3b, 0x54, 0x17, 0x28, 0x33, 0xb7, 0x04, 0xae, 0xa9, + 0xbe, 0x15, 0x8e, 0x0b, 0xdd, 0xfb, 0x60, 0x00, 0x02, 0x00, 0x5d, 0xff, 0xec, 0x05, 0x12, 0x05, 0xc4, 0x00, 0x17, + 0x00, 0x1f, 0x00, 0x5e, 0xb2, 0x00, 0x20, 0x21, 0x11, 0x12, 0x39, 0xb0, 0x18, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, + 0x12, 0x3e, 0x59, 0xb2, 0x05, 0x10, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x05, 0x2f, 0xb0, 0x10, 0x10, 0xb1, 0x09, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x00, 0x10, 0xb1, 0x18, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x05, 0x10, 0xb1, 0x1b, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0x30, 0x31, 0x05, 0x20, 0x00, 0x11, 0x35, 0x21, 0x35, 0x10, 0x02, 0x23, 0x22, 0x07, 0x07, 0x27, 0x37, 0x36, + 0x33, 0x20, 0x00, 0x11, 0x15, 0x14, 0x02, 0x04, 0x27, 0x32, 0x12, 0x37, 0x21, 0x15, 0x14, 0x16, 0x02, 0xb9, 0xfe, + 0xe3, 0xfe, 0xc1, 0x03, 0xf4, 0xf4, 0xdd, 0xa5, 0x8b, 0x3d, 0x2f, 0x16, 0x9e, 0xe8, 0x01, 0x2e, 0x01, 0x64, 0x9c, + 0xfe, 0xea, 0xa7, 0xa9, 0xde, 0x0f, 0xfc, 0xcf, 0xd3, 0x14, 0x01, 0x59, 0x01, 0x45, 0x75, 0x07, 0x01, 0x02, 0x01, + 0x1c, 0x3a, 0x1a, 0x8f, 0x0d, 0x58, 0xfe, 0x87, 0xfe, 0xb1, 0x54, 0xc5, 0xfe, 0xbf, 0xb6, 0x9e, 0x01, 0x05, 0xdb, + 0x22, 0xda, 0xe4, 0x00, 0x00, 0x01, 0xff, 0xe4, 0xfe, 0x4b, 0x02, 0xbc, 0x06, 0x15, 0x00, 0x1e, 0x00, 0x74, 0xb2, + 0x14, 0x1f, 0x20, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x15, 0x2f, 0x1b, 0xb1, 0x15, 0x20, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x1d, 0x2f, 0x1b, 0xb1, 0x1d, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x14, + 0x3e, 0x59, 0xb0, 0x1d, 0x10, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x05, + 0x10, 0xb1, 0x0a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x00, 0x10, 0xb0, 0x0e, 0xd0, + 0xb0, 0x0f, 0xd0, 0xb0, 0x15, 0x10, 0xb1, 0x1a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, + 0x31, 0x01, 0x23, 0x11, 0x14, 0x06, 0x23, 0x22, 0x27, 0x37, 0x16, 0x33, 0x32, 0x36, 0x35, 0x11, 0x23, 0x35, 0x33, + 0x35, 0x36, 0x36, 0x33, 0x32, 0x17, 0x07, 0x26, 0x23, 0x22, 0x07, 0x15, 0x33, 0x02, 0x60, 0xcb, 0xa8, 0x9a, 0x3d, + 0x32, 0x0e, 0x1e, 0x43, 0x41, 0x47, 0xab, 0xab, 0x02, 0xaf, 0xa1, 0x3b, 0x54, 0x16, 0x26, 0x3c, 0xab, 0x04, 0xcb, + 0x03, 0xab, 0xfb, 0xfe, 0xa7, 0xb7, 0x12, 0x93, 0x0d, 0x68, 0x5c, 0x04, 0x04, 0x8f, 0x78, 0xa7, 0xbc, 0x15, 0x93, + 0x0a, 0xc3, 0x7a, 0x00, 0x02, 0x00, 0x65, 0xff, 0xec, 0x05, 0x9d, 0x06, 0x37, 0x00, 0x17, 0x00, 0x25, 0x00, 0x55, + 0xb2, 0x04, 0x26, 0x27, 0x11, 0x12, 0x39, 0xb0, 0x04, 0x10, 0xb0, 0x22, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, + 0x3e, 0x59, 0xb2, 0x0f, 0x0d, 0x04, 0x11, 0x12, 0x39, 0xb0, 0x0f, 0x10, 0xb0, 0x15, 0xd0, 0xb0, 0x0d, 0x10, 0xb1, + 0x1b, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0x10, 0xb1, 0x22, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x14, 0x02, 0x04, 0x23, 0x22, 0x24, 0x02, 0x27, 0x35, + 0x34, 0x12, 0x24, 0x33, 0x32, 0x17, 0x36, 0x36, 0x35, 0x33, 0x10, 0x05, 0x16, 0x17, 0x07, 0x10, 0x02, 0x23, 0x22, + 0x02, 0x07, 0x15, 0x14, 0x12, 0x33, 0x32, 0x12, 0x11, 0x04, 0xf8, 0x90, 0xfe, 0xf8, 0xb0, 0xab, 0xfe, 0xf6, 0x95, + 0x01, 0x92, 0x01, 0x0b, 0xac, 0xf0, 0x9b, 0x60, 0x5d, 0xa7, 0xfe, 0xf9, 0x61, 0x01, 0xbe, 0xcf, 0xbd, 0xb6, 0xd1, + 0x03, 0xd3, 0xb9, 0xbf, 0xcb, 0x02, 0xa9, 0xd6, 0xfe, 0xc1, 0xa8, 0xa8, 0x01, 0x3e, 0xcf, 0x64, 0xd2, 0x01, 0x41, + 0xac, 0x9b, 0x07, 0x83, 0x84, 0xfe, 0xb3, 0x3d, 0xac, 0xf6, 0x04, 0x01, 0x02, 0x01, 0x16, 0xfe, 0xeb, 0xf6, 0x6b, + 0xfb, 0xfe, 0xe1, 0x01, 0x1a, 0x01, 0x01, 0x00, 0x00, 0x02, 0x00, 0x5b, 0xff, 0xec, 0x04, 0xba, 0x04, 0xb0, 0x00, + 0x16, 0x00, 0x23, 0x00, 0x55, 0xb2, 0x13, 0x24, 0x25, 0x11, 0x12, 0x39, 0xb0, 0x13, 0x10, 0xb0, 0x1a, 0xd0, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x13, + 0x2f, 0x1b, 0xb1, 0x13, 0x12, 0x3e, 0x59, 0xb2, 0x06, 0x04, 0x13, 0x11, 0x12, 0x39, 0xb0, 0x06, 0x10, 0xb0, 0x0c, + 0xd0, 0xb0, 0x13, 0x10, 0xb1, 0x1a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0x10, + 0xb1, 0x21, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x13, 0x34, 0x36, 0x36, 0x33, + 0x32, 0x17, 0x36, 0x36, 0x35, 0x33, 0x10, 0x07, 0x16, 0x15, 0x15, 0x14, 0x06, 0x06, 0x23, 0x22, 0x00, 0x35, 0x17, + 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x5b, 0x7b, 0xe1, 0x8f, 0xcf, 0x88, 0x47, + 0x40, 0x96, 0xcf, 0x49, 0x7c, 0xe0, 0x90, 0xde, 0xfe, 0xf1, 0xb9, 0xa7, 0x8d, 0x8b, 0xa7, 0xa9, 0x8b, 0x8a, 0xa8, + 0x02, 0x27, 0x9f, 0xfd, 0x8b, 0x8a, 0x08, 0x64, 0x80, 0xfe, 0xdd, 0x33, 0x8a, 0xa9, 0x16, 0x9e, 0xfe, 0x89, 0x01, + 0x33, 0xfb, 0x09, 0xb4, 0xda, 0xdb, 0xb9, 0x10, 0xb5, 0xda, 0xda, 0x00, 0x00, 0x01, 0x00, 0x8c, 0xff, 0xec, 0x06, + 0x1d, 0x06, 0x02, 0x00, 0x1a, 0x00, 0x4d, 0xb2, 0x0c, 0x1b, 0x1c, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x12, 0x2f, 0x1b, 0xb1, 0x12, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x1a, 0x2f, 0x1b, 0xb1, 0x1a, + 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x12, 0x3e, 0x59, 0xb2, 0x01, 0x0d, + 0x1a, 0x11, 0x12, 0x39, 0xb0, 0x01, 0x10, 0xb0, 0x08, 0xd0, 0xb0, 0x0d, 0x10, 0xb1, 0x16, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x15, 0x36, 0x36, 0x35, 0x33, 0x14, 0x06, 0x07, 0x11, 0x06, + 0x02, 0x07, 0x07, 0x22, 0x00, 0x27, 0x11, 0x33, 0x11, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x11, 0x04, 0xaa, 0x73, + 0x61, 0x9f, 0xb1, 0xc2, 0x01, 0xf4, 0xd3, 0x49, 0xef, 0xfe, 0xe4, 0x02, 0xbe, 0xae, 0xa1, 0xa3, 0xad, 0x05, 0xb0, + 0xd5, 0x0b, 0x89, 0x93, 0xd2, 0xd1, 0x0c, 0xfd, 0x7e, 0xc7, 0xfe, 0xfc, 0x16, 0x04, 0x01, 0x02, 0xe2, 0x03, 0xe0, + 0xfc, 0x26, 0x9e, 0xaf, 0xae, 0x9e, 0x03, 0xdb, 0x00, 0x00, 0x01, 0x00, 0x88, 0xff, 0xec, 0x05, 0x0f, 0x04, 0x90, + 0x00, 0x19, 0x00, 0x61, 0xb2, 0x07, 0x1a, 0x1b, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x13, 0x2f, + 0x1b, 0xb1, 0x13, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1a, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, + 0x2f, 0x1b, 0xb1, 0x05, 0x12, 0x3e, 0x59, 0xb2, 0x15, 0x08, 0x13, 0x11, 0x12, 0x39, 0xb0, 0x15, 0x10, 0xb0, 0x03, + 0xd0, 0xb2, 0x06, 0x08, 0x13, 0x11, 0x12, 0x39, 0xb0, 0x08, 0x10, 0xb1, 0x10, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x14, 0x06, 0x07, 0x11, 0x23, 0x27, 0x06, 0x23, 0x22, 0x26, 0x27, 0x11, + 0x33, 0x11, 0x14, 0x33, 0x32, 0x37, 0x11, 0x33, 0x15, 0x3e, 0x02, 0x35, 0x05, 0x0f, 0x93, 0xa0, 0xb0, 0x04, 0x6c, + 0xd1, 0xad, 0xb5, 0x01, 0xb9, 0xc8, 0xd4, 0x46, 0xb9, 0x44, 0x44, 0x1d, 0x04, 0x90, 0xb4, 0x93, 0x04, 0xfc, 0xbb, + 0x6b, 0x7f, 0xc9, 0xc5, 0x02, 0xc0, 0xfd, 0x45, 0xf6, 0x9e, 0x03, 0x13, 0x83, 0x02, 0x23, 0x48, 0x6c, 0x00, 0x00, + 0x01, 0xff, 0xb4, 0xfe, 0x4b, 0x01, 0x65, 0x04, 0x3a, 0x00, 0x0d, 0x00, 0x29, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x14, + 0x3e, 0x59, 0xb1, 0x09, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x11, 0x14, + 0x06, 0x23, 0x22, 0x27, 0x37, 0x16, 0x33, 0x32, 0x36, 0x35, 0x11, 0x01, 0x65, 0xaa, 0x98, 0x3b, 0x34, 0x0e, 0x1e, + 0x43, 0x41, 0x48, 0x04, 0x3a, 0xfb, 0x6d, 0xaa, 0xb2, 0x12, 0x93, 0x0d, 0x68, 0x5c, 0x04, 0x93, 0x00, 0x00, 0x02, + 0x00, 0x62, 0xff, 0xec, 0x03, 0xe9, 0x04, 0x4f, 0x00, 0x14, 0x00, 0x1c, 0x00, 0x68, 0xb2, 0x08, 0x1d, 0x1e, 0x11, + 0x12, 0x39, 0xb0, 0x08, 0x10, 0xb0, 0x15, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, + 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x12, 0x3e, 0x59, 0xb2, 0x0d, 0x00, + 0x08, 0x11, 0x12, 0x39, 0xb0, 0x0d, 0x2f, 0xb0, 0x00, 0x10, 0xb1, 0x10, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb2, 0x12, 0x00, 0x08, 0x11, 0x12, 0x39, 0xb0, 0x08, 0x10, 0xb1, 0x15, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0d, 0x10, 0xb1, 0x18, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0x30, 0x31, 0x01, 0x32, 0x00, 0x15, 0x15, 0x14, 0x06, 0x06, 0x27, 0x22, 0x26, 0x35, 0x35, 0x21, 0x26, + 0x26, 0x23, 0x22, 0x07, 0x27, 0x36, 0x01, 0x32, 0x36, 0x37, 0x21, 0x15, 0x14, 0x16, 0x01, 0xff, 0xdc, 0x01, 0x0e, + 0x7c, 0xd8, 0x7a, 0xd0, 0xe9, 0x02, 0xcd, 0x07, 0xa1, 0x88, 0xba, 0x7b, 0x49, 0x8c, 0x01, 0x0e, 0x62, 0x97, 0x15, + 0xfd, 0xf3, 0x89, 0x04, 0x4f, 0xfe, 0xd4, 0xf9, 0x24, 0x95, 0xf8, 0x8d, 0x01, 0xfe, 0xe9, 0x74, 0xa8, 0xc8, 0x6c, + 0x7d, 0x86, 0xfc, 0x35, 0xa4, 0x89, 0x1a, 0x7d, 0x96, 0x00, 0x00, 0x01, 0x00, 0xa9, 0x04, 0xe4, 0x03, 0x06, 0x06, + 0x00, 0x00, 0x08, 0x00, 0x34, 0x00, 0xb0, 0x04, 0x2f, 0xb0, 0x07, 0xd0, 0xb0, 0x07, 0x2f, 0xb4, 0x0f, 0x07, 0x1f, + 0x07, 0x02, 0x5d, 0xb2, 0x05, 0x04, 0x07, 0x11, 0x12, 0x39, 0x19, 0xb0, 0x05, 0x2f, 0x18, 0xb0, 0x01, 0xd0, 0x19, + 0xb0, 0x01, 0x2f, 0x18, 0xb0, 0x04, 0x10, 0xb0, 0x02, 0xd0, 0xb2, 0x03, 0x04, 0x07, 0x11, 0x12, 0x39, 0x30, 0x31, + 0x01, 0x15, 0x23, 0x27, 0x07, 0x23, 0x35, 0x13, 0x33, 0x03, 0x06, 0x99, 0x96, 0x95, 0x99, 0xf6, 0x70, 0x04, 0xee, + 0x0a, 0xaa, 0xaa, 0x0c, 0x01, 0x10, 0x00, 0x00, 0x01, 0x00, 0x8d, 0x04, 0xe3, 0x02, 0xf7, 0x05, 0xff, 0x00, 0x08, + 0x00, 0x20, 0x00, 0xb0, 0x04, 0x2f, 0xb0, 0x01, 0xd0, 0xb0, 0x01, 0x2f, 0xb4, 0x0f, 0x01, 0x1f, 0x01, 0x02, 0x5d, + 0xb2, 0x00, 0x04, 0x01, 0x11, 0x12, 0x39, 0xb0, 0x08, 0xd0, 0xb0, 0x08, 0x2f, 0x30, 0x31, 0x01, 0x37, 0x33, 0x15, + 0x03, 0x23, 0x03, 0x35, 0x33, 0x01, 0xc1, 0x96, 0xa0, 0xfe, 0x71, 0xfb, 0x9d, 0x05, 0x55, 0xaa, 0x0a, 0xfe, 0xee, + 0x01, 0x12, 0x0a, 0xff, 0xff, 0x00, 0x8e, 0x05, 0x16, 0x03, 0x2e, 0x05, 0xa5, 0x01, 0x06, 0x00, 0x70, 0x00, 0x00, + 0x00, 0x0a, 0x00, 0xb0, 0x01, 0x2f, 0xb1, 0x02, 0x03, 0xf4, 0x30, 0x31, 0x00, 0x01, 0x00, 0x81, 0x04, 0xcb, 0x02, + 0xd8, 0x05, 0xd7, 0x00, 0x0c, 0x00, 0x27, 0xb2, 0x09, 0x0d, 0x0e, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x03, 0x2f, 0xb2, + 0x0f, 0x03, 0x01, 0x5d, 0xb1, 0x09, 0x04, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x06, 0xd0, + 0xb0, 0x06, 0x2f, 0xb0, 0x0c, 0xd0, 0x30, 0x31, 0x01, 0x14, 0x06, 0x20, 0x26, 0x35, 0x33, 0x14, 0x16, 0x33, 0x32, + 0x36, 0x35, 0x02, 0xd8, 0xa5, 0xfe, 0xf4, 0xa6, 0x97, 0x4c, 0x49, 0x46, 0x4f, 0x05, 0xd7, 0x79, 0x93, 0x94, 0x78, + 0x46, 0x4f, 0x4e, 0x47, 0x00, 0x00, 0x01, 0x00, 0x8d, 0x04, 0xee, 0x01, 0x68, 0x05, 0xc2, 0x00, 0x08, 0x00, 0x19, + 0xb2, 0x02, 0x09, 0x0a, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x07, 0x2f, 0xb1, 0x02, 0x05, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x13, 0x34, 0x36, 0x32, 0x16, 0x14, 0x06, 0x22, 0x26, 0x8d, 0x37, 0x6c, 0x38, + 0x38, 0x6c, 0x37, 0x05, 0x57, 0x2d, 0x3e, 0x3e, 0x5a, 0x3c, 0x3c, 0x00, 0x00, 0x02, 0x00, 0x79, 0x04, 0xb4, 0x02, + 0x27, 0x06, 0x50, 0x00, 0x09, 0x00, 0x14, 0x00, 0x2a, 0xb2, 0x03, 0x15, 0x16, 0x11, 0x12, 0x39, 0xb0, 0x03, 0x10, + 0xb0, 0x0d, 0xd0, 0x00, 0xb0, 0x03, 0x2f, 0xb0, 0x07, 0xd0, 0xb0, 0x07, 0x2f, 0xb2, 0x3f, 0x07, 0x01, 0x5d, 0xb0, + 0x03, 0x10, 0xb0, 0x0d, 0xd0, 0xb0, 0x07, 0x10, 0xb0, 0x12, 0xd0, 0x30, 0x31, 0x01, 0x14, 0x06, 0x23, 0x22, 0x26, + 0x34, 0x36, 0x32, 0x16, 0x05, 0x14, 0x16, 0x33, 0x32, 0x36, 0x34, 0x26, 0x23, 0x22, 0x06, 0x02, 0x27, 0x7c, 0x5b, + 0x5c, 0x7b, 0x7b, 0xb8, 0x7b, 0xfe, 0xb5, 0x43, 0x31, 0x30, 0x44, 0x43, 0x31, 0x32, 0x42, 0x05, 0x80, 0x57, 0x75, + 0x76, 0xac, 0x7a, 0x7a, 0x56, 0x2f, 0x44, 0x42, 0x62, 0x45, 0x46, 0x00, 0x00, 0x01, 0x00, 0x32, 0xfe, 0x4f, 0x01, + 0x92, 0x00, 0x38, 0x00, 0x10, 0x00, 0x32, 0xb2, 0x05, 0x11, 0x12, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x10, 0x2f, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x14, 0x3e, 0x59, 0xb1, 0x05, 0x03, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x40, 0x09, 0x0f, 0x10, 0x1f, 0x10, 0x2f, 0x10, 0x3f, 0x10, 0x04, 0x5d, 0x30, 0x31, + 0x21, 0x07, 0x06, 0x15, 0x14, 0x33, 0x32, 0x37, 0x17, 0x06, 0x23, 0x22, 0x26, 0x35, 0x34, 0x36, 0x37, 0x01, 0x7e, + 0x3a, 0x71, 0x4e, 0x30, 0x34, 0x0d, 0x46, 0x5a, 0x59, 0x67, 0x86, 0x7b, 0x2d, 0x5b, 0x56, 0x48, 0x1a, 0x79, 0x2c, + 0x68, 0x56, 0x59, 0x9a, 0x38, 0x00, 0x00, 0x01, 0x00, 0x7b, 0x04, 0xd9, 0x03, 0x3e, 0x05, 0xe8, 0x00, 0x17, 0x00, + 0x40, 0x00, 0xb0, 0x03, 0x2f, 0xb0, 0x08, 0xd0, 0xb0, 0x08, 0x2f, 0xb4, 0x0f, 0x08, 0x1f, 0x08, 0x02, 0x5d, 0xb0, + 0x03, 0x10, 0xb0, 0x0b, 0xd0, 0xb0, 0x0b, 0x2f, 0xb0, 0x08, 0x10, 0xb1, 0x0f, 0x03, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x14, 0x03, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb0, 0x0f, 0x10, 0xb0, 0x17, 0xd0, 0x30, 0x31, 0x01, 0x14, 0x06, 0x23, 0x22, 0x2e, 0x02, 0x23, 0x22, 0x06, 0x15, + 0x27, 0x34, 0x36, 0x33, 0x32, 0x1e, 0x02, 0x33, 0x32, 0x36, 0x35, 0x03, 0x3e, 0x7b, 0x5c, 0x29, 0x3c, 0x61, 0x2b, + 0x1c, 0x29, 0x3a, 0x7c, 0x79, 0x5d, 0x23, 0x38, 0x60, 0x33, 0x1f, 0x2b, 0x39, 0x05, 0xdc, 0x6c, 0x86, 0x14, 0x3e, + 0x0d, 0x3f, 0x31, 0x07, 0x6b, 0x8c, 0x14, 0x3a, 0x12, 0x44, 0x2d, 0x00, 0x02, 0x00, 0x5e, 0x04, 0xd0, 0x03, 0x2c, + 0x05, 0xff, 0x00, 0x03, 0x00, 0x07, 0x00, 0x3b, 0x00, 0xb0, 0x02, 0x2f, 0xb0, 0x00, 0xd0, 0xb0, 0x00, 0x2f, 0xb4, + 0x0f, 0x00, 0x1f, 0x00, 0x02, 0x5d, 0xb0, 0x02, 0x10, 0xb0, 0x03, 0xd0, 0x19, 0xb0, 0x03, 0x2f, 0x18, 0xb0, 0x00, + 0x10, 0xb0, 0x05, 0xd0, 0xb0, 0x05, 0x2f, 0xb0, 0x02, 0x10, 0xb0, 0x06, 0xd0, 0xb0, 0x06, 0x2f, 0xb0, 0x03, 0x10, + 0xb0, 0x07, 0xd0, 0x19, 0xb0, 0x07, 0x2f, 0x18, 0x30, 0x31, 0x01, 0x33, 0x01, 0x23, 0x03, 0x33, 0x03, 0x23, 0x02, + 0x5d, 0xcf, 0xfe, 0xf3, 0xa9, 0x6d, 0xc5, 0xda, 0x96, 0x05, 0xff, 0xfe, 0xd1, 0x01, 0x2f, 0xfe, 0xd1, 0x00, 0x00, + 0x02, 0x00, 0x7e, 0xfe, 0x6b, 0x01, 0xd5, 0xff, 0xb5, 0x00, 0x0b, 0x00, 0x16, 0x00, 0x34, 0x00, 0xb0, 0x03, 0x2f, + 0x40, 0x0b, 0x00, 0x03, 0x10, 0x03, 0x20, 0x03, 0x30, 0x03, 0x40, 0x03, 0x05, 0x5d, 0xb0, 0x09, 0xd0, 0xb0, 0x09, + 0x2f, 0x40, 0x09, 0x30, 0x09, 0x40, 0x09, 0x50, 0x09, 0x60, 0x09, 0x04, 0x5d, 0xb2, 0x00, 0x09, 0x01, 0x5d, 0xb0, + 0x0e, 0xd0, 0xb0, 0x03, 0x10, 0xb0, 0x14, 0xd0, 0x30, 0x31, 0x17, 0x34, 0x36, 0x33, 0x32, 0x16, 0x15, 0x14, 0x06, + 0x23, 0x22, 0x26, 0x37, 0x14, 0x16, 0x32, 0x36, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x7e, 0x64, 0x4a, 0x47, 0x62, + 0x60, 0x49, 0x4c, 0x62, 0x57, 0x34, 0x46, 0x30, 0x30, 0x23, 0x25, 0x32, 0xf2, 0x46, 0x61, 0x60, 0x47, 0x46, 0x5d, + 0x5e, 0x45, 0x23, 0x30, 0x30, 0x23, 0x24, 0x32, 0x34, 0x00, 0x01, 0xfc, 0xa7, 0x04, 0xda, 0xfe, 0x48, 0x06, 0x00, + 0x00, 0x03, 0x00, 0x1e, 0x00, 0xb0, 0x01, 0x2f, 0xb0, 0x00, 0xd0, 0x19, 0xb0, 0x00, 0x2f, 0x18, 0xb0, 0x01, 0x10, + 0xb0, 0x02, 0xd0, 0xb0, 0x02, 0x2f, 0xb4, 0x0f, 0x02, 0x1f, 0x02, 0x02, 0x5d, 0x30, 0x31, 0x01, 0x23, 0x01, 0x33, + 0xfe, 0x48, 0x9f, 0xfe, 0xfe, 0xe0, 0x04, 0xda, 0x01, 0x26, 0x00, 0x01, 0xfd, 0x6f, 0x04, 0xda, 0xff, 0x10, 0x06, + 0x00, 0x00, 0x03, 0x00, 0x1e, 0x00, 0xb0, 0x02, 0x2f, 0xb0, 0x01, 0xd0, 0xb0, 0x01, 0x2f, 0xb4, 0x0f, 0x01, 0x1f, + 0x01, 0x02, 0x5d, 0xb0, 0x02, 0x10, 0xb0, 0x03, 0xd0, 0x19, 0xb0, 0x03, 0x2f, 0x18, 0x30, 0x31, 0x01, 0x33, 0x01, + 0x23, 0xfe, 0x30, 0xe0, 0xfe, 0xf4, 0x95, 0x06, 0x00, 0xfe, 0xda, 0xff, 0xff, 0xfc, 0x8b, 0x04, 0xd9, 0xff, 0x4e, + 0x05, 0xe8, 0x00, 0x07, 0x00, 0xa5, 0xfc, 0x10, 0x00, 0x00, 0x00, 0x01, 0xfd, 0x5e, 0x04, 0xd9, 0xfe, 0x94, 0x06, + 0x74, 0x00, 0x0e, 0x00, 0x2e, 0x00, 0xb0, 0x00, 0x2f, 0xb2, 0x0f, 0x00, 0x01, 0x5d, 0xb0, 0x07, 0xd0, 0xb0, 0x07, + 0x2f, 0x40, 0x09, 0x0f, 0x07, 0x1f, 0x07, 0x2f, 0x07, 0x3f, 0x07, 0x04, 0x5d, 0xb0, 0x06, 0xd0, 0xb2, 0x01, 0x00, + 0x06, 0x11, 0x12, 0x39, 0xb2, 0x0d, 0x00, 0x07, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x27, 0x36, 0x36, 0x34, 0x26, + 0x23, 0x37, 0x32, 0x16, 0x15, 0x14, 0x06, 0x07, 0x07, 0xfd, 0x74, 0x01, 0x4b, 0x46, 0x5b, 0x4b, 0x07, 0x95, 0x9a, + 0x4e, 0x4d, 0x01, 0x04, 0xd9, 0x99, 0x05, 0x1e, 0x4e, 0x27, 0x6a, 0x67, 0x55, 0x3d, 0x50, 0x0b, 0x47, 0x00, 0x02, + 0xfc, 0x27, 0x04, 0xe4, 0xff, 0x07, 0x05, 0xee, 0x00, 0x03, 0x00, 0x07, 0x00, 0x37, 0x00, 0xb0, 0x01, 0x2f, 0xb0, + 0x00, 0xd0, 0x19, 0xb0, 0x00, 0x2f, 0x18, 0xb0, 0x01, 0x10, 0xb0, 0x05, 0xd0, 0xb0, 0x05, 0x2f, 0xb0, 0x06, 0xd0, + 0xb0, 0x06, 0x2f, 0xb6, 0x0f, 0x06, 0x1f, 0x06, 0x2f, 0x06, 0x03, 0x5d, 0xb0, 0x03, 0xd0, 0xb0, 0x03, 0x2f, 0xb0, + 0x00, 0x10, 0xb0, 0x04, 0xd0, 0x19, 0xb0, 0x04, 0x2f, 0x18, 0x30, 0x31, 0x01, 0x23, 0x01, 0x33, 0x01, 0x23, 0x03, + 0x33, 0xfe, 0x02, 0xa9, 0xfe, 0xce, 0xe1, 0x01, 0xff, 0x96, 0xf6, 0xce, 0x04, 0xe4, 0x01, 0x0a, 0xfe, 0xf6, 0x01, + 0x0a, 0x00, 0x01, 0xfd, 0x38, 0xfe, 0xa2, 0xfe, 0x13, 0xff, 0x76, 0x00, 0x08, 0x00, 0x12, 0x00, 0xb0, 0x02, 0x2f, + 0xb1, 0x07, 0x05, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x05, 0x34, 0x36, 0x32, 0x16, + 0x14, 0x06, 0x22, 0x26, 0xfd, 0x38, 0x37, 0x6c, 0x38, 0x38, 0x6c, 0x37, 0xf5, 0x2d, 0x3e, 0x3e, 0x5a, 0x3c, 0x3c, + 0x00, 0x01, 0x00, 0xb7, 0x04, 0xee, 0x01, 0x9b, 0x06, 0x3f, 0x00, 0x03, 0x00, 0x1d, 0x00, 0xb0, 0x02, 0x2f, 0xb0, + 0x00, 0xd0, 0xb0, 0x00, 0x2f, 0xb2, 0x0f, 0x00, 0x01, 0x5d, 0xb2, 0x03, 0x02, 0x00, 0x11, 0x12, 0x39, 0x19, 0xb0, + 0x03, 0x2f, 0x18, 0x30, 0x31, 0x13, 0x33, 0x03, 0x23, 0xed, 0xae, 0x74, 0x70, 0x06, 0x3f, 0xfe, 0xaf, 0x00, 0x00, + 0x03, 0x00, 0x71, 0x04, 0xf0, 0x03, 0x83, 0x06, 0x88, 0x00, 0x03, 0x00, 0x0c, 0x00, 0x15, 0x00, 0x38, 0x00, 0xb0, + 0x0b, 0x2f, 0xb0, 0x02, 0xd0, 0xb0, 0x02, 0x2f, 0xb0, 0x01, 0xd0, 0xb0, 0x01, 0x2f, 0xb0, 0x02, 0x10, 0xb0, 0x03, + 0xd0, 0x19, 0xb0, 0x03, 0x2f, 0x18, 0xb0, 0x0b, 0x10, 0xb1, 0x06, 0x05, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb0, 0x0f, 0xd0, 0xb0, 0x0b, 0x10, 0xb0, 0x14, 0xd0, 0xb0, 0x14, 0x2f, 0x30, 0x31, 0x01, 0x33, 0x03, + 0x23, 0x05, 0x34, 0x36, 0x32, 0x16, 0x14, 0x06, 0x22, 0x26, 0x25, 0x34, 0x36, 0x32, 0x16, 0x14, 0x06, 0x22, 0x26, + 0x01, 0xe1, 0xbc, 0x65, 0x87, 0xfe, 0xc0, 0x37, 0x6c, 0x38, 0x38, 0x6c, 0x37, 0x02, 0x37, 0x37, 0x6c, 0x38, 0x38, + 0x6c, 0x37, 0x06, 0x88, 0xfe, 0xf8, 0x25, 0x2d, 0x3d, 0x3d, 0x5a, 0x3c, 0x3c, 0x2b, 0x2d, 0x3e, 0x3e, 0x5a, 0x3c, + 0x3c, 0x00, 0xff, 0xff, 0x00, 0x93, 0x02, 0x6b, 0x01, 0x79, 0x03, 0x49, 0x01, 0x06, 0x00, 0x78, 0x00, 0x00, 0x00, + 0x06, 0x00, 0xb0, 0x02, 0x2f, 0x30, 0x31, 0x00, 0x01, 0x00, 0xb1, 0x00, 0x00, 0x04, 0x30, 0x05, 0xb0, 0x00, 0x05, + 0x00, 0x2c, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x04, 0x10, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, 0x11, 0x23, 0x11, 0x21, 0x04, 0x30, 0xfd, 0x42, 0xc1, + 0x03, 0x7f, 0x05, 0x12, 0xfa, 0xee, 0x05, 0xb0, 0x00, 0x00, 0x02, 0x00, 0x1f, 0x00, 0x00, 0x05, 0x73, 0x05, 0xb0, + 0x00, 0x03, 0x00, 0x06, 0x00, 0x30, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1e, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb1, 0x04, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x06, 0x02, 0x00, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x33, 0x01, + 0x21, 0x25, 0x21, 0x01, 0x02, 0x86, 0xaa, 0x02, 0x43, 0xfa, 0xac, 0x01, 0x06, 0x03, 0x4c, 0xfe, 0x67, 0x05, 0xb0, + 0xfa, 0x50, 0x9d, 0x04, 0x28, 0x00, 0x00, 0x03, 0x00, 0x67, 0xff, 0xec, 0x04, 0xfa, 0x05, 0xc4, 0x00, 0x03, 0x00, + 0x15, 0x00, 0x23, 0x00, 0x7a, 0xb2, 0x08, 0x24, 0x25, 0x11, 0x12, 0x39, 0xb0, 0x08, 0x10, 0xb0, 0x01, 0xd0, 0xb0, + 0x08, 0x10, 0xb0, 0x20, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x11, 0x2f, 0x1b, 0xb1, 0x11, 0x1e, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x12, 0x3e, 0x59, 0xb2, 0x02, 0x08, 0x11, 0x11, 0x12, + 0x39, 0xb0, 0x02, 0x2f, 0xb2, 0xcf, 0x02, 0x01, 0x5d, 0xb2, 0xff, 0x02, 0x01, 0x5d, 0xb2, 0x2f, 0x02, 0x01, 0x5d, + 0xb4, 0xbf, 0x02, 0xcf, 0x02, 0x02, 0x71, 0xb1, 0x01, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb0, 0x11, 0x10, 0xb1, 0x19, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, 0x10, 0xb1, + 0x20, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, 0x35, 0x21, 0x05, 0x14, + 0x02, 0x04, 0x23, 0x22, 0x24, 0x02, 0x27, 0x35, 0x34, 0x12, 0x24, 0x33, 0x32, 0x04, 0x12, 0x17, 0x07, 0x10, 0x02, + 0x23, 0x22, 0x02, 0x07, 0x15, 0x14, 0x12, 0x33, 0x32, 0x12, 0x37, 0x03, 0xc0, 0xfd, 0xfb, 0x02, 0x05, 0x01, 0x3a, + 0x8f, 0xfe, 0xf8, 0xb1, 0xac, 0xfe, 0xf6, 0x93, 0x02, 0x92, 0x01, 0x0b, 0xac, 0xaf, 0x01, 0x08, 0x91, 0x02, 0xbf, + 0xd0, 0xbb, 0xb6, 0xd1, 0x03, 0xd1, 0xbb, 0xba, 0xcc, 0x03, 0x02, 0x93, 0x98, 0x82, 0xd5, 0xfe, 0xc2, 0xaa, 0xa9, + 0x01, 0x39, 0xce, 0x69, 0xd2, 0x01, 0x42, 0xab, 0xa8, 0xfe, 0xc5, 0xcf, 0x0b, 0x01, 0x03, 0x01, 0x15, 0xfe, 0xeb, + 0xf6, 0x6b, 0xfa, 0xfe, 0xe0, 0x01, 0x0f, 0xfd, 0x00, 0x00, 0x01, 0x00, 0x32, 0x00, 0x00, 0x05, 0x03, 0x05, 0xb0, + 0x00, 0x06, 0x00, 0x31, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1e, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, + 0x1b, 0xb1, 0x05, 0x12, 0x3e, 0x59, 0xb2, 0x00, 0x03, 0x01, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x01, 0x23, 0x01, + 0x33, 0x01, 0x23, 0x02, 0x9a, 0xfe, 0x66, 0xce, 0x02, 0x12, 0xac, 0x02, 0x13, 0xcf, 0x04, 0x89, 0xfb, 0x77, 0x05, + 0xb0, 0xfa, 0x50, 0x00, 0x00, 0x03, 0x00, 0x78, 0x00, 0x00, 0x04, 0x21, 0x05, 0xb0, 0x00, 0x03, 0x00, 0x07, 0x00, + 0x0b, 0x00, 0x52, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1e, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x02, 0x10, 0xb0, 0x05, 0xd0, 0xb0, 0x05, 0x2f, 0xb2, 0x2f, 0x05, 0x01, 0x5d, 0xb1, + 0x06, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, 0x10, 0xb1, 0x0a, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x37, 0x21, 0x15, 0x21, 0x13, 0x21, 0x15, 0x21, 0x03, 0x21, + 0x15, 0x21, 0x78, 0x03, 0xa9, 0xfc, 0x57, 0x57, 0x02, 0xf2, 0xfd, 0x0e, 0x53, 0x03, 0x94, 0xfc, 0x6c, 0x9d, 0x9d, + 0x03, 0x3f, 0x9d, 0x03, 0x0e, 0x9e, 0x00, 0x00, 0x01, 0x00, 0xb2, 0x00, 0x00, 0x05, 0x01, 0x05, 0xb0, 0x00, 0x07, + 0x00, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, + 0x04, 0x12, 0x3e, 0x59, 0xb0, 0x06, 0x10, 0xb1, 0x02, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0x30, 0x31, 0x21, 0x23, 0x11, 0x21, 0x11, 0x23, 0x11, 0x21, 0x05, 0x01, 0xc1, 0xfd, 0x32, 0xc0, 0x04, 0x4f, 0x05, + 0x12, 0xfa, 0xee, 0x05, 0xb0, 0x00, 0x00, 0x01, 0x00, 0x45, 0x00, 0x00, 0x04, 0x44, 0x05, 0xb0, 0x00, 0x0c, 0x00, + 0x3e, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x12, 0x3e, 0x59, 0xb1, 0x01, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb0, 0x05, 0xd0, 0xb0, 0x08, 0x10, 0xb1, 0x0a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb0, 0x07, 0xd0, 0x30, 0x31, 0x01, 0x01, 0x21, 0x15, 0x21, 0x35, 0x01, 0x01, 0x35, 0x21, 0x15, 0x21, 0x01, + 0x02, 0xf2, 0xfe, 0x43, 0x03, 0x0f, 0xfc, 0x01, 0x01, 0xe1, 0xfe, 0x1f, 0x03, 0xce, 0xfd, 0x24, 0x01, 0xbb, 0x02, + 0xce, 0xfd, 0xcf, 0x9d, 0x8f, 0x02, 0x4a, 0x02, 0x47, 0x90, 0x9e, 0xfd, 0xd4, 0x00, 0x00, 0x03, 0x00, 0x4d, 0x00, + 0x00, 0x05, 0x74, 0x05, 0xb0, 0x00, 0x15, 0x00, 0x1c, 0x00, 0x23, 0x00, 0x6e, 0xb2, 0x0a, 0x24, 0x25, 0x11, 0x12, + 0x39, 0xb0, 0x0a, 0x10, 0xb0, 0x19, 0xd0, 0xb0, 0x0a, 0x10, 0xb0, 0x20, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x14, 0x2f, 0x1b, 0xb1, 0x14, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x12, + 0x3e, 0x59, 0xb2, 0x13, 0x14, 0x09, 0x11, 0x12, 0x39, 0xb0, 0x13, 0x2f, 0xb0, 0x00, 0xd0, 0xb2, 0x08, 0x09, 0x14, + 0x11, 0x12, 0x39, 0xb0, 0x08, 0x2f, 0xb0, 0x0b, 0xd0, 0xb0, 0x08, 0x10, 0xb1, 0x21, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x19, 0xd0, 0xb0, 0x13, 0x10, 0xb1, 0x1a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x20, 0xd0, 0x30, 0x31, 0x01, 0x16, 0x04, 0x16, 0x15, 0x14, 0x06, 0x06, 0x07, 0x15, + 0x23, 0x35, 0x26, 0x00, 0x35, 0x34, 0x36, 0x37, 0x36, 0x37, 0x35, 0x33, 0x01, 0x14, 0x16, 0x17, 0x11, 0x06, 0x06, + 0x05, 0x34, 0x26, 0x27, 0x11, 0x36, 0x36, 0x03, 0x42, 0xa1, 0x01, 0x01, 0x90, 0x8f, 0xff, 0xa4, 0xc2, 0xfb, 0xfe, + 0xc8, 0x7d, 0x74, 0x8b, 0xb7, 0xc2, 0xfd, 0xca, 0xc2, 0xb2, 0xb4, 0xc0, 0x03, 0xa9, 0xc1, 0xb2, 0xb4, 0xbf, 0x04, + 0xf7, 0x03, 0x8a, 0xfa, 0x9c, 0x9e, 0xfa, 0x89, 0x04, 0xaf, 0xaf, 0x04, 0x01, 0x2f, 0xf0, 0x94, 0xee, 0x49, 0x57, + 0x03, 0xb9, 0xfd, 0x22, 0xb8, 0xc8, 0x04, 0x03, 0x09, 0x04, 0xca, 0xb5, 0xb5, 0xca, 0x04, 0xfc, 0xf7, 0x04, 0xcb, + 0x00, 0x00, 0x01, 0x00, 0x5a, 0x00, 0x00, 0x05, 0x21, 0x05, 0xb0, 0x00, 0x18, 0x00, 0x5d, 0xb2, 0x00, 0x19, 0x1a, + 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1e, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x11, 0x2f, 0x1b, 0xb1, 0x11, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x17, 0x2f, 0x1b, + 0xb1, 0x17, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x12, 0x3e, 0x59, 0xb2, + 0x16, 0x04, 0x0b, 0x11, 0x12, 0x39, 0xb0, 0x16, 0x2f, 0xb0, 0x00, 0xd0, 0xb0, 0x16, 0x10, 0xb1, 0x0d, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0a, 0xd0, 0x30, 0x31, 0x01, 0x36, 0x36, 0x35, 0x11, 0x33, + 0x11, 0x14, 0x06, 0x06, 0x07, 0x11, 0x23, 0x11, 0x26, 0x00, 0x27, 0x11, 0x33, 0x11, 0x16, 0x16, 0x17, 0x11, 0x33, + 0x03, 0x16, 0x9c, 0xae, 0xc1, 0x7f, 0xed, 0x9f, 0xc1, 0xe7, 0xfe, 0xef, 0x03, 0xc0, 0x01, 0xa5, 0x95, 0xc1, 0x02, + 0x0b, 0x17, 0xd7, 0xaa, 0x02, 0x0d, 0xfd, 0xf0, 0x9f, 0xf5, 0x93, 0x0f, 0xfe, 0x96, 0x01, 0x6a, 0x17, 0x01, 0x2a, + 0xed, 0x02, 0x18, 0xfd, 0xef, 0xa3, 0xd7, 0x19, 0x03, 0xa4, 0x00, 0x01, 0x00, 0x71, 0x00, 0x00, 0x04, 0xcb, 0x05, + 0xc4, 0x00, 0x24, 0x00, 0x5e, 0xb2, 0x19, 0x25, 0x26, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x19, + 0x2f, 0x1b, 0xb1, 0x19, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0e, 0x2f, 0x1b, 0xb1, 0x0e, 0x12, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x23, 0x2f, 0x1b, 0xb1, 0x23, 0x12, 0x3e, 0x59, 0xb0, 0x0e, 0x10, 0xb1, 0x10, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0d, 0xd0, 0xb0, 0x00, 0xd0, 0xb0, 0x19, 0x10, + 0xb1, 0x06, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x10, 0x10, 0xb0, 0x21, 0xd0, 0xb0, + 0x22, 0xd0, 0x30, 0x31, 0x25, 0x36, 0x12, 0x37, 0x35, 0x34, 0x26, 0x20, 0x06, 0x15, 0x15, 0x14, 0x12, 0x17, 0x15, + 0x21, 0x35, 0x33, 0x26, 0x02, 0x35, 0x35, 0x34, 0x12, 0x36, 0x33, 0x32, 0x16, 0x12, 0x17, 0x15, 0x14, 0x02, 0x07, + 0x33, 0x15, 0x21, 0x02, 0xe1, 0x8a, 0x9a, 0x03, 0xc2, 0xfe, 0xae, 0xc0, 0x9d, 0x91, 0xfe, 0x14, 0xdd, 0x6a, 0x78, + 0x8d, 0xfe, 0xa1, 0xa0, 0xfd, 0x8e, 0x03, 0x78, 0x6a, 0xdc, 0xfe, 0x1c, 0xa2, 0x1b, 0x01, 0x1c, 0xea, 0x86, 0xe7, + 0xf6, 0xfa, 0xe5, 0x71, 0xf0, 0xfe, 0xd8, 0x1c, 0xa2, 0x9d, 0x66, 0x01, 0x33, 0xa2, 0x6f, 0xba, 0x01, 0x24, 0x9f, + 0x9c, 0xfe, 0xe4, 0xb4, 0x82, 0xa0, 0xfe, 0xcd, 0x66, 0x9d, 0x00, 0x00, 0x02, 0x00, 0x64, 0xff, 0xeb, 0x04, 0x77, + 0x04, 0x4e, 0x00, 0x16, 0x00, 0x21, 0x00, 0x7f, 0xb2, 0x1f, 0x22, 0x23, 0x11, 0x12, 0x39, 0xb0, 0x1f, 0x10, 0xb0, + 0x13, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x13, 0x2f, 0x1b, 0xb1, 0x13, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x16, 0x2f, 0x1b, 0xb1, 0x16, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, + 0x08, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x12, 0x3e, 0x59, 0xb0, 0x08, + 0x10, 0xb1, 0x03, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x0a, 0x13, 0x08, 0x11, 0x12, + 0x39, 0xb2, 0x15, 0x13, 0x08, 0x11, 0x12, 0x39, 0xb0, 0x0c, 0x10, 0xb1, 0x1a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x13, 0x10, 0xb1, 0x1f, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0x30, 0x31, 0x01, 0x11, 0x16, 0x33, 0x32, 0x37, 0x17, 0x06, 0x23, 0x22, 0x27, 0x06, 0x23, 0x22, 0x02, 0x35, 0x35, + 0x10, 0x12, 0x33, 0x32, 0x17, 0x37, 0x01, 0x14, 0x16, 0x33, 0x32, 0x37, 0x11, 0x26, 0x23, 0x22, 0x06, 0x03, 0xee, + 0x02, 0x4e, 0x13, 0x0f, 0x17, 0x30, 0x4a, 0x93, 0x26, 0x6b, 0xd1, 0xc0, 0xe4, 0xe2, 0xc4, 0xcb, 0x6b, 0x11, 0xfd, + 0xcc, 0x92, 0x87, 0xad, 0x52, 0x55, 0xa8, 0x86, 0x95, 0x04, 0x3a, 0xfc, 0xe3, 0x8c, 0x05, 0x89, 0x22, 0xa5, 0xa5, + 0x01, 0x1b, 0xf4, 0x0f, 0x01, 0x08, 0x01, 0x3d, 0xa1, 0x8d, 0xfd, 0xba, 0xaf, 0xc3, 0xba, 0x01, 0xbe, 0xbc, 0xe3, + 0x00, 0x02, 0x00, 0xa0, 0xfe, 0x80, 0x04, 0x4d, 0x05, 0xc4, 0x00, 0x14, 0x00, 0x2a, 0x00, 0x6c, 0xb2, 0x00, 0x2b, + 0x2c, 0x11, 0x12, 0x39, 0xb0, 0x18, 0xd0, 0x00, 0xb0, 0x0f, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, + 0xb1, 0x00, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x12, 0x3e, 0x59, 0xb2, + 0x28, 0x00, 0x0c, 0x11, 0x12, 0x39, 0xb0, 0x28, 0x2f, 0xb1, 0x25, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb2, 0x06, 0x25, 0x28, 0x11, 0x12, 0x39, 0xb2, 0x0e, 0x0c, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x00, 0x10, + 0xb1, 0x18, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0c, 0x10, 0xb1, 0x1f, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x32, 0x16, 0x15, 0x14, 0x06, 0x07, 0x16, 0x16, + 0x15, 0x14, 0x06, 0x23, 0x22, 0x27, 0x11, 0x23, 0x11, 0x34, 0x36, 0x36, 0x01, 0x34, 0x26, 0x23, 0x22, 0x06, 0x07, + 0x11, 0x16, 0x16, 0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x27, 0x23, 0x35, 0x33, 0x32, 0x36, 0x02, 0x5d, 0xc1, 0xeb, + 0x62, 0x58, 0x7b, 0x83, 0xf9, 0xcd, 0xb5, 0x78, 0xba, 0x7a, 0xcf, 0x01, 0x67, 0x88, 0x6b, 0x6c, 0x96, 0x01, 0x2c, + 0x90, 0x5e, 0x86, 0x9a, 0x8c, 0x6d, 0x96, 0x55, 0x78, 0x7e, 0x05, 0xc4, 0xdb, 0xae, 0x5b, 0x98, 0x2e, 0x2d, 0xc3, + 0x82, 0xcd, 0xef, 0x5f, 0xfe, 0x35, 0x05, 0xb1, 0x6c, 0xbc, 0x6b, 0xfe, 0x7b, 0x66, 0x87, 0x8e, 0x6b, 0xfc, 0xc3, + 0x34, 0x3f, 0xa0, 0x81, 0x76, 0xa5, 0x03, 0x98, 0x77, 0x00, 0x00, 0x01, 0x00, 0x2e, 0xfe, 0x60, 0x03, 0xdf, 0x04, + 0x3a, 0x00, 0x08, 0x00, 0x38, 0xb2, 0x00, 0x09, 0x0a, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, + 0x2f, 0x1b, 0xb1, 0x01, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1a, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x14, 0x3e, 0x59, 0xb2, 0x00, 0x07, 0x04, 0x11, + 0x12, 0x39, 0x30, 0x31, 0x01, 0x01, 0x33, 0x01, 0x11, 0x23, 0x11, 0x01, 0x33, 0x02, 0x0a, 0x01, 0x18, 0xbd, 0xfe, + 0x85, 0xba, 0xfe, 0x84, 0xbd, 0x01, 0x14, 0x03, 0x26, 0xfb, 0xff, 0xfe, 0x27, 0x01, 0xe0, 0x03, 0xfa, 0x00, 0x02, + 0x00, 0x60, 0xff, 0xec, 0x04, 0x27, 0x06, 0x1c, 0x00, 0x1e, 0x00, 0x2a, 0x00, 0x61, 0xb2, 0x14, 0x2b, 0x2c, 0x11, + 0x12, 0x39, 0xb0, 0x14, 0x10, 0xb0, 0x22, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, + 0x20, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x14, 0x2f, 0x1b, 0xb1, 0x14, 0x12, 0x3e, 0x59, 0xb0, 0x03, 0x10, + 0xb1, 0x08, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x1b, 0x14, 0x03, 0x11, 0x12, 0x39, + 0xb0, 0x1b, 0x2f, 0xb1, 0x28, 0x0b, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0c, 0xd0, 0xb0, + 0x14, 0x10, 0xb1, 0x22, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x13, 0x34, 0x36, + 0x33, 0x32, 0x17, 0x07, 0x26, 0x23, 0x22, 0x06, 0x15, 0x14, 0x04, 0x12, 0x17, 0x15, 0x14, 0x06, 0x06, 0x23, 0x22, + 0x00, 0x35, 0x35, 0x34, 0x12, 0x37, 0x27, 0x26, 0x26, 0x13, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x27, + 0x22, 0x06, 0xdd, 0xcb, 0xaf, 0x8b, 0x86, 0x02, 0x97, 0x7c, 0x56, 0x65, 0x01, 0xbb, 0xcf, 0x05, 0x76, 0xdb, 0x91, + 0xde, 0xfe, 0xf9, 0xbc, 0x90, 0x01, 0x63, 0x6b, 0x3e, 0xa1, 0x89, 0x88, 0xa0, 0xa9, 0x7d, 0x88, 0xa4, 0x04, 0xf5, + 0x88, 0x9f, 0x37, 0xa0, 0x3b, 0x48, 0x3e, 0x6c, 0x99, 0xfe, 0xf3, 0xc4, 0x27, 0x99, 0xf3, 0x85, 0x01, 0x27, 0xf2, + 0x0d, 0xa5, 0x01, 0x08, 0x23, 0x05, 0x27, 0x8c, 0xfd, 0x63, 0xb0, 0xcb, 0xca, 0xc6, 0x88, 0xdb, 0x19, 0xcd, 0x00, + 0x00, 0x01, 0x00, 0x63, 0xff, 0xec, 0x03, 0xec, 0x04, 0x4d, 0x00, 0x25, 0x00, 0x72, 0xb2, 0x03, 0x26, 0x27, 0x11, + 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x15, 0x2f, 0x1b, 0xb1, 0x15, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x12, 0x3e, 0x59, 0xb1, 0x03, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x0a, 0x10, 0xb0, 0x06, 0xd0, 0xb0, 0x0a, 0x10, 0xb0, 0x22, 0xd0, 0xb0, 0x22, 0x2f, 0xb2, + 0x2f, 0x22, 0x01, 0x5d, 0xb2, 0xbf, 0x22, 0x01, 0x5d, 0xb1, 0x23, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb2, 0x0f, 0x23, 0x22, 0x11, 0x12, 0x39, 0xb2, 0x19, 0x15, 0x22, 0x11, 0x12, 0x39, 0xb0, 0x15, 0x10, + 0xb1, 0x1c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x14, 0x16, 0x33, 0x32, + 0x36, 0x35, 0x33, 0x14, 0x06, 0x23, 0x22, 0x26, 0x35, 0x34, 0x37, 0x26, 0x26, 0x35, 0x34, 0x36, 0x33, 0x32, 0x16, + 0x15, 0x23, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x14, 0x33, 0x33, 0x15, 0x23, 0x06, 0x01, 0x1e, 0x93, 0x76, 0x71, + 0x9b, 0xb9, 0xff, 0xc6, 0xcc, 0xf8, 0xcd, 0x58, 0x62, 0xe7, 0xca, 0xba, 0xf9, 0xb9, 0x8f, 0x6b, 0x70, 0x87, 0xf4, + 0xc4, 0xe0, 0xea, 0x01, 0x30, 0x4d, 0x62, 0x6e, 0x51, 0x9b, 0xb9, 0xb1, 0x93, 0xba, 0x42, 0x24, 0x7a, 0x49, 0x94, + 0xa6, 0xb3, 0x8e, 0x46, 0x65, 0x5b, 0x4a, 0xa0, 0x94, 0x06, 0x00, 0x00, 0x01, 0x00, 0x6d, 0xfe, 0x81, 0x03, 0xc3, + 0x05, 0xb0, 0x00, 0x1f, 0x00, 0x4d, 0xb2, 0x08, 0x20, 0x21, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x0f, 0x2f, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1e, 0x3e, 0x59, 0xb1, 0x1d, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x01, 0xd0, 0xb2, 0x15, 0x20, 0x00, 0x11, 0x12, 0x39, 0xb2, 0x02, 0x15, 0x00, 0x11, + 0x12, 0x39, 0xb0, 0x15, 0x10, 0xb1, 0x07, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x1c, + 0x00, 0x15, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x15, 0x01, 0x06, 0x06, 0x15, 0x14, 0x16, 0x17, 0x17, 0x16, 0x16, + 0x15, 0x06, 0x06, 0x07, 0x27, 0x36, 0x36, 0x35, 0x34, 0x24, 0x27, 0x26, 0x26, 0x35, 0x34, 0x12, 0x37, 0x01, 0x21, + 0x35, 0x03, 0xc3, 0xfe, 0xa2, 0x8a, 0x66, 0x43, 0x52, 0xf7, 0x51, 0x47, 0x02, 0x6c, 0x43, 0x62, 0x2f, 0x33, 0xfe, + 0xcc, 0x36, 0x67, 0x5b, 0x92, 0x7f, 0x01, 0x1d, 0xfd, 0x83, 0x05, 0xb0, 0x78, 0xfe, 0x55, 0xa1, 0xe5, 0x85, 0x5a, + 0x61, 0x19, 0x48, 0x18, 0x58, 0x4e, 0x45, 0xac, 0x36, 0x54, 0x35, 0x55, 0x2d, 0x44, 0x4e, 0x18, 0x2d, 0x99, 0x81, + 0x82, 0x01, 0x40, 0x96, 0x01, 0x43, 0x98, 0x00, 0x01, 0x00, 0x91, 0xfe, 0x61, 0x03, 0xf0, 0x04, 0x4e, 0x00, 0x12, + 0x00, 0x54, 0xb2, 0x0c, 0x13, 0x14, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, + 0x03, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1a, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x14, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, + 0xb1, 0x10, 0x12, 0x3e, 0x59, 0xb2, 0x01, 0x10, 0x03, 0x11, 0x12, 0x39, 0xb0, 0x03, 0x10, 0xb1, 0x0c, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x17, 0x36, 0x33, 0x32, 0x16, 0x17, 0x11, 0x23, + 0x11, 0x34, 0x26, 0x23, 0x22, 0x06, 0x07, 0x11, 0x23, 0x11, 0x01, 0x38, 0x0b, 0x78, 0xc8, 0xbe, 0xae, 0x01, 0xb9, + 0x6c, 0x80, 0x5c, 0x82, 0x22, 0xba, 0x04, 0x3a, 0x88, 0x9c, 0xc5, 0xcc, 0xfb, 0xa4, 0x04, 0x51, 0x88, 0x7c, 0x57, + 0x4e, 0xfc, 0xef, 0x04, 0x3a, 0x00, 0x03, 0x00, 0x7a, 0xff, 0xec, 0x04, 0x12, 0x05, 0xc4, 0x00, 0x0d, 0x00, 0x16, + 0x00, 0x1e, 0x00, 0x95, 0xb2, 0x03, 0x1f, 0x20, 0x11, 0x12, 0x39, 0xb0, 0x03, 0x10, 0xb0, 0x13, 0xd0, 0xb0, 0x03, + 0x10, 0xb0, 0x1b, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1e, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x12, 0x3e, 0x59, 0xb2, 0x0e, 0x03, 0x0a, 0x11, 0x12, 0x39, + 0xb0, 0x0e, 0x2f, 0xb2, 0x5f, 0x0e, 0x01, 0x5d, 0xb2, 0xff, 0x0e, 0x01, 0x5d, 0xb4, 0x8f, 0x0e, 0x9f, 0x0e, 0x02, + 0x71, 0xb4, 0xbf, 0x0e, 0xcf, 0x0e, 0x02, 0x71, 0xb2, 0x2f, 0x0e, 0x01, 0x71, 0xb2, 0xcf, 0x0e, 0x01, 0x5d, 0xb2, + 0x2f, 0x0e, 0x01, 0x5d, 0xb4, 0xef, 0x0e, 0xff, 0x0e, 0x02, 0x71, 0xb0, 0x0a, 0x10, 0xb1, 0x13, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0e, 0x10, 0xb1, 0x18, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x1b, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, + 0x31, 0x01, 0x10, 0x02, 0x23, 0x22, 0x02, 0x03, 0x35, 0x10, 0x12, 0x33, 0x32, 0x12, 0x13, 0x05, 0x21, 0x35, 0x34, + 0x26, 0x23, 0x22, 0x06, 0x15, 0x05, 0x21, 0x15, 0x14, 0x16, 0x20, 0x36, 0x37, 0x04, 0x12, 0xec, 0xdf, 0xdb, 0xee, + 0x04, 0xec, 0xdf, 0xde, 0xeb, 0x04, 0xfd, 0x21, 0x02, 0x25, 0x8b, 0x88, 0x86, 0x8c, 0x02, 0x25, 0xfd, 0xdb, 0x92, + 0x01, 0x04, 0x8d, 0x02, 0x02, 0x80, 0xfe, 0xbf, 0xfe, 0xad, 0x01, 0x4c, 0x01, 0x34, 0xcd, 0x01, 0x3d, 0x01, 0x4e, + 0xfe, 0xbc, 0xfe, 0xcd, 0x2c, 0x37, 0xe3, 0xf1, 0xf1, 0xe3, 0xcf, 0x27, 0xe5, 0xfa, 0xf0, 0xe3, 0x00, 0x01, 0x00, + 0xc3, 0xff, 0xf4, 0x02, 0x4b, 0x04, 0x3a, 0x00, 0x0c, 0x00, 0x29, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, + 0x1b, 0xb1, 0x00, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x12, 0x3e, 0x59, + 0xb1, 0x04, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x11, 0x14, 0x16, 0x33, + 0x32, 0x37, 0x17, 0x06, 0x23, 0x22, 0x11, 0x11, 0x01, 0x7c, 0x37, 0x40, 0x30, 0x27, 0x01, 0x46, 0x49, 0xf9, 0x04, + 0x3a, 0xfc, 0xd7, 0x3f, 0x40, 0x0c, 0x97, 0x13, 0x01, 0x26, 0x03, 0x20, 0x00, 0x00, 0x01, 0x00, 0x25, 0xff, 0xef, + 0x04, 0x3b, 0x05, 0xee, 0x00, 0x1a, 0x00, 0x52, 0xb2, 0x10, 0x1b, 0x1c, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x2f, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x11, + 0x2f, 0x1b, 0xb1, 0x11, 0x12, 0x3e, 0x59, 0xb0, 0x0b, 0x10, 0xb1, 0x07, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb2, 0x10, 0x00, 0x0b, 0x11, 0x12, 0x39, 0xb0, 0x10, 0x10, 0xb0, 0x13, 0xd0, 0xb0, 0x00, 0x10, + 0xb1, 0x17, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x32, 0x16, 0x17, 0x01, + 0x16, 0x16, 0x33, 0x37, 0x17, 0x06, 0x23, 0x22, 0x26, 0x26, 0x27, 0x03, 0x01, 0x23, 0x01, 0x27, 0x26, 0x26, 0x23, + 0x07, 0x27, 0x36, 0x01, 0x05, 0x62, 0x78, 0x21, 0x01, 0xab, 0x14, 0x2d, 0x23, 0x26, 0x06, 0x24, 0x2a, 0x4d, 0x4e, + 0x3e, 0x1d, 0xe6, 0xfe, 0xe2, 0xce, 0x01, 0x8a, 0x60, 0x17, 0x35, 0x2d, 0x2f, 0x01, 0x2a, 0x05, 0xee, 0x50, 0x5f, + 0xfb, 0xab, 0x33, 0x27, 0x03, 0x98, 0x0c, 0x25, 0x56, 0x50, 0x02, 0x51, 0xfc, 0xf5, 0x04, 0x05, 0xeb, 0x38, 0x2e, + 0x02, 0x8e, 0x0c, 0x00, 0x01, 0x00, 0x65, 0xfe, 0x77, 0x03, 0xa9, 0x05, 0xc4, 0x00, 0x2d, 0x00, 0x59, 0xb2, 0x03, + 0x2e, 0x2f, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x17, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x2b, 0x2f, 0x1b, 0xb1, 0x2b, + 0x1e, 0x3e, 0x59, 0xb1, 0x02, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x08, 0x2e, 0x2b, + 0x11, 0x12, 0x39, 0xb0, 0x08, 0x2f, 0xb1, 0x09, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, + 0x1e, 0x2e, 0x2b, 0x11, 0x12, 0x39, 0xb0, 0x1e, 0x10, 0xb1, 0x0f, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb2, 0x25, 0x09, 0x08, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x26, 0x23, 0x22, 0x06, 0x15, 0x14, 0x21, + 0x33, 0x15, 0x23, 0x06, 0x06, 0x15, 0x14, 0x16, 0x04, 0x16, 0x17, 0x16, 0x15, 0x14, 0x06, 0x07, 0x27, 0x37, 0x36, + 0x35, 0x34, 0x2e, 0x04, 0x35, 0x34, 0x36, 0x37, 0x26, 0x26, 0x35, 0x34, 0x24, 0x33, 0x32, 0x17, 0x03, 0x72, 0x84, + 0x61, 0x8d, 0xa0, 0x01, 0x4d, 0x85, 0x96, 0xb6, 0xc7, 0x90, 0x01, 0x0f, 0x7c, 0x20, 0x4f, 0x68, 0x48, 0x6b, 0x39, + 0x31, 0x4c, 0xe6, 0xa9, 0x77, 0x41, 0xa4, 0x96, 0x76, 0x83, 0x01, 0x02, 0xe4, 0x91, 0x70, 0x05, 0x08, 0x24, 0x67, + 0x55, 0xdb, 0x98, 0x02, 0x9c, 0xa3, 0x70, 0x9d, 0x41, 0x25, 0x14, 0x31, 0x69, 0x40, 0xa7, 0x3d, 0x54, 0x40, 0x3c, + 0x3e, 0x27, 0x2e, 0x33, 0x42, 0x69, 0x99, 0x6f, 0x91, 0xcb, 0x2e, 0x2a, 0x98, 0x60, 0x9f, 0xb9, 0x27, 0x00, 0x00, + 0x01, 0x00, 0x29, 0xff, 0xf4, 0x04, 0xa4, 0x04, 0x3a, 0x00, 0x14, 0x00, 0x5e, 0xb2, 0x0b, 0x15, 0x16, 0x11, 0x12, + 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x13, 0x2f, 0x1b, 0xb1, 0x13, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0f, 0x2f, 0x1b, 0xb1, 0x0f, + 0x12, 0x3e, 0x59, 0xb0, 0x13, 0x10, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x0a, 0x10, 0xb1, 0x05, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x00, 0x10, 0xb0, 0x0d, + 0xd0, 0xb0, 0x0e, 0xd0, 0xb0, 0x11, 0xd0, 0xb0, 0x12, 0xd0, 0x30, 0x31, 0x01, 0x23, 0x11, 0x14, 0x16, 0x33, 0x32, + 0x37, 0x17, 0x06, 0x23, 0x22, 0x11, 0x11, 0x21, 0x11, 0x23, 0x11, 0x23, 0x35, 0x21, 0x04, 0x71, 0x9c, 0x36, 0x41, + 0x30, 0x27, 0x01, 0x46, 0x49, 0xf9, 0xfe, 0x6f, 0xb9, 0xa9, 0x04, 0x48, 0x03, 0xa1, 0xfd, 0x72, 0x40, 0x41, 0x0c, + 0x97, 0x13, 0x01, 0x26, 0x02, 0x87, 0xfc, 0x5f, 0x03, 0xa1, 0x99, 0x00, 0x02, 0x00, 0x91, 0xfe, 0x60, 0x04, 0x1f, + 0x04, 0x4e, 0x00, 0x0f, 0x00, 0x1b, 0x00, 0x59, 0xb2, 0x12, 0x1c, 0x1d, 0x11, 0x12, 0x39, 0xb0, 0x12, 0x10, 0xb0, + 0x00, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x14, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, + 0x07, 0x12, 0x3e, 0x59, 0xb2, 0x09, 0x00, 0x07, 0x11, 0x12, 0x39, 0xb1, 0x12, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x00, 0x10, 0xb1, 0x18, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0x30, 0x31, 0x01, 0x32, 0x12, 0x17, 0x17, 0x14, 0x02, 0x23, 0x22, 0x27, 0x11, 0x23, 0x11, 0x34, 0x36, 0x36, 0x03, + 0x16, 0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x02, 0x50, 0xcf, 0xf4, 0x0b, 0x01, 0xe0, 0xbf, + 0xc3, 0x72, 0xba, 0x71, 0xcd, 0x84, 0x53, 0xab, 0x87, 0x96, 0x91, 0x85, 0x75, 0x90, 0x04, 0x4e, 0xfe, 0xe6, 0xfe, + 0x42, 0xf0, 0xfe, 0xe8, 0x7c, 0xfd, 0xf8, 0x03, 0xe4, 0x9e, 0xec, 0x80, 0xfc, 0xc8, 0x93, 0xc3, 0xc3, 0xcd, 0xe0, + 0xd8, 0xa9, 0x00, 0x00, 0x01, 0x00, 0x65, 0xfe, 0x8a, 0x03, 0xe1, 0x04, 0x4e, 0x00, 0x22, 0x00, 0x4b, 0xb2, 0x00, + 0x23, 0x24, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x14, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, + 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x1b, 0x2f, 0x1b, 0xb1, 0x1b, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x10, + 0xb0, 0x04, 0xd0, 0xb0, 0x00, 0x10, 0xb1, 0x07, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x1b, 0x10, 0xb1, 0x0d, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x32, 0x16, + 0x15, 0x23, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x15, 0x10, 0x05, 0x17, 0x16, 0x16, 0x15, 0x06, 0x06, 0x07, 0x27, + 0x37, 0x36, 0x35, 0x34, 0x26, 0x27, 0x26, 0x02, 0x35, 0x35, 0x34, 0x36, 0x36, 0x02, 0x3d, 0xbd, 0xe7, 0xaf, 0x86, + 0x6f, 0x84, 0x9b, 0x01, 0x40, 0x86, 0x62, 0x50, 0x02, 0x63, 0x4a, 0x62, 0x2f, 0x31, 0x46, 0x56, 0xec, 0xf8, 0x77, + 0xd7, 0x04, 0x4e, 0xd5, 0xb4, 0x6e, 0x83, 0xdb, 0xb3, 0x20, 0xfe, 0xfc, 0x63, 0x26, 0x1d, 0x60, 0x50, 0x3f, 0xa7, + 0x3e, 0x55, 0x36, 0x3c, 0x46, 0x2b, 0x2b, 0x13, 0x34, 0x01, 0x01, 0xd3, 0x2a, 0x98, 0xfb, 0x89, 0x00, 0x02, 0x00, + 0x60, 0xff, 0xec, 0x04, 0x7b, 0x04, 0x3a, 0x00, 0x11, 0x00, 0x1d, 0x00, 0x4e, 0xb2, 0x08, 0x1e, 0x1f, 0x11, 0x12, + 0x39, 0xb0, 0x08, 0x10, 0xb0, 0x15, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x1a, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x12, 0x3e, 0x59, 0xb0, 0x10, 0x10, 0xb1, + 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, 0x10, 0xb1, 0x15, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x00, 0x10, 0xb0, 0x1b, 0xd0, 0x30, 0x31, 0x01, 0x21, 0x16, 0x11, + 0x15, 0x14, 0x06, 0x06, 0x23, 0x22, 0x00, 0x35, 0x35, 0x34, 0x36, 0x36, 0x37, 0x21, 0x01, 0x14, 0x16, 0x33, 0x32, + 0x36, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x04, 0x7b, 0xfe, 0xe4, 0xc8, 0x7a, 0xdd, 0x8c, 0xda, 0xfe, 0xf6, 0x76, + 0xd9, 0x8c, 0x02, 0x40, 0xfc, 0x9f, 0xa0, 0x8a, 0x8b, 0x9f, 0xa1, 0x8b, 0x89, 0x9f, 0x03, 0xa1, 0x94, 0xfe, 0xef, + 0x11, 0x8c, 0xeb, 0x88, 0x01, 0x2f, 0xff, 0x0d, 0x98, 0xf2, 0x88, 0x01, 0xfd, 0xd7, 0xb7, 0xd7, 0xd9, 0xcb, 0xac, + 0xce, 0xcc, 0x00, 0x01, 0x00, 0x51, 0xff, 0xec, 0x03, 0xd9, 0x04, 0x3a, 0x00, 0x10, 0x00, 0x4b, 0xb2, 0x0a, 0x11, + 0x12, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0f, 0x2f, 0x1b, 0xb1, 0x0f, 0x1a, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x12, 0x3e, 0x59, 0xb0, 0x0f, 0x10, 0xb1, 0x00, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x09, 0x10, 0xb1, 0x04, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x00, 0x10, 0xb0, 0x0d, 0xd0, 0xb0, 0x0e, 0xd0, 0x30, 0x31, 0x01, 0x21, 0x11, 0x14, + 0x33, 0x32, 0x37, 0x17, 0x06, 0x23, 0x22, 0x26, 0x27, 0x11, 0x21, 0x35, 0x21, 0x03, 0xd9, 0xfe, 0x8d, 0x69, 0x2b, + 0x31, 0x2a, 0x4c, 0x6a, 0x7d, 0x75, 0x01, 0xfe, 0xa5, 0x03, 0x88, 0x03, 0xa4, 0xfd, 0x69, 0x85, 0x1a, 0x82, 0x34, + 0x93, 0x92, 0x02, 0x93, 0x96, 0x00, 0x01, 0x00, 0x8f, 0xff, 0xec, 0x03, 0xf6, 0x04, 0x3a, 0x00, 0x12, 0x00, 0x3d, + 0xb2, 0x0e, 0x13, 0x14, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1a, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x0e, 0x2f, 0x1b, 0xb1, 0x0e, 0x12, 0x3e, 0x59, 0xb1, 0x03, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0x30, 0x31, 0x01, 0x11, 0x10, 0x33, 0x32, 0x36, 0x35, 0x26, 0x03, 0x33, 0x16, 0x11, 0x10, 0x00, 0x23, + 0x22, 0x26, 0x27, 0x11, 0x01, 0x49, 0xc9, 0x81, 0xaa, 0x05, 0x76, 0xc3, 0x71, 0xfe, 0xff, 0xda, 0xc2, 0xc8, 0x02, + 0x04, 0x3a, 0xfd, 0x79, 0xfe, 0xcf, 0xfa, 0xb6, 0xe7, 0x01, 0x21, 0xf1, 0xfe, 0xe9, 0xfe, 0xf9, 0xfe, 0xc1, 0xe0, + 0xd7, 0x02, 0x97, 0x00, 0x00, 0x02, 0x00, 0x57, 0xfe, 0x22, 0x05, 0x4c, 0x04, 0x3a, 0x00, 0x19, 0x00, 0x22, 0x00, + 0x5e, 0xb2, 0x0f, 0x23, 0x24, 0x11, 0x12, 0x39, 0xb0, 0x0f, 0x10, 0xb0, 0x1a, 0xd0, 0x00, 0xb0, 0x18, 0x2f, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, + 0x1b, 0xb1, 0x10, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x17, 0x2f, 0x1b, 0xb1, 0x17, 0x12, 0x3e, 0x59, + 0xb0, 0x00, 0xd0, 0xb0, 0x17, 0x10, 0xb1, 0x1a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x0c, 0xd0, 0xb0, 0x10, 0x10, 0xb1, 0x20, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, + 0x05, 0x24, 0x00, 0x35, 0x34, 0x12, 0x37, 0x17, 0x06, 0x07, 0x14, 0x16, 0x17, 0x11, 0x34, 0x36, 0x33, 0x32, 0x16, + 0x16, 0x15, 0x14, 0x00, 0x05, 0x11, 0x23, 0x13, 0x36, 0x36, 0x35, 0x26, 0x26, 0x23, 0x22, 0x15, 0x02, 0x6c, 0xff, + 0x00, 0xfe, 0xeb, 0x81, 0x7f, 0x65, 0xa1, 0x0a, 0xb5, 0xa6, 0x8a, 0x71, 0x82, 0xe1, 0x82, 0xfe, 0xde, 0xfe, 0xfb, + 0xb9, 0xb9, 0xaa, 0xc4, 0x05, 0xa5, 0x82, 0x42, 0x11, 0x17, 0x01, 0x33, 0xfb, 0xa8, 0x01, 0x07, 0x57, 0x85, 0x8c, + 0xf5, 0xad, 0xe5, 0x1a, 0x02, 0xcc, 0x69, 0x7d, 0x8d, 0xf8, 0x95, 0xf3, 0xfe, 0xd7, 0x15, 0xfe, 0x33, 0x02, 0x66, + 0x16, 0xde, 0xa4, 0xa9, 0xd8, 0x52, 0x00, 0x00, 0x01, 0x00, 0x5f, 0xfe, 0x28, 0x05, 0x43, 0x04, 0x3a, 0x00, 0x19, + 0x00, 0x59, 0xb2, 0x00, 0x1a, 0x1b, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x0d, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, + 0x2f, 0x1b, 0xb1, 0x00, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1a, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x13, 0x2f, 0x1b, 0xb1, 0x13, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x12, 0x3e, 0x59, 0xb1, 0x01, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb0, 0x0c, 0x10, 0xb0, 0x0f, 0xd0, 0xb0, 0x01, 0x10, 0xb0, 0x18, 0xd0, 0x30, 0x31, 0x01, 0x11, 0x36, 0x36, + 0x35, 0x26, 0x03, 0x33, 0x16, 0x11, 0x10, 0x00, 0x05, 0x11, 0x23, 0x11, 0x26, 0x00, 0x11, 0x11, 0x33, 0x11, 0x16, + 0x16, 0x17, 0x11, 0x03, 0x1c, 0xab, 0xc3, 0x05, 0x7a, 0xc2, 0x76, 0xfe, 0xe3, 0xfe, 0xf6, 0xb9, 0xff, 0xfe, 0xfb, + 0xba, 0x02, 0xa6, 0xa2, 0x04, 0x3a, 0xfc, 0x4e, 0x18, 0xe5, 0xb2, 0xe8, 0x01, 0x1b, 0xec, 0xfe, 0xe9, 0xfe, 0xfd, + 0xfe, 0xd0, 0x15, 0xfe, 0x39, 0x01, 0xc9, 0x1a, 0x01, 0x36, 0x01, 0x13, 0x01, 0xe6, 0xfe, 0x0e, 0xc2, 0xe4, 0x19, + 0x03, 0xb1, 0x00, 0x00, 0x01, 0x00, 0x7a, 0xff, 0xec, 0x06, 0x19, 0x04, 0x3a, 0x00, 0x23, 0x00, 0x5b, 0xb2, 0x1b, + 0x24, 0x25, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1a, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x13, 0x2f, 0x1b, 0xb1, 0x13, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x19, + 0x2f, 0x1b, 0xb1, 0x19, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x1e, 0x2f, 0x1b, 0xb1, 0x1e, 0x12, 0x3e, + 0x59, 0xb1, 0x05, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x09, 0x00, 0x1e, 0x11, 0x12, + 0x39, 0xb0, 0x0e, 0xd0, 0xb2, 0x1b, 0x13, 0x19, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x02, 0x07, 0x14, 0x16, 0x33, + 0x32, 0x36, 0x35, 0x11, 0x33, 0x11, 0x16, 0x16, 0x33, 0x32, 0x36, 0x35, 0x26, 0x03, 0x33, 0x16, 0x11, 0x10, 0x02, + 0x23, 0x22, 0x27, 0x06, 0x06, 0x23, 0x22, 0x02, 0x11, 0x10, 0x37, 0x01, 0xc4, 0x8a, 0x07, 0x72, 0x6a, 0x6c, 0x71, + 0xbb, 0x01, 0x71, 0x6b, 0x6a, 0x72, 0x07, 0x8a, 0xc3, 0x87, 0xcf, 0xbc, 0xf0, 0x55, 0x29, 0xa4, 0x77, 0xbc, 0xcf, + 0x87, 0x04, 0x3a, 0xfe, 0xe5, 0xef, 0xcb, 0xe3, 0xad, 0xa6, 0x01, 0x2d, 0xfe, 0xce, 0xa4, 0xaa, 0xe2, 0xcc, 0xef, + 0x01, 0x1b, 0xf4, 0xfe, 0xea, 0xfe, 0xed, 0xfe, 0xcf, 0xee, 0x75, 0x79, 0x01, 0x31, 0x01, 0x13, 0x01, 0x1f, 0xeb, + 0x00, 0x02, 0x00, 0x79, 0xff, 0xec, 0x04, 0x79, 0x05, 0xc6, 0x00, 0x1f, 0x00, 0x28, 0x00, 0x71, 0xb2, 0x14, 0x29, + 0x2a, 0x11, 0x12, 0x39, 0xb0, 0x14, 0x10, 0xb0, 0x26, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x19, 0x2f, 0x1b, + 0xb1, 0x19, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x12, 0x3e, 0x59, 0xb2, + 0x1d, 0x19, 0x06, 0x11, 0x12, 0x39, 0xb0, 0x1d, 0x2f, 0xb1, 0x02, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb2, 0x0b, 0x19, 0x06, 0x11, 0x12, 0x39, 0xb0, 0x06, 0x10, 0xb1, 0x0f, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x02, 0x10, 0xb0, 0x13, 0xd0, 0xb0, 0x1d, 0x10, 0xb0, 0x23, 0xd0, 0xb0, 0x19, + 0x10, 0xb1, 0x26, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x06, 0x07, 0x15, + 0x06, 0x06, 0x23, 0x22, 0x26, 0x35, 0x11, 0x37, 0x11, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x35, 0x26, 0x00, 0x35, + 0x34, 0x36, 0x33, 0x32, 0x16, 0x15, 0x11, 0x36, 0x37, 0x01, 0x14, 0x16, 0x17, 0x11, 0x26, 0x23, 0x22, 0x15, 0x04, + 0x79, 0x3c, 0x53, 0x02, 0xe5, 0xc8, 0xcb, 0xf7, 0xba, 0x8c, 0x7c, 0x74, 0x82, 0xd9, 0xfe, 0xf3, 0xb8, 0x96, 0x9f, + 0xb2, 0x3f, 0x48, 0xfd, 0x94, 0xa2, 0x8a, 0x05, 0x93, 0x94, 0x02, 0x73, 0x17, 0x09, 0xa6, 0xd3, 0xee, 0xf7, 0xd7, + 0x01, 0x47, 0x02, 0xfe, 0xb0, 0x8f, 0x9b, 0x92, 0x98, 0xa6, 0x1f, 0x01, 0x1a, 0xd9, 0xa0, 0xbb, 0xc5, 0xb2, 0xfe, + 0xa1, 0x05, 0x13, 0x01, 0x52, 0x85, 0xbd, 0x1e, 0x01, 0x68, 0xc6, 0xc4, 0x00, 0x01, 0xff, 0xda, 0x00, 0x00, 0x04, + 0x6e, 0x05, 0xbc, 0x00, 0x1a, 0x00, 0x4a, 0xb2, 0x00, 0x1b, 0x1c, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x17, 0x2f, 0x1b, 0xb1, 0x17, + 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x12, 0x3e, 0x59, 0xb2, 0x00, 0x04, + 0x0d, 0x11, 0x12, 0x39, 0xb0, 0x04, 0x10, 0xb1, 0x09, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb0, 0x12, 0xd0, 0x30, 0x31, 0x01, 0x13, 0x36, 0x36, 0x33, 0x32, 0x17, 0x07, 0x26, 0x23, 0x22, 0x07, 0x01, 0x11, + 0x23, 0x11, 0x01, 0x26, 0x23, 0x22, 0x07, 0x27, 0x36, 0x33, 0x32, 0x16, 0x17, 0x02, 0x24, 0xe1, 0x2b, 0x6b, 0x57, + 0x48, 0x34, 0x24, 0x0d, 0x27, 0x46, 0x24, 0xfe, 0xd7, 0xbf, 0xfe, 0xd8, 0x27, 0x43, 0x27, 0x0d, 0x24, 0x34, 0x47, + 0x58, 0x6b, 0x2a, 0x03, 0x06, 0x01, 0xfb, 0x63, 0x58, 0x1b, 0x97, 0x08, 0x4f, 0xfd, 0x77, 0xfd, 0xc6, 0x02, 0x3c, + 0x02, 0x87, 0x4f, 0x08, 0x96, 0x1c, 0x54, 0x5d, 0x00, 0x00, 0x02, 0x00, 0x4a, 0xff, 0xec, 0x06, 0x1b, 0x04, 0x3a, + 0x00, 0x12, 0x00, 0x26, 0x00, 0x72, 0xb2, 0x08, 0x27, 0x28, 0x11, 0x12, 0x39, 0xb0, 0x08, 0x10, 0xb0, 0x1e, 0xd0, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x11, 0x2f, 0x1b, 0xb1, 0x11, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x12, + 0x3e, 0x59, 0xb0, 0x11, 0x10, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x08, + 0x11, 0x06, 0x11, 0x12, 0x39, 0xb0, 0x0f, 0xd0, 0xb0, 0x10, 0xd0, 0xb0, 0x15, 0xd0, 0xb0, 0x16, 0xd0, 0xb0, 0x0a, + 0x10, 0xb1, 0x1b, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x1f, 0x0a, 0x11, 0x11, 0x12, + 0x39, 0xb0, 0x24, 0xd0, 0x30, 0x31, 0x01, 0x23, 0x16, 0x15, 0x10, 0x02, 0x23, 0x22, 0x27, 0x06, 0x23, 0x22, 0x02, + 0x11, 0x34, 0x37, 0x23, 0x35, 0x21, 0x01, 0x26, 0x27, 0x21, 0x06, 0x07, 0x14, 0x16, 0x33, 0x32, 0x36, 0x37, 0x11, + 0x33, 0x11, 0x16, 0x16, 0x33, 0x32, 0x36, 0x06, 0x1b, 0x88, 0x40, 0xbc, 0xab, 0xf1, 0x53, 0x53, 0xf0, 0xaa, 0xbd, + 0x40, 0x74, 0x05, 0xd1, 0xfe, 0xfe, 0x04, 0x4a, 0xfc, 0xbb, 0x4b, 0x04, 0x60, 0x58, 0x69, 0x71, 0x02, 0xbb, 0x02, + 0x71, 0x6a, 0x56, 0x60, 0x03, 0xa1, 0xac, 0xc5, 0xfe, 0xef, 0xfe, 0xcd, 0xef, 0xef, 0x01, 0x30, 0x01, 0x14, 0xbf, + 0xb2, 0x99, 0xfd, 0xf6, 0xaa, 0xc7, 0xc8, 0xa9, 0xcb, 0xe3, 0xa7, 0xa2, 0x01, 0x07, 0xfe, 0xf9, 0xa2, 0xa7, 0xe2, + 0x00, 0x01, 0x00, 0x2a, 0xff, 0xf5, 0x05, 0xb1, 0x05, 0xb0, 0x00, 0x18, 0x00, 0x64, 0xb2, 0x11, 0x19, 0x1a, 0x11, + 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x17, 0x2f, 0x1b, 0xb1, 0x17, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x12, 0x3e, 0x59, 0xb0, 0x17, 0x10, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x04, 0x17, 0x09, 0x11, 0x12, 0x39, 0xb0, 0x04, 0x2f, 0xb0, 0x09, 0x10, + 0xb1, 0x0a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0x10, 0xb1, 0x10, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x00, 0x10, 0xb0, 0x15, 0xd0, 0xb0, 0x16, 0xd0, 0x30, 0x31, + 0x01, 0x21, 0x11, 0x36, 0x33, 0x32, 0x04, 0x10, 0x04, 0x23, 0x27, 0x32, 0x36, 0x35, 0x26, 0x26, 0x23, 0x22, 0x07, + 0x11, 0x23, 0x11, 0x21, 0x35, 0x21, 0x04, 0x94, 0xfd, 0xf6, 0x9d, 0x84, 0xf4, 0x01, 0x12, 0xfe, 0xfc, 0xed, 0x02, + 0x9b, 0x98, 0x02, 0xa3, 0xa2, 0x96, 0x8a, 0xc1, 0xfe, 0x61, 0x04, 0x6a, 0x05, 0x12, 0xfe, 0x39, 0x30, 0xf1, 0xfe, + 0x4e, 0xe3, 0x96, 0x91, 0x94, 0x8e, 0x96, 0x2e, 0xfd, 0x5a, 0x05, 0x12, 0x9e, 0x00, 0x01, 0x00, 0x7b, 0xff, 0xec, + 0x04, 0xdc, 0x05, 0xc4, 0x00, 0x1f, 0x00, 0x89, 0xb2, 0x03, 0x20, 0x21, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, + 0x03, 0x12, 0x3e, 0x59, 0xb0, 0x0b, 0x10, 0xb0, 0x0f, 0xd0, 0xb0, 0x0b, 0x10, 0xb1, 0x12, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x16, 0x03, 0x0b, 0x11, 0x12, 0x39, 0xb0, 0x16, 0x2f, 0xb4, 0xbf, 0x16, + 0xcf, 0x16, 0x02, 0x71, 0xb2, 0xcf, 0x16, 0x01, 0x5d, 0xb2, 0x9f, 0x16, 0x01, 0x71, 0xb2, 0xff, 0x16, 0x01, 0x5d, + 0xb2, 0x2f, 0x16, 0x01, 0x5d, 0xb2, 0x5f, 0x16, 0x01, 0x72, 0xb2, 0x8f, 0x16, 0x01, 0x72, 0xb1, 0x17, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x1c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb0, 0x1f, 0xd0, 0x30, 0x31, 0x01, 0x06, 0x04, 0x23, 0x20, 0x00, 0x11, + 0x35, 0x34, 0x12, 0x24, 0x33, 0x32, 0x00, 0x17, 0x23, 0x26, 0x26, 0x23, 0x22, 0x02, 0x07, 0x21, 0x15, 0x21, 0x15, + 0x14, 0x12, 0x33, 0x32, 0x36, 0x37, 0x04, 0xdc, 0x1b, 0xfe, 0xe1, 0xee, 0xfe, 0xfe, 0xfe, 0xc9, 0x8f, 0x01, 0x0b, + 0xb0, 0xe8, 0x01, 0x18, 0x17, 0xc0, 0x19, 0xa7, 0x97, 0xb9, 0xce, 0x02, 0x02, 0x3a, 0xfd, 0xc6, 0xc6, 0xb2, 0xa0, + 0xab, 0x1c, 0x01, 0xce, 0xe7, 0xfb, 0x01, 0x72, 0x01, 0x36, 0x8b, 0xc9, 0x01, 0x35, 0xa7, 0xfe, 0xfd, 0xe5, 0xac, + 0x9e, 0xfe, 0xf1, 0xea, 0x9d, 0x02, 0xed, 0xfe, 0xe8, 0x91, 0xb4, 0x00, 0x00, 0x02, 0x00, 0x31, 0x00, 0x00, 0x08, + 0x3b, 0x05, 0xb0, 0x00, 0x18, 0x00, 0x21, 0x00, 0x77, 0xb2, 0x09, 0x22, 0x23, 0x11, 0x12, 0x39, 0xb0, 0x09, 0x10, + 0xb0, 0x19, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1e, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, + 0xb1, 0x10, 0x12, 0x3e, 0x59, 0xb2, 0x01, 0x00, 0x08, 0x11, 0x12, 0x39, 0xb0, 0x01, 0x2f, 0xb0, 0x00, 0x10, 0xb1, + 0x0a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x10, 0x10, 0xb1, 0x12, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x01, 0x10, 0xb1, 0x19, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x12, 0x10, 0xb0, 0x1a, 0xd0, 0xb0, 0x1b, 0xd0, 0x30, 0x31, 0x01, 0x11, 0x21, 0x16, 0x04, + 0x15, 0x14, 0x04, 0x07, 0x21, 0x11, 0x21, 0x03, 0x02, 0x02, 0x06, 0x07, 0x23, 0x35, 0x37, 0x3e, 0x02, 0x37, 0x13, + 0x01, 0x11, 0x21, 0x32, 0x36, 0x35, 0x34, 0x26, 0x27, 0x04, 0xee, 0x01, 0x69, 0xde, 0x01, 0x06, 0xfe, 0xfe, 0xde, + 0xfd, 0xd3, 0xfe, 0x00, 0x1a, 0x0f, 0x59, 0xac, 0x90, 0x3f, 0x28, 0x5d, 0x64, 0x34, 0x0b, 0x1e, 0x03, 0x77, 0x01, + 0x5f, 0x8c, 0xa2, 0x9d, 0x8a, 0x05, 0xb0, 0xfd, 0xcb, 0x03, 0xf0, 0xcb, 0xc6, 0xf3, 0x04, 0x05, 0x12, 0xfd, 0xbf, + 0xfe, 0xde, 0xfe, 0xdc, 0x89, 0x02, 0x9d, 0x02, 0x07, 0x6b, 0xea, 0xf3, 0x02, 0xc2, 0xfd, 0x2d, 0xfd, 0xc0, 0x9e, + 0x84, 0x80, 0x9c, 0x02, 0x00, 0x00, 0x02, 0x00, 0xb1, 0x00, 0x00, 0x08, 0x4d, 0x05, 0xb0, 0x00, 0x12, 0x00, 0x1b, + 0x00, 0x85, 0xb2, 0x01, 0x1c, 0x1d, 0x11, 0x12, 0x39, 0xb0, 0x01, 0x10, 0xb0, 0x13, 0xd0, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x12, 0x2f, 0x1b, 0xb1, 0x12, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, + 0x02, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0f, 0x2f, 0x1b, 0xb1, 0x0f, 0x12, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x12, 0x3e, 0x59, 0xb2, 0x00, 0x02, 0x0f, 0x11, 0x12, 0x39, 0xb0, + 0x00, 0x2f, 0xb2, 0x04, 0x0c, 0x02, 0x11, 0x12, 0x39, 0xb0, 0x04, 0x2f, 0xb0, 0x00, 0x10, 0xb1, 0x0e, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0x10, 0xb1, 0x13, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0c, 0x10, 0xb1, 0x14, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0x30, 0x31, 0x01, 0x21, 0x11, 0x33, 0x11, 0x21, 0x16, 0x04, 0x15, 0x14, 0x04, 0x07, 0x21, 0x11, 0x21, 0x11, 0x23, + 0x11, 0x33, 0x01, 0x11, 0x21, 0x32, 0x36, 0x35, 0x34, 0x26, 0x27, 0x01, 0x72, 0x02, 0xce, 0xc0, 0x01, 0x6a, 0xe2, + 0x01, 0x01, 0xfe, 0xff, 0xdf, 0xfd, 0xd3, 0xfd, 0x32, 0xc1, 0xc1, 0x03, 0x8e, 0x01, 0x5f, 0x8e, 0xa0, 0x98, 0x8a, + 0x03, 0x39, 0x02, 0x77, 0xfd, 0x9e, 0x03, 0xe2, 0xbd, 0xbf, 0xe9, 0x04, 0x02, 0x9c, 0xfd, 0x64, 0x05, 0xb0, 0xfd, + 0x01, 0xfd, 0xf5, 0x8e, 0x7a, 0x74, 0x8c, 0x03, 0x00, 0x00, 0x01, 0x00, 0x3e, 0x00, 0x00, 0x05, 0xd4, 0x05, 0xb0, + 0x00, 0x15, 0x00, 0x5f, 0xb2, 0x0e, 0x16, 0x17, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x14, 0x2f, + 0x1b, 0xb1, 0x14, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x12, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x12, 0x3e, 0x59, 0xb0, 0x14, 0x10, 0xb1, 0x00, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x04, 0x14, 0x08, 0x11, 0x12, 0x39, 0xb0, 0x04, 0x2f, + 0xb1, 0x0d, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x00, 0x10, 0xb0, 0x12, 0xd0, 0xb0, + 0x13, 0xd0, 0x30, 0x31, 0x01, 0x21, 0x11, 0x36, 0x33, 0x32, 0x16, 0x17, 0x11, 0x23, 0x11, 0x26, 0x26, 0x23, 0x22, + 0x07, 0x11, 0x23, 0x11, 0x21, 0x35, 0x21, 0x04, 0xa6, 0xfd, 0xf0, 0xa0, 0xaf, 0xfa, 0xf2, 0x03, 0xc1, 0x01, 0x89, + 0xa4, 0xa9, 0xa6, 0xc0, 0xfe, 0x68, 0x04, 0x68, 0x05, 0x12, 0xfe, 0x50, 0x28, 0xda, 0xdd, 0xfe, 0x2d, 0x01, 0xce, + 0x98, 0x86, 0x2a, 0xfd, 0x3e, 0x05, 0x12, 0x9e, 0x00, 0x01, 0x00, 0xb0, 0xfe, 0x99, 0x04, 0xff, 0x05, 0xb0, 0x00, + 0x0b, 0x00, 0x49, 0x00, 0xb0, 0x09, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1e, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x12, + 0x3e, 0x59, 0xb1, 0x02, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0xd0, 0x30, 0x31, + 0x13, 0x33, 0x11, 0x21, 0x11, 0x33, 0x11, 0x21, 0x11, 0x23, 0x11, 0x21, 0xb0, 0xc1, 0x02, 0xce, 0xc0, 0xfe, 0x40, + 0xc1, 0xfe, 0x32, 0x05, 0xb0, 0xfa, 0xed, 0x05, 0x13, 0xfa, 0x50, 0xfe, 0x99, 0x01, 0x67, 0x00, 0x00, 0x02, 0x00, + 0xa2, 0x00, 0x00, 0x04, 0xb1, 0x05, 0xb0, 0x00, 0x0c, 0x00, 0x15, 0x00, 0x5e, 0xb2, 0x0f, 0x16, 0x17, 0x11, 0x12, + 0x39, 0xb0, 0x0f, 0x10, 0xb0, 0x03, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1e, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x12, 0x3e, 0x59, 0xb0, 0x0b, 0x10, 0xb1, + 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x02, 0x0b, 0x09, 0x11, 0x12, 0x39, 0xb0, + 0x02, 0x2f, 0xb1, 0x0d, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x09, 0x10, 0xb1, 0x0e, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, 0x11, 0x21, 0x16, 0x04, 0x15, + 0x14, 0x04, 0x07, 0x21, 0x11, 0x21, 0x01, 0x11, 0x21, 0x32, 0x36, 0x35, 0x34, 0x26, 0x27, 0x04, 0x21, 0xfd, 0x42, + 0x01, 0x6a, 0xe4, 0x01, 0x00, 0xfe, 0xfe, 0xdf, 0xfd, 0xd2, 0x03, 0x7f, 0xfd, 0x42, 0x01, 0x5f, 0x8f, 0x9f, 0x99, + 0x8d, 0x05, 0x12, 0xfe, 0x4c, 0x03, 0xe4, 0xc4, 0xc5, 0xea, 0x04, 0x05, 0xb0, 0xfd, 0x10, 0xfd, 0xdd, 0x98, 0x80, + 0x7b, 0x8e, 0x02, 0x00, 0x00, 0x02, 0x00, 0x32, 0xfe, 0x9a, 0x05, 0xc9, 0x05, 0xb0, 0x00, 0x0e, 0x00, 0x15, 0x00, + 0x5d, 0xb2, 0x12, 0x16, 0x17, 0x11, 0x12, 0x39, 0xb0, 0x12, 0x10, 0xb0, 0x0b, 0xd0, 0x00, 0xb0, 0x04, 0x2f, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, + 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x04, 0x10, 0xb0, 0x01, 0xd0, 0xb0, 0x02, 0x10, 0xb1, 0x06, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0d, 0xd0, 0xb0, 0x0e, 0xd0, 0xb0, 0x0f, 0xd0, 0xb0, 0x10, + 0xd0, 0xb0, 0x0b, 0x10, 0xb1, 0x11, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, + 0x23, 0x11, 0x21, 0x11, 0x23, 0x03, 0x33, 0x36, 0x12, 0x37, 0x13, 0x21, 0x11, 0x33, 0x21, 0x21, 0x11, 0x21, 0x03, + 0x06, 0x02, 0x05, 0xc7, 0xbf, 0xfb, 0xeb, 0xc0, 0x01, 0x77, 0x5e, 0x6f, 0x0e, 0x20, 0x03, 0x67, 0xbe, 0xfb, 0xbb, + 0x02, 0xc6, 0xfe, 0x13, 0x15, 0x0d, 0x6b, 0xfe, 0x9b, 0x01, 0x65, 0xfe, 0x9a, 0x02, 0x03, 0x6a, 0x01, 0x65, 0xd5, + 0x02, 0x6f, 0xfa, 0xed, 0x04, 0x75, 0xfe, 0x54, 0xfb, 0xfe, 0x9e, 0x00, 0x01, 0x00, 0x1b, 0x00, 0x00, 0x07, 0x35, + 0x05, 0xb0, 0x00, 0x15, 0x00, 0x87, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x1e, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x11, 0x2f, 0x1b, 0xb1, 0x11, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x14, 0x2f, 0x1b, 0xb1, 0x14, 0x12, 0x3e, 0x59, 0xb0, 0x02, 0x10, 0xb0, 0x10, 0xd0, 0xb0, 0x10, 0x2f, 0xb2, + 0x2f, 0x10, 0x01, 0x5d, 0xb2, 0xcf, 0x10, 0x01, 0x5d, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb0, 0x04, 0xd0, 0xb2, 0x08, 0x10, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x10, 0x10, 0xb0, 0x0b, 0xd0, 0xb2, + 0x13, 0x00, 0x10, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x23, 0x11, 0x23, 0x11, 0x23, 0x01, 0x23, 0x01, 0x01, 0x33, + 0x01, 0x33, 0x11, 0x33, 0x11, 0x33, 0x01, 0x33, 0x01, 0x01, 0x23, 0x04, 0xa8, 0x9c, 0xc0, 0xa5, 0xfe, 0x64, 0xf0, + 0x01, 0xea, 0xfe, 0x3c, 0xe3, 0x01, 0x83, 0xa5, 0xc0, 0x9e, 0x01, 0x83, 0xe2, 0xfe, 0x3c, 0x01, 0xea, 0xef, 0x02, + 0x98, 0xfd, 0x68, 0x02, 0x98, 0xfd, 0x68, 0x03, 0x00, 0x02, 0xb0, 0xfd, 0x88, 0x02, 0x78, 0xfd, 0x88, 0x02, 0x78, + 0xfd, 0x51, 0xfc, 0xff, 0x00, 0x00, 0x01, 0x00, 0x50, 0xff, 0xec, 0x04, 0x6a, 0x05, 0xc4, 0x00, 0x28, 0x00, 0x75, + 0xb2, 0x03, 0x29, 0x2a, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1e, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x16, 0x2f, 0x1b, 0xb1, 0x16, 0x12, 0x3e, 0x59, 0xb0, 0x0b, 0x10, 0xb1, + 0x03, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0b, 0x10, 0xb0, 0x06, 0xd0, 0xb2, 0x25, + 0x16, 0x0b, 0x11, 0x12, 0x39, 0xb0, 0x25, 0x2f, 0xb2, 0xcf, 0x25, 0x01, 0x5d, 0xb2, 0x9f, 0x25, 0x01, 0x71, 0xb1, + 0x24, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x11, 0x24, 0x25, 0x11, 0x12, 0x39, 0xb0, + 0x16, 0x10, 0xb0, 0x1b, 0xd0, 0xb0, 0x16, 0x10, 0xb1, 0x1e, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0x30, 0x31, 0x01, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x23, 0x34, 0x36, 0x36, 0x33, 0x32, 0x04, 0x15, 0x14, + 0x06, 0x07, 0x04, 0x15, 0x14, 0x04, 0x23, 0x22, 0x26, 0x26, 0x35, 0x33, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x10, + 0x25, 0x23, 0x35, 0x33, 0x36, 0x36, 0x03, 0x94, 0xa9, 0x99, 0x80, 0xad, 0xc0, 0x7f, 0xe4, 0x8a, 0xf4, 0x01, 0x0e, + 0x7c, 0x6f, 0x01, 0x01, 0xfe, 0xdc, 0xf4, 0x91, 0xed, 0x84, 0xc0, 0xb6, 0x8c, 0x9d, 0xbb, 0xfe, 0xc3, 0xb4, 0xb3, + 0x92, 0x96, 0x04, 0x29, 0x74, 0x89, 0x8d, 0x68, 0x74, 0xb8, 0x67, 0xdb, 0xc3, 0x65, 0xa6, 0x30, 0x56, 0xff, 0xc4, + 0xe6, 0x67, 0xbe, 0x83, 0x73, 0x99, 0x92, 0x78, 0x01, 0x00, 0x05, 0x9e, 0x03, 0x7e, 0x00, 0x00, 0x01, 0x00, 0xb1, + 0x00, 0x00, 0x04, 0xff, 0x05, 0xb0, 0x00, 0x09, 0x00, 0x5d, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, + 0xb1, 0x00, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1e, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, + 0x1b, 0xb1, 0x05, 0x12, 0x3e, 0x59, 0xb2, 0x04, 0x00, 0x02, 0x11, 0x12, 0x39, 0x40, 0x09, 0x8a, 0x04, 0x9a, 0x04, + 0xaa, 0x04, 0xba, 0x04, 0x04, 0x5d, 0xb2, 0x09, 0x00, 0x02, 0x11, 0x12, 0x39, 0x40, 0x09, 0x85, 0x09, 0x95, 0x09, + 0xa5, 0x09, 0xb5, 0x09, 0x04, 0x5d, 0x30, 0x31, 0x01, 0x33, 0x11, 0x23, 0x11, 0x01, 0x23, 0x11, 0x33, 0x11, 0x04, + 0x3f, 0xc0, 0xc0, 0xfd, 0x33, 0xc1, 0xc1, 0x05, 0xb0, 0xfa, 0x50, 0x04, 0x62, 0xfb, 0x9e, 0x05, 0xb0, 0xfb, 0x9e, + 0x00, 0x00, 0x01, 0x00, 0x2f, 0x00, 0x00, 0x04, 0xf6, 0x05, 0xb0, 0x00, 0x11, 0x00, 0x4f, 0xb2, 0x04, 0x12, 0x13, + 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1e, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, + 0xb1, 0x09, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x10, 0xb1, 0x03, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb0, 0x09, 0x10, 0xb1, 0x0b, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, + 0x11, 0x23, 0x11, 0x21, 0x03, 0x02, 0x02, 0x06, 0x07, 0x23, 0x35, 0x37, 0x3e, 0x02, 0x37, 0x13, 0x04, 0xf6, 0xc0, + 0xfd, 0xf6, 0x1a, 0x0f, 0x59, 0xac, 0x90, 0x3f, 0x28, 0x5d, 0x64, 0x34, 0x0b, 0x1e, 0x05, 0xb0, 0xfa, 0x50, 0x05, + 0x12, 0xfd, 0xbf, 0xfe, 0xde, 0xfe, 0xdc, 0x89, 0x02, 0x9d, 0x02, 0x07, 0x6b, 0xea, 0xf3, 0x02, 0xc2, 0x00, 0x00, + 0x01, 0x00, 0x4d, 0xff, 0xeb, 0x04, 0xcb, 0x05, 0xb0, 0x00, 0x11, 0x00, 0x4b, 0xb2, 0x04, 0x12, 0x13, 0x11, 0x12, + 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, + 0x12, 0x3e, 0x59, 0xb2, 0x00, 0x01, 0x07, 0x11, 0x12, 0x39, 0xb1, 0x0b, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb2, 0x0f, 0x07, 0x10, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x01, 0x33, 0x01, 0x0e, 0x02, 0x23, + 0x22, 0x27, 0x37, 0x17, 0x32, 0x3f, 0x02, 0x01, 0x33, 0x02, 0x9d, 0x01, 0x4f, 0xdf, 0xfd, 0xfd, 0x34, 0x5a, 0x79, + 0x5b, 0x4f, 0x16, 0x06, 0x5b, 0x69, 0x33, 0x19, 0x26, 0xfe, 0x10, 0xd7, 0x02, 0x63, 0x03, 0x4d, 0xfb, 0x43, 0x74, + 0x61, 0x33, 0x09, 0x98, 0x04, 0x65, 0x34, 0x59, 0x04, 0x36, 0x00, 0x03, 0x00, 0x53, 0xff, 0xc4, 0x05, 0xe3, 0x05, + 0xec, 0x00, 0x18, 0x00, 0x21, 0x00, 0x2a, 0x00, 0x5d, 0xb2, 0x0c, 0x2b, 0x2c, 0x11, 0x12, 0x39, 0xb0, 0x0c, 0x10, + 0xb0, 0x20, 0xd0, 0xb0, 0x0c, 0x10, 0xb0, 0x22, 0xd0, 0x00, 0xb0, 0x0b, 0x2f, 0xb0, 0x17, 0x2f, 0xb2, 0x15, 0x17, + 0x0b, 0x11, 0x12, 0x39, 0xb0, 0x15, 0x2f, 0xb0, 0x00, 0xd0, 0xb2, 0x09, 0x0b, 0x17, 0x11, 0x12, 0x39, 0xb0, 0x09, + 0x2f, 0xb0, 0x0d, 0xd0, 0xb0, 0x15, 0x10, 0xb1, 0x19, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb0, 0x09, 0x10, 0xb1, 0x24, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x1f, 0xd0, 0xb0, + 0x19, 0x10, 0xb0, 0x22, 0xd0, 0x30, 0x31, 0x01, 0x33, 0x16, 0x04, 0x12, 0x15, 0x14, 0x02, 0x04, 0x07, 0x23, 0x15, + 0x23, 0x35, 0x23, 0x22, 0x24, 0x02, 0x10, 0x12, 0x24, 0x33, 0x33, 0x35, 0x33, 0x03, 0x22, 0x06, 0x15, 0x14, 0x16, + 0x33, 0x33, 0x11, 0x33, 0x11, 0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x23, 0x03, 0x78, 0x1f, 0xa5, 0x01, 0x10, 0x97, + 0x98, 0xfe, 0xf4, 0xa4, 0x23, 0xba, 0x1c, 0xa7, 0xfe, 0xef, 0x97, 0x97, 0x01, 0x11, 0xa7, 0x1c, 0xba, 0xd6, 0xbc, + 0xdb, 0xda, 0xbf, 0x1a, 0xba, 0x1c, 0xbf, 0xd7, 0xd7, 0xc3, 0x05, 0x1e, 0x01, 0x98, 0xfe, 0xf5, 0xa5, 0xa6, 0xfe, + 0xf2, 0x97, 0x02, 0xc4, 0xc4, 0x98, 0x01, 0x0c, 0x01, 0x4e, 0x01, 0x0c, 0x98, 0xce, 0xfe, 0x9b, 0xe7, 0xcd, 0xce, + 0xe5, 0x03, 0x67, 0xfc, 0x99, 0xeb, 0xca, 0xc8, 0xea, 0x00, 0x00, 0x01, 0x00, 0xaf, 0xfe, 0xa1, 0x05, 0x97, 0x05, + 0xb0, 0x00, 0x0b, 0x00, 0x3c, 0x00, 0xb0, 0x09, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, + 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x12, 0x3e, 0x59, 0xb1, 0x02, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x06, 0xd0, 0x30, 0x31, 0x13, 0x33, 0x11, 0x21, 0x11, 0x33, 0x11, 0x33, 0x03, 0x23, 0x11, + 0x21, 0xaf, 0xc1, 0x02, 0xce, 0xc0, 0x99, 0x12, 0xad, 0xfb, 0xd7, 0x05, 0xb0, 0xfa, 0xed, 0x05, 0x13, 0xfa, 0xf1, + 0xfe, 0x00, 0x01, 0x5f, 0x00, 0x01, 0x00, 0x96, 0x00, 0x00, 0x04, 0xc8, 0x05, 0xb0, 0x00, 0x12, 0x00, 0x47, 0xb2, + 0x05, 0x13, 0x14, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1e, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x12, 0x3e, 0x59, 0xb2, 0x0f, 0x00, 0x01, 0x11, 0x12, 0x39, 0xb0, 0x0f, 0x2f, 0xb1, + 0x06, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x11, 0x23, 0x11, 0x06, 0x06, + 0x23, 0x22, 0x26, 0x27, 0x11, 0x33, 0x11, 0x16, 0x16, 0x33, 0x32, 0x37, 0x11, 0x04, 0xc8, 0xc1, 0x69, 0xac, 0x6e, + 0xf9, 0xf2, 0x03, 0xc1, 0x01, 0x89, 0xa3, 0xbe, 0xc5, 0x05, 0xb0, 0xfa, 0x50, 0x02, 0x5b, 0x1e, 0x17, 0xd8, 0xdf, + 0x01, 0xd3, 0xfe, 0x32, 0x98, 0x86, 0x36, 0x02, 0xb6, 0x00, 0x01, 0x00, 0xb0, 0x00, 0x00, 0x06, 0xd7, 0x05, 0xb0, + 0x00, 0x0b, 0x00, 0x49, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1e, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, + 0x1b, 0xb1, 0x07, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x12, 0x3e, 0x59, + 0xb1, 0x01, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x05, 0xd0, 0xb0, 0x06, 0xd0, 0x30, + 0x31, 0x01, 0x11, 0x21, 0x11, 0x33, 0x11, 0x21, 0x11, 0x33, 0x11, 0x21, 0x11, 0x01, 0x71, 0x01, 0xf5, 0xbf, 0x01, + 0xf2, 0xc0, 0xf9, 0xd9, 0x05, 0xb0, 0xfa, 0xed, 0x05, 0x13, 0xfa, 0xed, 0x05, 0x13, 0xfa, 0x50, 0x05, 0xb0, 0x00, + 0x00, 0x01, 0x00, 0xb0, 0xfe, 0xa1, 0x07, 0x6a, 0x05, 0xb0, 0x00, 0x0f, 0x00, 0x55, 0x00, 0xb0, 0x0b, 0x2f, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, + 0x1b, 0xb1, 0x03, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1e, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x12, 0x3e, 0x59, 0xb1, 0x01, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x05, 0xd0, 0xb0, 0x06, 0xd0, 0xb0, 0x09, 0xd0, 0xb0, 0x0a, 0xd0, 0xb0, + 0x02, 0xd0, 0x30, 0x31, 0x01, 0x11, 0x21, 0x11, 0x33, 0x11, 0x21, 0x11, 0x33, 0x11, 0x33, 0x03, 0x23, 0x11, 0x21, + 0x11, 0x01, 0x71, 0x01, 0xf5, 0xbf, 0x01, 0xf2, 0xc0, 0x93, 0x12, 0xa5, 0xf9, 0xfd, 0x05, 0xb0, 0xfa, 0xed, 0x05, + 0x13, 0xfa, 0xed, 0x05, 0x13, 0xfa, 0xe7, 0xfe, 0x0a, 0x01, 0x5f, 0x05, 0xb0, 0x00, 0x02, 0x00, 0x10, 0x00, 0x00, + 0x05, 0xb8, 0x05, 0xb0, 0x00, 0x0c, 0x00, 0x15, 0x00, 0x61, 0xb2, 0x01, 0x16, 0x17, 0x11, 0x12, 0x39, 0xb0, 0x01, + 0x10, 0xb0, 0x0d, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1e, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x12, 0x3e, 0x59, 0xb2, 0x02, 0x00, 0x09, 0x11, 0x12, 0x39, + 0xb0, 0x02, 0x2f, 0xb0, 0x00, 0x10, 0xb1, 0x0b, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x02, 0x10, 0xb1, 0x0d, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x09, 0x10, 0xb1, 0x0e, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x13, 0x21, 0x11, 0x21, 0x32, 0x04, 0x15, + 0x14, 0x04, 0x07, 0x21, 0x11, 0x21, 0x01, 0x11, 0x21, 0x32, 0x36, 0x35, 0x34, 0x26, 0x27, 0x10, 0x02, 0x5b, 0x01, + 0x5a, 0xef, 0x01, 0x04, 0xfe, 0xfe, 0xe2, 0xfd, 0xd6, 0xfe, 0x66, 0x02, 0x5b, 0x01, 0x5f, 0x8e, 0x9f, 0x99, 0x8c, + 0x05, 0xb0, 0xfd, 0xae, 0xe5, 0xc6, 0xc5, 0xeb, 0x03, 0x05, 0x18, 0xfd, 0xa8, 0xfd, 0xdd, 0x98, 0x80, 0x7b, 0x8e, + 0x02, 0x00, 0x03, 0x00, 0xb2, 0x00, 0x00, 0x06, 0x30, 0x05, 0xb0, 0x00, 0x0a, 0x00, 0x13, 0x00, 0x17, 0x00, 0x6f, + 0xb2, 0x12, 0x18, 0x19, 0x11, 0x12, 0x39, 0xb0, 0x12, 0x10, 0xb0, 0x06, 0xd0, 0xb0, 0x12, 0x10, 0xb0, 0x15, 0xd0, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x16, 0x2f, 0x1b, 0xb1, 0x16, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x12, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x14, 0x2f, 0x1b, 0xb1, 0x14, 0x12, 0x3e, 0x59, 0xb2, 0x00, 0x09, 0x07, + 0x11, 0x12, 0x39, 0xb0, 0x00, 0x2f, 0xb1, 0x0b, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x07, 0x10, 0xb1, 0x0c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, 0x16, + 0x04, 0x15, 0x14, 0x04, 0x07, 0x21, 0x11, 0x33, 0x11, 0x11, 0x21, 0x32, 0x36, 0x35, 0x34, 0x26, 0x27, 0x01, 0x23, + 0x11, 0x33, 0x01, 0x72, 0x01, 0x6a, 0xe4, 0x01, 0x00, 0xfe, 0xfe, 0xdf, 0xfd, 0xd3, 0xc0, 0x01, 0x5f, 0x8f, 0x9f, + 0x99, 0x8d, 0x03, 0x57, 0xc0, 0xc0, 0x03, 0x5e, 0x03, 0xe4, 0xc4, 0xc5, 0xea, 0x04, 0x05, 0xb0, 0xfd, 0x10, 0xfd, + 0xdd, 0x98, 0x80, 0x7b, 0x8e, 0x02, 0xfd, 0x40, 0x05, 0xb0, 0x00, 0x00, 0x02, 0x00, 0xa3, 0x00, 0x00, 0x04, 0xb1, + 0x05, 0xb0, 0x00, 0x0a, 0x00, 0x13, 0x00, 0x4f, 0xb2, 0x0d, 0x14, 0x15, 0x11, 0x12, 0x39, 0xb0, 0x0d, 0x10, 0xb0, + 0x01, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x12, 0x3e, 0x59, 0xb2, 0x00, 0x09, 0x07, 0x11, 0x12, 0x39, 0xb0, 0x00, + 0x2f, 0xb1, 0x0b, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x07, 0x10, 0xb1, 0x0c, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, 0x16, 0x04, 0x15, 0x14, 0x04, 0x07, + 0x21, 0x11, 0x33, 0x11, 0x11, 0x21, 0x32, 0x36, 0x35, 0x34, 0x26, 0x27, 0x01, 0x63, 0x01, 0x6a, 0xe4, 0x01, 0x00, + 0xfe, 0xfe, 0xdf, 0xfd, 0xd3, 0xc0, 0x01, 0x5f, 0x8f, 0x9f, 0x99, 0x8d, 0x03, 0x5e, 0x03, 0xe4, 0xc4, 0xc5, 0xea, + 0x04, 0x05, 0xb0, 0xfd, 0x10, 0xfd, 0xdd, 0x98, 0x80, 0x7b, 0x8e, 0x02, 0x00, 0x00, 0x01, 0x00, 0x93, 0xff, 0xec, + 0x04, 0xf4, 0x05, 0xc4, 0x00, 0x1f, 0x00, 0x92, 0xb2, 0x0c, 0x20, 0x21, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x13, 0x2f, 0x1b, 0xb1, 0x13, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x1c, 0x2f, 0x1b, 0xb1, + 0x1c, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0xd0, 0xb0, 0x1c, 0x10, 0xb1, 0x03, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb2, 0x08, 0x1c, 0x13, 0x11, 0x12, 0x39, 0xb0, 0x08, 0x2f, 0xb4, 0xef, 0x08, 0xff, 0x08, 0x02, + 0x71, 0xb2, 0xcf, 0x08, 0x01, 0x5d, 0xb2, 0x2f, 0x08, 0x01, 0x71, 0xb4, 0xbf, 0x08, 0xcf, 0x08, 0x02, 0x71, 0xb2, + 0x9f, 0x08, 0x01, 0x71, 0xb2, 0xff, 0x08, 0x01, 0x5d, 0xb2, 0x2f, 0x08, 0x01, 0x5d, 0xb2, 0x5f, 0x08, 0x01, 0x72, + 0xb2, 0x8f, 0x08, 0x01, 0x72, 0xb1, 0x06, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x13, + 0x10, 0xb1, 0x0c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x13, 0x10, 0xb0, 0x0f, 0xd0, + 0x30, 0x31, 0x01, 0x16, 0x16, 0x33, 0x32, 0x12, 0x37, 0x21, 0x35, 0x21, 0x34, 0x02, 0x23, 0x22, 0x06, 0x07, 0x23, + 0x36, 0x00, 0x33, 0x32, 0x04, 0x12, 0x15, 0x15, 0x14, 0x02, 0x04, 0x23, 0x22, 0x24, 0x27, 0x01, 0x54, 0x1c, 0xab, + 0xa0, 0xad, 0xc9, 0x02, 0xfd, 0xc3, 0x02, 0x3d, 0xcf, 0xba, 0x96, 0xa7, 0x19, 0xc1, 0x17, 0x01, 0x18, 0xe8, 0xb0, + 0x01, 0x0b, 0x8f, 0x8e, 0xfe, 0xfd, 0xa8, 0xee, 0xfe, 0xe1, 0x1b, 0x01, 0xce, 0xb4, 0x91, 0x01, 0x0e, 0xf0, 0x9e, + 0xed, 0x01, 0x14, 0x9c, 0xae, 0xe5, 0x01, 0x03, 0xa7, 0xfe, 0xcb, 0xc9, 0x91, 0xc9, 0xfe, 0xcc, 0xa5, 0xfb, 0xe7, + 0x00, 0x00, 0x02, 0x00, 0xb7, 0xff, 0xec, 0x06, 0xda, 0x05, 0xc4, 0x00, 0x17, 0x00, 0x25, 0x00, 0xa4, 0xb2, 0x21, + 0x26, 0x27, 0x11, 0x12, 0x39, 0xb0, 0x21, 0x10, 0xb0, 0x12, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x13, 0x2f, + 0x1b, 0xb1, 0x13, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1e, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, + 0x2f, 0x1b, 0xb1, 0x0a, 0x12, 0x3e, 0x59, 0xb2, 0x0f, 0x0a, 0x0d, 0x11, 0x12, 0x39, 0xb0, 0x0f, 0x2f, 0xb2, 0x5f, + 0x0f, 0x01, 0x5d, 0xb2, 0xff, 0x0f, 0x01, 0x5d, 0xb4, 0x4f, 0x0f, 0x5f, 0x0f, 0x02, 0x71, 0xb4, 0x8f, 0x0f, 0x9f, + 0x0f, 0x02, 0x71, 0xb2, 0x2f, 0x0f, 0x01, 0x71, 0xb2, 0xcf, 0x0f, 0x01, 0x5d, 0xb2, 0x2f, 0x0f, 0x01, 0x5d, 0xb2, + 0xcf, 0x0f, 0x01, 0x71, 0xb1, 0x08, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x13, 0x10, + 0xb1, 0x1b, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0x10, 0xb1, 0x22, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x14, 0x02, 0x04, 0x23, 0x22, 0x24, 0x02, 0x27, + 0x23, 0x11, 0x23, 0x11, 0x33, 0x11, 0x33, 0x36, 0x12, 0x24, 0x33, 0x32, 0x04, 0x12, 0x15, 0x27, 0x10, 0x02, 0x23, + 0x22, 0x02, 0x07, 0x15, 0x14, 0x12, 0x33, 0x32, 0x12, 0x37, 0x06, 0xda, 0x90, 0xfe, 0xf8, 0xb0, 0xa6, 0xfe, 0xf9, + 0x95, 0x08, 0xd1, 0xc0, 0xc0, 0xd0, 0x03, 0x90, 0x01, 0x0a, 0xac, 0xaf, 0x01, 0x0b, 0x90, 0xbf, 0xd0, 0xbb, 0xb6, + 0xd1, 0x03, 0xd3, 0xb9, 0xba, 0xcc, 0x03, 0x02, 0xa9, 0xd6, 0xfe, 0xc1, 0xa8, 0xa0, 0x01, 0x2a, 0xc7, 0xfd, 0x83, + 0x05, 0xb0, 0xfd, 0x64, 0xce, 0x01, 0x37, 0xab, 0xa9, 0xfe, 0xbf, 0xd5, 0x02, 0x01, 0x03, 0x01, 0x15, 0xfe, 0xeb, + 0xf6, 0x6b, 0xfb, 0xfe, 0xe1, 0x01, 0x0f, 0xfd, 0x00, 0x02, 0x00, 0x59, 0x00, 0x00, 0x04, 0x64, 0x05, 0xb0, 0x00, + 0x0c, 0x00, 0x15, 0x00, 0x63, 0xb2, 0x10, 0x16, 0x17, 0x11, 0x12, 0x39, 0xb0, 0x10, 0x10, 0xb0, 0x0a, 0xd0, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, + 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x12, 0x3e, + 0x59, 0xb2, 0x11, 0x0a, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x11, 0x2f, 0xb1, 0x01, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x05, 0x01, 0x0a, 0x11, 0x12, 0x39, 0xb0, 0x0a, 0x10, 0xb1, 0x12, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x21, 0x11, 0x21, 0x01, 0x23, 0x01, 0x24, 0x11, 0x34, 0x24, + 0x33, 0x21, 0x11, 0x01, 0x14, 0x16, 0x17, 0x21, 0x11, 0x21, 0x22, 0x06, 0x03, 0xa3, 0xfe, 0xb0, 0xfe, 0xd3, 0xcd, + 0x01, 0x52, 0xfe, 0xe6, 0x01, 0x11, 0xf3, 0x01, 0xcf, 0xfc, 0xed, 0xa5, 0x93, 0x01, 0x1a, 0xfe, 0xef, 0x9c, 0xa5, + 0x02, 0x37, 0xfd, 0xc9, 0x02, 0x6c, 0x6f, 0x01, 0x1e, 0xd0, 0xe7, 0xfa, 0x50, 0x03, 0xf9, 0x84, 0xa0, 0x01, 0x02, + 0x3e, 0x94, 0x00, 0x02, 0x00, 0x61, 0xff, 0xec, 0x04, 0x28, 0x06, 0x11, 0x00, 0x1b, 0x00, 0x28, 0x00, 0x64, 0xb2, + 0x1c, 0x29, 0x2a, 0x11, 0x12, 0x39, 0xb0, 0x1c, 0x10, 0xb0, 0x08, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x12, + 0x2f, 0x1b, 0xb1, 0x12, 0x20, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x12, 0x3e, + 0x59, 0xb2, 0x00, 0x12, 0x08, 0x11, 0x12, 0x39, 0xb0, 0x00, 0x2f, 0xb2, 0x17, 0x00, 0x12, 0x11, 0x12, 0x39, 0xb2, + 0x0f, 0x12, 0x17, 0x11, 0x12, 0x39, 0xb2, 0x1a, 0x00, 0x08, 0x11, 0x12, 0x39, 0xb1, 0x1c, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, 0x10, 0xb1, 0x23, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0x30, 0x31, 0x01, 0x32, 0x12, 0x15, 0x15, 0x14, 0x06, 0x06, 0x23, 0x22, 0x00, 0x35, 0x35, 0x10, 0x12, + 0x37, 0x36, 0x36, 0x35, 0x33, 0x14, 0x06, 0x07, 0x07, 0x06, 0x06, 0x07, 0x36, 0x17, 0x22, 0x06, 0x15, 0x15, 0x14, + 0x16, 0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x02, 0x67, 0xcc, 0xf5, 0x76, 0xdd, 0x90, 0xda, 0xfe, 0xf6, 0xfd, 0xf7, + 0x8c, 0x62, 0x98, 0x71, 0x7c, 0x8a, 0xa5, 0xa5, 0x19, 0x93, 0xaf, 0x88, 0xa0, 0xa1, 0x89, 0x8a, 0xa0, 0xa1, 0x03, + 0xfc, 0xfe, 0xef, 0xdf, 0x11, 0x99, 0xf1, 0x85, 0x01, 0x23, 0xf5, 0x5a, 0x01, 0x55, 0x01, 0x92, 0x2c, 0x19, 0x48, + 0x3f, 0x7d, 0x8c, 0x1d, 0x1f, 0x27, 0xb9, 0x9a, 0xaa, 0x98, 0xb7, 0xa2, 0x10, 0xae, 0xcb, 0xcc, 0xc4, 0x99, 0xb9, + 0x00, 0x03, 0x00, 0x9d, 0x00, 0x00, 0x04, 0x29, 0x04, 0x3a, 0x00, 0x0e, 0x00, 0x16, 0x00, 0x1c, 0x00, 0x91, 0xb2, + 0x18, 0x1d, 0x1e, 0x11, 0x12, 0x39, 0xb0, 0x18, 0x10, 0xb0, 0x02, 0xd0, 0xb0, 0x18, 0x10, 0xb0, 0x16, 0xd0, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, + 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb2, 0x17, 0x01, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x17, 0x2f, 0xb4, 0xbf, + 0x17, 0xcf, 0x17, 0x02, 0x5d, 0xb4, 0x9f, 0x17, 0xaf, 0x17, 0x02, 0x71, 0xb2, 0xff, 0x17, 0x01, 0x5d, 0xb2, 0x0f, + 0x17, 0x01, 0x71, 0xb4, 0x2f, 0x17, 0x3f, 0x17, 0x02, 0x5d, 0xb4, 0x6f, 0x17, 0x7f, 0x17, 0x02, 0x72, 0xb1, 0x0f, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x08, 0x0f, 0x17, 0x11, 0x12, 0x39, 0xb0, 0x00, + 0x10, 0xb1, 0x10, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x01, 0x10, 0xb1, 0x1b, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x33, 0x11, 0x21, 0x32, 0x16, 0x15, 0x14, 0x06, + 0x07, 0x16, 0x16, 0x15, 0x14, 0x06, 0x23, 0x01, 0x11, 0x21, 0x32, 0x36, 0x35, 0x34, 0x23, 0x25, 0x33, 0x20, 0x10, + 0x27, 0x23, 0x9d, 0x01, 0xa6, 0xd8, 0xe7, 0x5a, 0x58, 0x62, 0x77, 0xdb, 0xc8, 0xfe, 0xd0, 0x01, 0x32, 0x74, 0x73, + 0xee, 0xfe, 0xd5, 0xef, 0x01, 0x04, 0xf6, 0xfd, 0x04, 0x3a, 0x97, 0x92, 0x4b, 0x79, 0x20, 0x17, 0x86, 0x5d, 0x95, + 0x9e, 0x01, 0xdb, 0xfe, 0xba, 0x56, 0x4e, 0xa2, 0x94, 0x01, 0x30, 0x05, 0x00, 0x01, 0x00, 0x9a, 0x00, 0x00, 0x03, + 0x47, 0x04, 0x3a, 0x00, 0x05, 0x00, 0x2c, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x04, 0x10, 0xb1, + 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, 0x11, 0x23, 0x11, 0x21, + 0x03, 0x47, 0xfe, 0x0d, 0xba, 0x02, 0xad, 0x03, 0xa1, 0xfc, 0x5f, 0x04, 0x3a, 0x00, 0x00, 0x02, 0x00, 0x2e, 0xfe, + 0xc2, 0x04, 0x93, 0x04, 0x3a, 0x00, 0x0e, 0x00, 0x14, 0x00, 0x5d, 0xb2, 0x12, 0x15, 0x16, 0x11, 0x12, 0x39, 0xb0, + 0x12, 0x10, 0xb0, 0x04, 0xd0, 0x00, 0xb0, 0x0c, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, + 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x12, 0x3e, 0x59, 0xb1, 0x00, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x06, 0xd0, 0xb0, 0x07, 0xd0, 0xb0, 0x0c, 0x10, 0xb0, + 0x09, 0xd0, 0xb0, 0x07, 0x10, 0xb0, 0x0f, 0xd0, 0xb0, 0x10, 0xd0, 0xb0, 0x04, 0x10, 0xb1, 0x11, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x37, 0x37, 0x36, 0x13, 0x13, 0x21, 0x11, 0x33, 0x11, 0x23, + 0x11, 0x21, 0x11, 0x23, 0x13, 0x21, 0x21, 0x11, 0x21, 0x03, 0x02, 0x83, 0x40, 0x6c, 0x0f, 0x11, 0x02, 0xb9, 0x8b, + 0xb9, 0xfd, 0x0d, 0xb9, 0x01, 0x01, 0x2f, 0x01, 0xf1, 0xfe, 0xb3, 0x0b, 0x11, 0x97, 0x4f, 0x8c, 0x01, 0x18, 0x01, + 0xb0, 0xfc, 0x5d, 0xfe, 0x2b, 0x01, 0x3e, 0xfe, 0xc2, 0x01, 0xd5, 0x02, 0xf8, 0xfe, 0xfe, 0xfe, 0xbd, 0x00, 0x01, + 0x00, 0x15, 0x00, 0x00, 0x06, 0x04, 0x04, 0x3a, 0x00, 0x15, 0x00, 0x91, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, + 0x2f, 0x1b, 0xb1, 0x09, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1a, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x11, 0x2f, 0x1b, 0xb1, 0x11, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x12, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x14, 0x2f, 0x1b, 0xb1, 0x14, 0x12, 0x3e, 0x59, 0xb0, 0x02, 0x10, 0xb0, + 0x10, 0xd0, 0xb0, 0x10, 0x2f, 0xb2, 0xbf, 0x10, 0x01, 0x5d, 0xb2, 0xff, 0x10, 0x01, 0x5d, 0xb2, 0x2f, 0x10, 0x01, + 0x5d, 0xb2, 0xcf, 0x10, 0x01, 0x71, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x04, 0xd0, 0xb2, 0x08, 0x10, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x10, 0x10, 0xb0, 0x0b, 0xd0, 0xb2, 0x13, 0x00, 0x10, + 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x23, 0x11, 0x23, 0x11, 0x23, 0x01, 0x23, 0x01, 0x01, 0x33, 0x01, 0x33, 0x11, + 0x33, 0x11, 0x33, 0x01, 0x33, 0x01, 0x01, 0x23, 0x03, 0xeb, 0x82, 0xb9, 0x82, 0xfe, 0xd1, 0xea, 0x01, 0x83, 0xfe, + 0xa2, 0xe0, 0x01, 0x17, 0x7f, 0xb9, 0x7e, 0x01, 0x19, 0xe0, 0xfe, 0xa1, 0x01, 0x83, 0xea, 0x01, 0xd6, 0xfe, 0x2a, + 0x01, 0xd6, 0xfe, 0x2a, 0x02, 0x30, 0x02, 0x0a, 0xfe, 0x40, 0x01, 0xc0, 0xfe, 0x40, 0x01, 0xc0, 0xfd, 0xf5, 0xfd, + 0xd1, 0x00, 0x00, 0x01, 0x00, 0x58, 0xff, 0xed, 0x03, 0xac, 0x04, 0x4d, 0x00, 0x26, 0x00, 0x89, 0xb2, 0x03, 0x27, + 0x28, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1a, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x15, 0x2f, 0x1b, 0xb1, 0x15, 0x12, 0x3e, 0x59, 0xb0, 0x0a, 0x10, 0xb1, 0x03, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x25, 0x0a, 0x15, 0x11, 0x12, 0x39, 0xb0, 0x25, 0x2f, 0xb4, + 0x2f, 0x25, 0x3f, 0x25, 0x02, 0x5d, 0xb4, 0xbf, 0x25, 0xcf, 0x25, 0x02, 0x5d, 0xb4, 0x9f, 0x25, 0xaf, 0x25, 0x02, + 0x71, 0xb4, 0x6f, 0x25, 0x7f, 0x25, 0x02, 0x72, 0xb2, 0x06, 0x25, 0x0a, 0x11, 0x12, 0x39, 0xb1, 0x22, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x10, 0x22, 0x25, 0x11, 0x12, 0x39, 0xb2, 0x19, 0x15, 0x0a, + 0x11, 0x12, 0x39, 0xb0, 0x15, 0x10, 0xb1, 0x1c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, + 0x31, 0x01, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x23, 0x34, 0x36, 0x33, 0x32, 0x16, 0x15, 0x14, 0x06, 0x07, 0x16, + 0x15, 0x14, 0x06, 0x23, 0x22, 0x26, 0x35, 0x33, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x23, 0x23, 0x35, + 0x33, 0x36, 0x02, 0xdf, 0x74, 0x65, 0x62, 0x83, 0xb8, 0xec, 0xb1, 0xbe, 0xd4, 0x58, 0x51, 0xbd, 0xe6, 0xc0, 0xbb, + 0xf3, 0xb8, 0x8d, 0x69, 0x6a, 0x82, 0x6d, 0x73, 0xb9, 0xc9, 0xbd, 0x03, 0x12, 0x4c, 0x59, 0x66, 0x45, 0x8d, 0xb4, + 0xa3, 0x97, 0x49, 0x7a, 0x24, 0x40, 0xbc, 0x95, 0xae, 0xb7, 0x9c, 0x4f, 0x71, 0x62, 0x4e, 0x5b, 0x4f, 0x9c, 0x05, + 0x00, 0x00, 0x01, 0x00, 0x9c, 0x00, 0x00, 0x04, 0x01, 0x04, 0x3a, 0x00, 0x09, 0x00, 0x45, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, + 0x07, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x12, 0x3e, 0x59, 0xb2, 0x04, 0x07, 0x02, 0x11, 0x12, 0x39, 0xb2, + 0x09, 0x07, 0x02, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x33, 0x11, 0x23, 0x11, 0x01, 0x23, 0x11, 0x33, 0x11, 0x03, + 0x48, 0xb9, 0xb9, 0xfe, 0x0d, 0xb9, 0xb9, 0x04, 0x3a, 0xfb, 0xc6, 0x03, 0x15, 0xfc, 0xeb, 0x04, 0x3a, 0xfc, 0xea, + 0x00, 0x00, 0x01, 0x00, 0x9c, 0x00, 0x00, 0x04, 0x3f, 0x04, 0x3a, 0x00, 0x0c, 0x00, 0x78, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, + 0x08, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x12, 0x3e, 0x59, 0xb0, 0x02, 0x10, 0xb0, 0x06, 0xd0, 0xb0, 0x06, + 0x2f, 0xb2, 0x9f, 0x06, 0x01, 0x5d, 0xb2, 0xff, 0x06, 0x01, 0x5d, 0xb2, 0xcf, 0x06, 0x01, 0x71, 0xb2, 0x9f, 0x06, + 0x01, 0x71, 0xb4, 0xbf, 0x06, 0xcf, 0x06, 0x02, 0x5d, 0xb2, 0x2f, 0x06, 0x01, 0x5d, 0xb2, 0x6f, 0x06, 0x01, 0x72, + 0xb1, 0x01, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x0a, 0x01, 0x06, 0x11, 0x12, 0x39, + 0x30, 0x31, 0x01, 0x23, 0x11, 0x23, 0x11, 0x33, 0x11, 0x33, 0x01, 0x33, 0x01, 0x01, 0x23, 0x01, 0xdd, 0x87, 0xba, + 0xba, 0x79, 0x01, 0x6c, 0xe0, 0xfe, 0x54, 0x01, 0xd0, 0xeb, 0x01, 0xcd, 0xfe, 0x33, 0x04, 0x3a, 0xfe, 0x36, 0x01, + 0xca, 0xfd, 0xf8, 0xfd, 0xce, 0x00, 0x00, 0x01, 0x00, 0x2c, 0x00, 0x00, 0x04, 0x03, 0x04, 0x3a, 0x00, 0x0f, 0x00, + 0x4f, 0xb2, 0x04, 0x10, 0x11, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, + 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x10, 0xb1, 0x03, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, 0x10, 0xb1, 0x0a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0x30, 0x31, 0x01, 0x11, 0x23, 0x11, 0x21, 0x03, 0x02, 0x06, 0x07, 0x23, 0x35, 0x37, 0x36, 0x36, 0x37, + 0x13, 0x04, 0x03, 0xba, 0xfe, 0x90, 0x16, 0x12, 0x97, 0xa4, 0x4a, 0x35, 0x5a, 0x4e, 0x0b, 0x14, 0x04, 0x3a, 0xfb, + 0xc6, 0x03, 0xa1, 0xfe, 0x6b, 0xfe, 0xe9, 0xf0, 0x05, 0xa3, 0x04, 0x0a, 0xbc, 0xfe, 0x01, 0xcf, 0x00, 0x00, 0x01, + 0x00, 0x9d, 0x00, 0x00, 0x05, 0x52, 0x04, 0x3a, 0x00, 0x0c, 0x00, 0x59, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, + 0x2f, 0x1b, 0xb1, 0x01, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1a, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x12, + 0x3e, 0x59, 0xb2, 0x00, 0x0b, 0x03, 0x11, 0x12, 0x39, 0xb2, 0x05, 0x0b, 0x03, 0x11, 0x12, 0x39, 0xb2, 0x08, 0x0b, + 0x03, 0x11, 0x12, 0x39, 0x30, 0x31, 0x25, 0x01, 0x33, 0x11, 0x23, 0x11, 0x01, 0x23, 0x01, 0x11, 0x23, 0x11, 0x33, + 0x02, 0xfb, 0x01, 0x70, 0xe7, 0xb9, 0xfe, 0xa2, 0x80, 0xfe, 0x9b, 0xb9, 0xf0, 0xf5, 0x03, 0x45, 0xfb, 0xc6, 0x03, + 0x13, 0xfc, 0xed, 0x03, 0x24, 0xfc, 0xdc, 0x04, 0x3a, 0x00, 0x01, 0x00, 0x9c, 0x00, 0x00, 0x04, 0x00, 0x04, 0x3a, + 0x00, 0x0b, 0x00, 0x8b, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1a, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, + 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, + 0xb0, 0x00, 0x10, 0xb0, 0x09, 0xd0, 0xb0, 0x09, 0x2f, 0xb2, 0x6f, 0x09, 0x01, 0x5d, 0xb4, 0xbf, 0x09, 0xcf, 0x09, + 0x02, 0x5d, 0xb2, 0x3f, 0x09, 0x01, 0x71, 0xb4, 0xcf, 0x09, 0xdf, 0x09, 0x02, 0x71, 0xb2, 0x0f, 0x09, 0x01, 0x72, + 0xb4, 0x9f, 0x09, 0xaf, 0x09, 0x02, 0x71, 0xb2, 0xff, 0x09, 0x01, 0x5d, 0xb2, 0x0f, 0x09, 0x01, 0x71, 0xb2, 0x9f, + 0x09, 0x01, 0x5d, 0xb2, 0x2f, 0x09, 0x01, 0x5d, 0xb4, 0x6f, 0x09, 0x7f, 0x09, 0x02, 0x72, 0xb1, 0x02, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x21, 0x23, 0x11, 0x21, 0x11, 0x23, 0x11, 0x33, 0x11, + 0x21, 0x11, 0x33, 0x04, 0x00, 0xb9, 0xfe, 0x0f, 0xba, 0xba, 0x01, 0xf1, 0xb9, 0x01, 0xce, 0xfe, 0x32, 0x04, 0x3a, + 0xfe, 0x2b, 0x01, 0xd5, 0x00, 0x00, 0x01, 0x00, 0x9c, 0x00, 0x00, 0x04, 0x01, 0x04, 0x3a, 0x00, 0x07, 0x00, 0x39, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, + 0x3e, 0x59, 0xb0, 0x06, 0x10, 0xb1, 0x02, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, + 0x21, 0x23, 0x11, 0x21, 0x11, 0x23, 0x11, 0x21, 0x04, 0x01, 0xb9, 0xfe, 0x0e, 0xba, 0x03, 0x65, 0x03, 0xa1, 0xfc, + 0x5f, 0x04, 0x3a, 0x00, 0x00, 0x01, 0x00, 0x28, 0x00, 0x00, 0x03, 0xb0, 0x04, 0x3a, 0x00, 0x07, 0x00, 0x32, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, + 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x06, 0x10, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0xd0, 0xb0, 0x05, 0xd0, 0x30, 0x31, 0x01, 0x21, 0x11, 0x23, 0x11, 0x21, 0x35, 0x21, + 0x03, 0xb0, 0xfe, 0x95, 0xb9, 0xfe, 0x9c, 0x03, 0x88, 0x03, 0xa4, 0xfc, 0x5c, 0x03, 0xa4, 0x96, 0x00, 0x03, 0x00, + 0x64, 0xfe, 0x60, 0x05, 0x69, 0x06, 0x00, 0x00, 0x1a, 0x00, 0x25, 0x00, 0x30, 0x00, 0x81, 0xb2, 0x07, 0x31, 0x32, + 0x11, 0x12, 0x39, 0xb0, 0x07, 0x10, 0xb0, 0x20, 0xd0, 0xb0, 0x07, 0x10, 0xb0, 0x2b, 0xd0, 0x00, 0xb0, 0x06, 0x2f, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, + 0x2f, 0x1b, 0xb1, 0x0a, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x13, 0x2f, 0x1b, 0xb1, 0x13, 0x14, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x17, 0x2f, 0x1b, 0xb1, 0x17, 0x12, 0x3e, 0x59, 0xb0, 0x0a, 0x10, 0xb1, 0x1e, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x10, 0x10, 0xb1, 0x23, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb0, 0x29, 0xd0, 0xb0, 0x1e, 0x10, 0xb0, 0x2e, 0xd0, 0x30, 0x31, 0x13, 0x10, 0x12, 0x33, 0x32, 0x17, 0x11, 0x33, + 0x11, 0x36, 0x33, 0x32, 0x12, 0x11, 0x14, 0x02, 0x23, 0x22, 0x27, 0x11, 0x23, 0x11, 0x06, 0x23, 0x22, 0x02, 0x35, + 0x25, 0x34, 0x26, 0x23, 0x22, 0x07, 0x11, 0x16, 0x33, 0x32, 0x36, 0x25, 0x14, 0x16, 0x33, 0x32, 0x37, 0x11, 0x26, + 0x23, 0x22, 0x06, 0x64, 0xd2, 0xb7, 0x55, 0x40, 0xb9, 0x46, 0x5e, 0xb8, 0xd2, 0xd1, 0xb7, 0x61, 0x45, 0xb9, 0x42, + 0x55, 0xb6, 0xd1, 0x04, 0x4c, 0x8c, 0x7b, 0x3f, 0x2f, 0x2d, 0x43, 0x7c, 0x89, 0xfc, 0x6d, 0x82, 0x7a, 0x3a, 0x2f, + 0x2a, 0x3d, 0x7a, 0x84, 0x02, 0x09, 0x01, 0x0f, 0x01, 0x36, 0x1d, 0x01, 0xcf, 0xfe, 0x2b, 0x23, 0xfe, 0xca, 0xfe, + 0xdc, 0xef, 0xfe, 0xe6, 0x20, 0xfe, 0x55, 0x01, 0xa8, 0x1d, 0x01, 0x1a, 0xf5, 0x0f, 0xcc, 0xe1, 0x14, 0xfc, 0xf1, + 0x11, 0xc0, 0xb2, 0xb6, 0xbc, 0x12, 0x03, 0x11, 0x11, 0xda, 0x00, 0x00, 0x01, 0x00, 0x9c, 0xfe, 0xbf, 0x04, 0x82, + 0x04, 0x3a, 0x00, 0x0b, 0x00, 0x3c, 0x00, 0xb0, 0x08, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, + 0x00, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x12, 0x3e, 0x59, 0xb1, 0x02, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x06, 0xd0, 0x30, 0x31, 0x13, 0x33, 0x11, 0x21, 0x11, 0x33, 0x11, 0x33, 0x03, 0x23, + 0x11, 0x21, 0x9c, 0xba, 0x01, 0xf2, 0xb9, 0x81, 0x12, 0xa6, 0xfc, 0xd2, 0x04, 0x3a, 0xfc, 0x5d, 0x03, 0xa3, 0xfc, + 0x5d, 0xfe, 0x28, 0x01, 0x41, 0x00, 0x01, 0x00, 0x67, 0x00, 0x00, 0x03, 0xbd, 0x04, 0x3b, 0x00, 0x10, 0x00, 0x47, + 0xb2, 0x04, 0x11, 0x12, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0f, 0x2f, 0x1b, 0xb1, 0x0f, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb2, 0x0c, 0x0f, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x0c, 0x2f, + 0xb1, 0x04, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x21, 0x23, 0x11, 0x06, 0x23, + 0x22, 0x26, 0x27, 0x11, 0x33, 0x11, 0x16, 0x33, 0x32, 0x37, 0x11, 0x33, 0x03, 0xbd, 0xba, 0x7a, 0x80, 0xcb, 0xd5, + 0x02, 0xb9, 0x05, 0xe4, 0x80, 0x7a, 0xba, 0x01, 0x88, 0x20, 0xd0, 0xc0, 0x01, 0x43, 0xfe, 0xb7, 0xf2, 0x20, 0x02, + 0x1a, 0x00, 0x00, 0x01, 0x00, 0x9c, 0x00, 0x00, 0x05, 0xe0, 0x04, 0x3a, 0x00, 0x0b, 0x00, 0x49, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, + 0xb1, 0x03, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1a, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x12, 0x3e, 0x59, 0xb1, 0x01, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x05, 0xd0, 0xb0, 0x06, 0xd0, 0x30, 0x31, 0x01, 0x11, 0x21, 0x11, 0x33, 0x11, + 0x21, 0x11, 0x33, 0x11, 0x21, 0x11, 0x01, 0x56, 0x01, 0x8c, 0xb9, 0x01, 0x8b, 0xba, 0xfa, 0xbc, 0x04, 0x3a, 0xfc, + 0x5d, 0x03, 0xa3, 0xfc, 0x5d, 0x03, 0xa3, 0xfb, 0xc6, 0x04, 0x3a, 0x00, 0x00, 0x01, 0x00, 0x91, 0xfe, 0xbf, 0x06, + 0x6d, 0x04, 0x3a, 0x00, 0x0f, 0x00, 0x4c, 0x00, 0xb0, 0x0c, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, + 0xb1, 0x00, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1a, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, + 0x1b, 0xb1, 0x0d, 0x12, 0x3e, 0x59, 0xb1, 0x01, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x05, 0xd0, 0xb0, 0x09, 0xd0, 0x30, 0x31, 0x01, 0x11, 0x21, 0x11, 0x33, 0x11, 0x21, 0x11, 0x33, 0x11, 0x33, 0x03, + 0x23, 0x11, 0x21, 0x11, 0x01, 0x4b, 0x01, 0x8c, 0xb9, 0x01, 0x8b, 0xba, 0x98, 0x12, 0xa6, 0xfa, 0xdc, 0x04, 0x3a, + 0xfc, 0x5d, 0x03, 0xa3, 0xfc, 0x5d, 0x03, 0xa3, 0xfc, 0x5d, 0xfe, 0x28, 0x01, 0x41, 0x04, 0x3a, 0x00, 0x00, 0x02, + 0x00, 0x1e, 0x00, 0x00, 0x04, 0xbf, 0x04, 0x3a, 0x00, 0x0c, 0x00, 0x15, 0x00, 0x61, 0xb2, 0x01, 0x16, 0x17, 0x11, + 0x12, 0x39, 0xb0, 0x01, 0x10, 0xb0, 0x0d, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, + 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x12, 0x3e, 0x59, 0xb2, 0x02, 0x00, + 0x09, 0x11, 0x12, 0x39, 0xb0, 0x02, 0x2f, 0xb0, 0x00, 0x10, 0xb1, 0x0b, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x02, 0x10, 0xb1, 0x0d, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x09, 0x10, 0xb1, 0x0e, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x13, 0x21, 0x11, + 0x21, 0x16, 0x16, 0x15, 0x14, 0x06, 0x23, 0x21, 0x11, 0x21, 0x01, 0x11, 0x21, 0x32, 0x36, 0x35, 0x34, 0x26, 0x27, + 0x1e, 0x01, 0xfa, 0x01, 0x19, 0xb8, 0xd6, 0xdc, 0xba, 0xfe, 0x36, 0xfe, 0xbf, 0x01, 0xfa, 0x01, 0x13, 0x68, 0x72, + 0x6f, 0x64, 0x04, 0x3a, 0xfe, 0x8b, 0x02, 0xbc, 0xa1, 0xa2, 0xc4, 0x03, 0xa2, 0xfe, 0x8c, 0xfe, 0x69, 0x6b, 0x5d, + 0x5a, 0x73, 0x02, 0x00, 0x03, 0x00, 0x9d, 0x00, 0x00, 0x05, 0x7f, 0x04, 0x3a, 0x00, 0x0a, 0x00, 0x0e, 0x00, 0x17, + 0x00, 0x6f, 0xb2, 0x06, 0x18, 0x19, 0x11, 0x12, 0x39, 0xb0, 0x06, 0x10, 0xb0, 0x0c, 0xd0, 0xb0, 0x06, 0x10, 0xb0, + 0x13, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, + 0x07, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x12, 0x3e, 0x59, 0xb2, 0x00, + 0x0d, 0x07, 0x11, 0x12, 0x39, 0xb0, 0x00, 0x2f, 0xb1, 0x0f, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb0, 0x07, 0x10, 0xb1, 0x10, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, + 0x21, 0x16, 0x16, 0x15, 0x14, 0x06, 0x23, 0x21, 0x11, 0x33, 0x01, 0x23, 0x11, 0x33, 0x01, 0x11, 0x21, 0x32, 0x36, + 0x35, 0x34, 0x26, 0x27, 0x01, 0x56, 0x01, 0x19, 0xb8, 0xd6, 0xdc, 0xba, 0xfe, 0x36, 0xb9, 0x04, 0x29, 0xba, 0xba, + 0xfb, 0xd7, 0x01, 0x13, 0x68, 0x72, 0x6f, 0x64, 0x02, 0xc5, 0x02, 0xbc, 0xa1, 0xa2, 0xc4, 0x04, 0x3a, 0xfb, 0xc6, + 0x04, 0x3a, 0xfd, 0xf4, 0xfe, 0x69, 0x6b, 0x5d, 0x5a, 0x73, 0x02, 0x00, 0x02, 0x00, 0x9d, 0x00, 0x00, 0x03, 0xfd, + 0x04, 0x3a, 0x00, 0x0a, 0x00, 0x13, 0x00, 0x4f, 0xb2, 0x07, 0x14, 0x15, 0x11, 0x12, 0x39, 0xb0, 0x07, 0x10, 0xb0, + 0x0d, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x12, 0x3e, 0x59, 0xb2, 0x00, 0x09, 0x07, 0x11, 0x12, 0x39, 0xb0, 0x00, + 0x2f, 0xb1, 0x0b, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x07, 0x10, 0xb1, 0x0c, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, 0x16, 0x16, 0x15, 0x14, 0x06, 0x23, + 0x21, 0x11, 0x33, 0x11, 0x11, 0x21, 0x32, 0x36, 0x35, 0x34, 0x26, 0x27, 0x01, 0x56, 0x01, 0x19, 0xb8, 0xd6, 0xdc, + 0xba, 0xfe, 0x36, 0xb9, 0x01, 0x13, 0x68, 0x72, 0x6f, 0x64, 0x02, 0xc5, 0x02, 0xbc, 0xa1, 0xa2, 0xc4, 0x04, 0x3a, + 0xfd, 0xf4, 0xfe, 0x69, 0x6b, 0x5d, 0x5a, 0x73, 0x02, 0x00, 0x01, 0x00, 0x64, 0xff, 0xec, 0x03, 0xe0, 0x04, 0x4e, + 0x00, 0x1f, 0x00, 0x85, 0xb2, 0x00, 0x20, 0x21, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, + 0x1b, 0xb1, 0x08, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x12, 0x3e, 0x59, + 0xb0, 0x08, 0x10, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x1d, 0x08, 0x10, + 0x11, 0x12, 0x39, 0xb0, 0x1d, 0x2f, 0xb4, 0x2f, 0x1d, 0x3f, 0x1d, 0x02, 0x5d, 0xb4, 0xbf, 0x1d, 0xcf, 0x1d, 0x02, + 0x5d, 0xb4, 0x9f, 0x1d, 0xaf, 0x1d, 0x02, 0x71, 0xb4, 0x6f, 0x1d, 0x7f, 0x1d, 0x02, 0x72, 0xb2, 0x03, 0x08, 0x1d, + 0x11, 0x12, 0x39, 0xb2, 0x14, 0x10, 0x08, 0x11, 0x12, 0x39, 0xb0, 0x10, 0x10, 0xb1, 0x17, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x1d, 0x10, 0xb1, 0x1a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0x30, 0x31, 0x01, 0x22, 0x06, 0x15, 0x23, 0x34, 0x36, 0x36, 0x33, 0x32, 0x00, 0x15, 0x15, 0x14, 0x06, + 0x06, 0x23, 0x22, 0x26, 0x35, 0x33, 0x14, 0x16, 0x33, 0x32, 0x36, 0x37, 0x21, 0x35, 0x21, 0x26, 0x26, 0x02, 0x08, + 0x63, 0x91, 0xb0, 0x76, 0xc4, 0x6a, 0xd3, 0x01, 0x05, 0x77, 0xd7, 0x8a, 0xb4, 0xf0, 0xb0, 0x8e, 0x66, 0x77, 0x9a, + 0x0c, 0xfe, 0x6a, 0x01, 0x94, 0x0e, 0x96, 0x03, 0xb6, 0x7e, 0x56, 0x5d, 0xaa, 0x65, 0xfe, 0xcf, 0xf6, 0x1f, 0x98, + 0xfb, 0x89, 0xe0, 0xa7, 0x66, 0x8b, 0xb8, 0xa1, 0x98, 0x92, 0xb1, 0x00, 0x02, 0x00, 0x9d, 0xff, 0xec, 0x06, 0x30, + 0x04, 0x4e, 0x00, 0x14, 0x00, 0x1f, 0x00, 0xa0, 0xb2, 0x0d, 0x20, 0x21, 0x11, 0x12, 0x39, 0xb0, 0x0d, 0x10, 0xb0, + 0x15, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x14, 0x2f, 0x1b, 0xb1, 0x14, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x11, 0x2f, 0x1b, 0xb1, + 0x11, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x12, 0x3e, 0x59, 0xb2, 0x00, + 0x11, 0x14, 0x11, 0x12, 0x39, 0xb0, 0x00, 0x2f, 0xb4, 0xbf, 0x00, 0xcf, 0x00, 0x02, 0x5d, 0xb4, 0x9f, 0x00, 0xaf, + 0x00, 0x02, 0x71, 0xb2, 0xff, 0x00, 0x01, 0x5d, 0xb2, 0x0f, 0x00, 0x01, 0x71, 0xb4, 0x2f, 0x00, 0x3f, 0x00, 0x02, + 0x5d, 0xb6, 0x5f, 0x00, 0x6f, 0x00, 0x7f, 0x00, 0x03, 0x72, 0xb1, 0x10, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x0c, 0x10, 0xb1, 0x18, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x04, 0x10, 0xb1, 0x1d, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, 0x36, + 0x00, 0x33, 0x32, 0x00, 0x17, 0x17, 0x14, 0x06, 0x06, 0x23, 0x22, 0x00, 0x27, 0x21, 0x11, 0x23, 0x11, 0x33, 0x01, + 0x14, 0x16, 0x20, 0x36, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x01, 0x56, 0x01, 0x04, 0x15, 0x01, 0x09, 0xca, 0xd4, + 0x01, 0x0e, 0x0b, 0x01, 0x7c, 0xe0, 0x90, 0xd1, 0xfe, 0xf6, 0x10, 0xfe, 0xfd, 0xb9, 0xb9, 0x01, 0xba, 0xa7, 0x01, + 0x1a, 0xa5, 0xa8, 0x8c, 0x8a, 0xa8, 0x02, 0x6f, 0xd8, 0x01, 0x07, 0xfe, 0xe2, 0xe5, 0x3a, 0x9e, 0xfe, 0x89, 0x01, + 0x11, 0xda, 0xfe, 0x29, 0x04, 0x3a, 0xfd, 0xd7, 0xb4, 0xda, 0xde, 0xc6, 0xb1, 0xde, 0xda, 0x00, 0x02, 0x00, 0x2f, + 0x00, 0x00, 0x03, 0xc7, 0x04, 0x3a, 0x00, 0x0d, 0x00, 0x16, 0x00, 0x63, 0xb2, 0x14, 0x17, 0x18, 0x11, 0x12, 0x39, + 0xb0, 0x14, 0x10, 0xb0, 0x0d, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1a, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x12, 0x3e, 0x59, 0xb2, 0x12, 0x00, 0x01, 0x11, 0x12, 0x39, 0xb0, 0x12, 0x2f, 0xb1, + 0x03, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x07, 0x03, 0x00, 0x11, 0x12, 0x39, 0xb0, + 0x00, 0x10, 0xb1, 0x13, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x11, 0x23, + 0x11, 0x21, 0x03, 0x23, 0x01, 0x26, 0x26, 0x35, 0x34, 0x36, 0x37, 0x03, 0x14, 0x16, 0x17, 0x21, 0x11, 0x21, 0x22, + 0x06, 0x03, 0xc7, 0xba, 0xfe, 0xe9, 0xff, 0xc8, 0x01, 0x10, 0x68, 0x6f, 0xde, 0xba, 0xde, 0x6c, 0x59, 0x01, 0x26, + 0xfe, 0xf6, 0x67, 0x7a, 0x04, 0x3a, 0xfb, 0xc6, 0x01, 0xa5, 0xfe, 0x5b, 0x01, 0xc1, 0x26, 0x9f, 0x6a, 0x94, 0xb5, + 0x01, 0xfe, 0xb4, 0x4f, 0x61, 0x01, 0x01, 0x67, 0x65, 0x00, 0x01, 0xff, 0xe8, 0xfe, 0x4b, 0x03, 0xdf, 0x06, 0x00, + 0x00, 0x22, 0x00, 0x87, 0xb2, 0x0d, 0x23, 0x24, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x1f, 0x2f, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x19, 0x2f, 0x1b, 0xb1, 0x19, + 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x14, 0x3e, 0x59, 0xb2, 0xbf, 0x1f, + 0x01, 0x5d, 0xb2, 0x2f, 0x1f, 0x01, 0x5d, 0xb2, 0x0f, 0x1f, 0x01, 0x5d, 0xb2, 0x1e, 0x19, 0x1f, 0x11, 0x12, 0x39, + 0xb0, 0x1e, 0x2f, 0xb0, 0x21, 0xd0, 0xb1, 0x01, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, + 0x02, 0x19, 0x04, 0x11, 0x12, 0x39, 0xb0, 0x0a, 0x10, 0xb1, 0x0f, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb0, 0x04, 0x10, 0xb1, 0x15, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x01, + 0x10, 0xb0, 0x1b, 0xd0, 0x30, 0x31, 0x01, 0x21, 0x11, 0x36, 0x33, 0x20, 0x13, 0x11, 0x14, 0x06, 0x23, 0x22, 0x27, + 0x37, 0x16, 0x32, 0x36, 0x35, 0x11, 0x34, 0x26, 0x23, 0x22, 0x06, 0x07, 0x11, 0x23, 0x11, 0x23, 0x35, 0x33, 0x35, + 0x33, 0x15, 0x21, 0x02, 0x63, 0xfe, 0xe2, 0x7b, 0xc5, 0x01, 0x57, 0x03, 0xaa, 0x98, 0x3d, 0x36, 0x0f, 0x23, 0x82, + 0x48, 0x69, 0x70, 0x5a, 0x88, 0x26, 0xb9, 0xa4, 0xa4, 0xb9, 0x01, 0x1e, 0x04, 0xb9, 0xfe, 0xfe, 0x97, 0xfe, 0x7d, + 0xfc, 0xdc, 0xaa, 0xb2, 0x12, 0x93, 0x0d, 0x68, 0x5c, 0x03, 0x20, 0x78, 0x72, 0x60, 0x4e, 0xfc, 0xfd, 0x04, 0xb9, + 0x98, 0xaf, 0xaf, 0x00, 0x00, 0x01, 0x00, 0x67, 0xff, 0xec, 0x03, 0xf7, 0x04, 0x4e, 0x00, 0x1f, 0x00, 0x9f, 0xb2, + 0x00, 0x20, 0x21, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x1a, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x12, 0x3e, 0x59, 0xb1, 0x00, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x03, 0x08, 0x10, 0x11, 0x12, 0x39, 0xb2, 0x1b, 0x10, 0x08, 0x11, + 0x12, 0x39, 0xb0, 0x1b, 0x2f, 0xb4, 0x0f, 0x1b, 0x1f, 0x1b, 0x02, 0x72, 0xb4, 0xbf, 0x1b, 0xcf, 0x1b, 0x02, 0x5d, + 0xb4, 0x9f, 0x1b, 0xaf, 0x1b, 0x02, 0x71, 0xb4, 0xcf, 0x1b, 0xdf, 0x1b, 0x02, 0x71, 0xb2, 0xff, 0x1b, 0x01, 0x5d, + 0xb2, 0x0f, 0x1b, 0x01, 0x71, 0xb4, 0x2f, 0x1b, 0x3f, 0x1b, 0x02, 0x5d, 0xb4, 0x6f, 0x1b, 0x7f, 0x1b, 0x02, 0x72, + 0xb2, 0xbf, 0x1b, 0x01, 0x72, 0xb2, 0x14, 0x10, 0x1b, 0x11, 0x12, 0x39, 0xb0, 0x10, 0x10, 0xb1, 0x17, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x1b, 0x10, 0xb1, 0x1c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x25, 0x32, 0x36, 0x37, 0x33, 0x0e, 0x02, 0x23, 0x22, 0x00, 0x11, 0x35, 0x34, + 0x36, 0x36, 0x33, 0x32, 0x16, 0x17, 0x23, 0x26, 0x26, 0x23, 0x22, 0x06, 0x07, 0x21, 0x15, 0x21, 0x16, 0x16, 0x02, + 0x48, 0x63, 0x94, 0x08, 0xb0, 0x05, 0x78, 0xc4, 0x6e, 0xde, 0xfe, 0xfd, 0x75, 0xd8, 0x94, 0xb6, 0xf1, 0x08, 0xb0, + 0x08, 0x8f, 0x68, 0x82, 0x9a, 0x0a, 0x01, 0x94, 0xfe, 0x6c, 0x0a, 0x99, 0x83, 0x78, 0x5a, 0x5e, 0xa8, 0x63, 0x01, + 0x28, 0x01, 0x00, 0x1e, 0x9f, 0xf7, 0x86, 0xda, 0xae, 0x69, 0x87, 0xb1, 0x9d, 0x98, 0xa0, 0xad, 0x00, 0x00, 0x02, + 0x00, 0x27, 0x00, 0x00, 0x06, 0x86, 0x04, 0x3a, 0x00, 0x16, 0x00, 0x1f, 0x00, 0x7d, 0xb2, 0x09, 0x20, 0x21, 0x11, + 0x12, 0x39, 0xb0, 0x09, 0x10, 0xb0, 0x17, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, + 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x0f, 0x2f, 0x1b, 0xb1, 0x0f, 0x12, 0x3e, 0x59, 0xb2, 0x01, 0x00, 0x08, 0x11, 0x12, 0x39, 0xb0, 0x01, + 0x2f, 0xb0, 0x00, 0x10, 0xb1, 0x0a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0f, 0x10, + 0xb1, 0x11, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x01, 0x10, 0xb1, 0x17, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, 0x10, 0xb1, 0x18, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x11, 0x21, 0x16, 0x16, 0x15, 0x14, 0x06, 0x07, 0x21, 0x11, 0x21, 0x03, + 0x02, 0x06, 0x07, 0x23, 0x35, 0x37, 0x36, 0x36, 0x37, 0x13, 0x01, 0x11, 0x21, 0x32, 0x36, 0x35, 0x34, 0x26, 0x27, + 0x03, 0xdf, 0x01, 0x1e, 0xb6, 0xd3, 0xd3, 0xb7, 0xfe, 0x29, 0xfe, 0xaf, 0x17, 0x14, 0x9c, 0xa5, 0x41, 0x36, 0x55, + 0x4d, 0x0d, 0x17, 0x02, 0xbc, 0x01, 0x13, 0x65, 0x75, 0x72, 0x63, 0x04, 0x3a, 0xfe, 0x64, 0x03, 0xb5, 0x94, 0x93, + 0xbc, 0x03, 0x03, 0xa1, 0xfe, 0x5a, 0xfe, 0xeb, 0xe4, 0x02, 0xa3, 0x04, 0x0a, 0xa7, 0xd3, 0x02, 0x0f, 0xfd, 0xcc, + 0xfe, 0x8f, 0x69, 0x56, 0x51, 0x60, 0x01, 0x00, 0x00, 0x02, 0x00, 0x9c, 0x00, 0x00, 0x06, 0xa7, 0x04, 0x3a, 0x00, + 0x12, 0x00, 0x1b, 0x00, 0x7e, 0xb2, 0x01, 0x1c, 0x1d, 0x11, 0x12, 0x39, 0xb0, 0x01, 0x10, 0xb0, 0x13, 0xd0, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x11, + 0x2f, 0x1b, 0xb1, 0x11, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x12, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0f, 0x2f, 0x1b, 0xb1, 0x0f, 0x12, 0x3e, 0x59, 0xb2, 0x01, 0x11, 0x0b, 0x11, + 0x12, 0x39, 0xb0, 0x01, 0x2f, 0xb0, 0x04, 0xd0, 0xb0, 0x01, 0x10, 0xb1, 0x0d, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0x10, 0xb1, 0x13, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb0, 0x0b, 0x10, 0xb1, 0x14, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, + 0x11, 0x33, 0x11, 0x21, 0x16, 0x16, 0x15, 0x14, 0x06, 0x23, 0x21, 0x11, 0x21, 0x11, 0x23, 0x11, 0x33, 0x01, 0x11, + 0x21, 0x32, 0x36, 0x35, 0x34, 0x26, 0x27, 0x01, 0x56, 0x01, 0xf1, 0xb9, 0x01, 0x22, 0xb4, 0xd1, 0xd9, 0xbd, 0xfe, + 0x36, 0xfe, 0x0f, 0xba, 0xba, 0x02, 0xaa, 0x01, 0x13, 0x65, 0x75, 0x72, 0x63, 0x02, 0xa1, 0x01, 0x99, 0xfe, 0x63, + 0x04, 0xb1, 0x96, 0x97, 0xbb, 0x02, 0x0a, 0xfd, 0xf6, 0x04, 0x3a, 0xfd, 0xcc, 0xfe, 0x8f, 0x69, 0x56, 0x51, 0x60, + 0x01, 0x00, 0x00, 0x01, 0xff, 0xfd, 0x00, 0x00, 0x03, 0xdf, 0x06, 0x00, 0x00, 0x19, 0x00, 0x7b, 0xb2, 0x0c, 0x1a, + 0x1b, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x16, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x12, 0x3e, 0x59, 0xb2, 0xbf, 0x16, 0x01, 0x5d, 0xb2, 0x2f, 0x16, 0x01, 0x5d, + 0xb2, 0x0f, 0x16, 0x01, 0x5d, 0xb2, 0x19, 0x10, 0x16, 0x11, 0x12, 0x39, 0xb0, 0x19, 0x2f, 0xb1, 0x00, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x02, 0x04, 0x07, 0x11, 0x12, 0x39, 0xb0, 0x04, 0x10, 0xb1, + 0x0c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x00, 0x10, 0xb0, 0x12, 0xd0, 0xb0, 0x19, + 0x10, 0xb0, 0x14, 0xd0, 0x30, 0x31, 0x01, 0x21, 0x11, 0x36, 0x33, 0x20, 0x13, 0x11, 0x23, 0x11, 0x26, 0x26, 0x23, + 0x22, 0x06, 0x07, 0x11, 0x23, 0x11, 0x23, 0x35, 0x33, 0x35, 0x33, 0x15, 0x21, 0x02, 0x79, 0xfe, 0xcc, 0x7b, 0xc5, + 0x01, 0x57, 0x03, 0xb9, 0x01, 0x69, 0x6f, 0x5a, 0x88, 0x26, 0xb9, 0x8f, 0x8f, 0xb9, 0x01, 0x34, 0x04, 0xbe, 0xfe, + 0xf9, 0x97, 0xfe, 0x7d, 0xfd, 0x35, 0x02, 0xcc, 0x75, 0x70, 0x60, 0x4e, 0xfc, 0xfd, 0x04, 0xbe, 0x97, 0xab, 0xab, + 0x00, 0x00, 0x01, 0x00, 0x9c, 0xfe, 0x9c, 0x04, 0x01, 0x04, 0x3a, 0x00, 0x0b, 0x00, 0x46, 0x00, 0xb0, 0x08, 0x2f, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, + 0x2f, 0x1b, 0xb1, 0x03, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x12, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x12, 0x3e, 0x59, 0xb1, 0x01, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x11, 0x21, 0x11, 0x33, 0x11, 0x21, 0x11, 0x23, 0x11, + 0x21, 0x11, 0x01, 0x56, 0x01, 0xf2, 0xb9, 0xfe, 0xad, 0xb9, 0xfe, 0xa7, 0x04, 0x3a, 0xfc, 0x5d, 0x03, 0xa3, 0xfb, + 0xc6, 0xfe, 0x9c, 0x01, 0x64, 0x04, 0x3a, 0x00, 0x01, 0x00, 0x9c, 0xff, 0xec, 0x06, 0x75, 0x05, 0xb0, 0x00, 0x20, + 0x00, 0x61, 0xb2, 0x07, 0x21, 0x22, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, + 0x00, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0e, 0x2f, 0x1b, 0xb1, 0x0e, 0x1e, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x17, 0x2f, 0x1b, 0xb1, 0x17, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, + 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x12, 0x3e, 0x59, 0xb2, + 0x07, 0x00, 0x04, 0x11, 0x12, 0x39, 0xb1, 0x13, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x1c, 0xd0, 0x30, 0x31, 0x01, 0x11, 0x14, 0x06, 0x23, 0x22, 0x26, 0x27, 0x06, 0x06, 0x23, 0x22, 0x26, 0x27, 0x11, + 0x33, 0x11, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x11, 0x33, 0x11, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x11, 0x06, + 0x75, 0xe1, 0xc3, 0x6d, 0xab, 0x31, 0x34, 0xb2, 0x71, 0xbd, 0xd7, 0x01, 0xc1, 0x72, 0x62, 0x72, 0x82, 0xc7, 0x7c, + 0x69, 0x6a, 0x7a, 0x05, 0xb0, 0xfb, 0xde, 0xc6, 0xdc, 0x57, 0x59, 0x59, 0x57, 0xdb, 0xc3, 0x04, 0x26, 0xfb, 0xdd, + 0x7b, 0x8a, 0x89, 0x7c, 0x04, 0x23, 0xfb, 0xdd, 0x7d, 0x88, 0x89, 0x7d, 0x04, 0x22, 0x00, 0x00, 0x01, 0x00, 0x81, + 0xff, 0xeb, 0x05, 0xad, 0x04, 0x3a, 0x00, 0x1e, 0x00, 0x61, 0xb2, 0x06, 0x1f, 0x20, 0x11, 0x12, 0x39, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, + 0x1b, 0xb1, 0x0c, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x15, 0x2f, 0x1b, 0xb1, 0x15, 0x1a, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, + 0x2f, 0x1b, 0xb1, 0x08, 0x12, 0x3e, 0x59, 0xb2, 0x06, 0x15, 0x04, 0x11, 0x12, 0x39, 0xb1, 0x11, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x1a, 0xd0, 0x30, 0x31, 0x01, 0x11, 0x14, 0x06, 0x23, 0x22, 0x27, + 0x06, 0x23, 0x22, 0x26, 0x27, 0x11, 0x33, 0x11, 0x16, 0x16, 0x33, 0x32, 0x36, 0x35, 0x11, 0x33, 0x11, 0x14, 0x16, + 0x33, 0x32, 0x36, 0x37, 0x11, 0x05, 0xad, 0xca, 0xae, 0xc6, 0x59, 0x5f, 0xce, 0xa7, 0xc0, 0x01, 0xb9, 0x01, 0x5b, + 0x53, 0x62, 0x6f, 0xba, 0x65, 0x5c, 0x59, 0x65, 0x01, 0x04, 0x3a, 0xfd, 0x27, 0xb0, 0xc6, 0x94, 0x94, 0xc3, 0xb0, + 0x02, 0xdc, 0xfd, 0x23, 0x66, 0x75, 0x78, 0x67, 0x02, 0xd9, 0xfd, 0x27, 0x67, 0x78, 0x75, 0x66, 0x02, 0xdd, 0x00, + 0x00, 0x02, 0xff, 0xdc, 0x00, 0x00, 0x03, 0xfc, 0x06, 0x16, 0x00, 0x11, 0x00, 0x1a, 0x00, 0x74, 0xb2, 0x14, 0x1b, + 0x1c, 0x11, 0x12, 0x39, 0xb0, 0x14, 0x10, 0xb0, 0x03, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0e, 0x2f, 0x1b, + 0xb1, 0x0e, 0x20, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x12, 0x3e, 0x59, 0xb2, + 0x11, 0x0e, 0x08, 0x11, 0x12, 0x39, 0xb0, 0x11, 0x2f, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb2, 0x02, 0x0e, 0x08, 0x11, 0x12, 0x39, 0xb0, 0x02, 0x2f, 0xb0, 0x00, 0x10, 0xb0, 0x0a, 0xd0, 0xb0, + 0x11, 0x10, 0xb0, 0x0c, 0xd0, 0xb0, 0x02, 0x10, 0xb1, 0x12, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb0, 0x08, 0x10, 0xb1, 0x13, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, + 0x21, 0x11, 0x21, 0x16, 0x16, 0x10, 0x06, 0x07, 0x21, 0x11, 0x23, 0x35, 0x33, 0x11, 0x33, 0x11, 0x21, 0x01, 0x11, + 0x21, 0x32, 0x36, 0x35, 0x34, 0x26, 0x27, 0x02, 0x96, 0xfe, 0xbf, 0x01, 0x18, 0xbb, 0xd4, 0xd4, 0xb7, 0xfe, 0x2a, + 0xbf, 0xbf, 0xba, 0x01, 0x41, 0xfe, 0xbf, 0x01, 0x12, 0x69, 0x71, 0x6f, 0x64, 0x04, 0x3a, 0xfe, 0xb0, 0x02, 0xca, + 0xfe, 0xb6, 0xd1, 0x03, 0x04, 0x3a, 0x97, 0x01, 0x45, 0xfe, 0xbb, 0xfd, 0x81, 0xfe, 0x45, 0x77, 0x64, 0x61, 0x7d, + 0x02, 0x00, 0x01, 0x00, 0xb7, 0xff, 0xed, 0x06, 0xa0, 0x05, 0xc5, 0x00, 0x26, 0x00, 0x8a, 0xb2, 0x1e, 0x27, 0x28, + 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x1e, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x26, 0x2f, 0x1b, 0xb1, 0x26, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x1d, 0x2f, 0x1b, + 0xb1, 0x1d, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x23, 0x2f, 0x1b, 0xb1, 0x23, 0x12, 0x3e, 0x59, 0xb2, + 0x10, 0x05, 0x1d, 0x11, 0x12, 0x39, 0xb0, 0x10, 0x2f, 0xb0, 0x00, 0xd0, 0xb0, 0x05, 0x10, 0xb0, 0x09, 0xd0, 0xb0, + 0x05, 0x10, 0xb1, 0x0c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x10, 0x10, 0xb1, 0x11, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x1d, 0x10, 0xb1, 0x16, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x1d, 0x10, 0xb0, 0x19, 0xd0, 0xb0, 0x11, 0x10, 0xb0, 0x21, 0xd0, 0x30, + 0x31, 0x01, 0x33, 0x36, 0x12, 0x24, 0x33, 0x32, 0x00, 0x17, 0x23, 0x26, 0x26, 0x23, 0x22, 0x02, 0x07, 0x21, 0x15, + 0x21, 0x15, 0x14, 0x12, 0x33, 0x32, 0x36, 0x37, 0x33, 0x06, 0x04, 0x23, 0x20, 0x00, 0x11, 0x35, 0x23, 0x11, 0x23, + 0x11, 0x33, 0x01, 0x78, 0xc7, 0x05, 0x93, 0x01, 0x06, 0xac, 0xe6, 0x01, 0x19, 0x18, 0xc0, 0x19, 0xa7, 0x97, 0xb4, + 0xcf, 0x06, 0x02, 0x1e, 0xfd, 0xe2, 0xc6, 0xb2, 0xa3, 0xa9, 0x1c, 0xc0, 0x1b, 0xfe, 0xe1, 0xee, 0xfe, 0xfe, 0xfe, + 0xc9, 0xc7, 0xc1, 0xc1, 0x03, 0x40, 0xc1, 0x01, 0x26, 0x9e, 0xff, 0x00, 0xe8, 0xac, 0x9e, 0xfe, 0xfb, 0xe2, 0x97, + 0x1a, 0xed, 0xfe, 0xe8, 0x93, 0xb2, 0xe7, 0xfb, 0x01, 0x72, 0x01, 0x36, 0x14, 0xfd, 0x57, 0x05, 0xb0, 0x00, 0x00, + 0x01, 0x00, 0x99, 0xff, 0xec, 0x05, 0xa1, 0x04, 0x4e, 0x00, 0x24, 0x00, 0xc7, 0xb2, 0x03, 0x25, 0x26, 0x11, 0x12, + 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x24, 0x2f, 0x1b, 0xb1, 0x24, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x21, 0x2f, 0x1b, 0xb1, 0x21, + 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x1c, 0x2f, 0x1b, 0xb1, 0x1c, 0x12, 0x3e, 0x59, 0xb2, 0x0f, 0x1c, + 0x04, 0x11, 0x12, 0x39, 0xb0, 0x0f, 0x2f, 0xb4, 0xbf, 0x0f, 0xcf, 0x0f, 0x02, 0x5d, 0xb4, 0x3f, 0x0f, 0x4f, 0x0f, + 0x02, 0x71, 0xb4, 0xcf, 0x0f, 0xdf, 0x0f, 0x02, 0x71, 0xb4, 0x0f, 0x0f, 0x1f, 0x0f, 0x02, 0x72, 0xb4, 0x9f, 0x0f, + 0xaf, 0x0f, 0x02, 0x71, 0xb2, 0xff, 0x0f, 0x01, 0x5d, 0xb2, 0x0f, 0x0f, 0x01, 0x71, 0xb4, 0x2f, 0x0f, 0x3f, 0x0f, + 0x02, 0x5d, 0xb4, 0x6f, 0x0f, 0x7f, 0x0f, 0x02, 0x72, 0xb0, 0x00, 0xd0, 0xb2, 0x08, 0x0f, 0x04, 0x11, 0x12, 0x39, + 0xb0, 0x04, 0x10, 0xb1, 0x0b, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0f, 0x10, 0xb1, + 0x10, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x1c, 0x10, 0xb1, 0x14, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x17, 0x1c, 0x04, 0x11, 0x12, 0x39, 0xb0, 0x10, 0x10, 0xb0, 0x1f, + 0xd0, 0x30, 0x31, 0x01, 0x33, 0x36, 0x12, 0x33, 0x32, 0x16, 0x17, 0x23, 0x26, 0x26, 0x23, 0x22, 0x06, 0x07, 0x21, + 0x15, 0x21, 0x16, 0x16, 0x33, 0x32, 0x36, 0x37, 0x33, 0x0e, 0x02, 0x23, 0x22, 0x02, 0x27, 0x23, 0x11, 0x23, 0x11, + 0x33, 0x01, 0x53, 0xbf, 0x10, 0xff, 0xd1, 0xb6, 0xf1, 0x08, 0xb0, 0x08, 0x8f, 0x68, 0x84, 0x98, 0x0a, 0x01, 0xb5, + 0xfe, 0x4b, 0x0a, 0x99, 0x83, 0x63, 0x94, 0x08, 0xb0, 0x05, 0x78, 0xc4, 0x6e, 0xd1, 0xfe, 0x10, 0xc0, 0xba, 0xba, + 0x02, 0x67, 0xdf, 0x01, 0x08, 0xda, 0xae, 0x69, 0x87, 0xb1, 0x9e, 0x97, 0xa0, 0xad, 0x78, 0x5a, 0x5e, 0xa8, 0x63, + 0x01, 0x06, 0xde, 0xfe, 0x30, 0x04, 0x3a, 0x00, 0x02, 0x00, 0x28, 0x00, 0x00, 0x04, 0xe4, 0x05, 0xb0, 0x00, 0x0b, + 0x00, 0x0e, 0x00, 0x57, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1e, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, + 0x1b, 0xb1, 0x06, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x12, 0x3e, 0x59, + 0xb2, 0x0d, 0x08, 0x02, 0x11, 0x12, 0x39, 0xb0, 0x0d, 0x2f, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0xd0, 0xb2, 0x0e, 0x08, 0x02, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x23, 0x11, 0x23, + 0x11, 0x23, 0x03, 0x23, 0x01, 0x33, 0x01, 0x23, 0x01, 0x21, 0x03, 0x03, 0x89, 0xaa, 0xbc, 0x9e, 0x98, 0xc5, 0x02, + 0x0d, 0xab, 0x02, 0x04, 0xc5, 0xfd, 0x9f, 0x01, 0x93, 0xc7, 0x01, 0xb6, 0xfe, 0x4a, 0x01, 0xb6, 0xfe, 0x4a, 0x05, + 0xb0, 0xfa, 0x50, 0x02, 0x5a, 0x02, 0x49, 0x00, 0x02, 0x00, 0x0f, 0x00, 0x00, 0x04, 0x25, 0x04, 0x3a, 0x00, 0x0b, + 0x00, 0x10, 0x00, 0x57, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, + 0x1b, 0xb1, 0x06, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x12, 0x3e, 0x59, + 0xb2, 0x0d, 0x02, 0x08, 0x11, 0x12, 0x39, 0xb0, 0x0d, 0x2f, 0xb1, 0x01, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0xd0, 0xb2, 0x0f, 0x08, 0x02, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x23, 0x11, 0x23, + 0x11, 0x23, 0x03, 0x23, 0x01, 0x33, 0x01, 0x23, 0x01, 0x21, 0x03, 0x27, 0x07, 0x02, 0xed, 0x75, 0xb9, 0x7c, 0x77, + 0xbd, 0x01, 0xba, 0x9f, 0x01, 0xbd, 0xbe, 0xfe, 0x19, 0x01, 0x2f, 0x80, 0x18, 0x18, 0x01, 0x29, 0xfe, 0xd7, 0x01, + 0x29, 0xfe, 0xd7, 0x04, 0x3a, 0xfb, 0xc6, 0x01, 0xc1, 0x01, 0x3b, 0x59, 0x59, 0x00, 0x02, 0x00, 0xc9, 0x00, 0x00, + 0x06, 0xf5, 0x05, 0xb0, 0x00, 0x13, 0x00, 0x16, 0x00, 0x7d, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, + 0xb1, 0x02, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x12, 0x2f, 0x1b, 0xb1, 0x12, 0x1e, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, + 0x1b, 0xb1, 0x08, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x12, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x12, 0x3e, 0x59, 0xb2, 0x15, 0x02, 0x04, 0x11, 0x12, + 0x39, 0xb0, 0x15, 0x2f, 0xb0, 0x00, 0xd0, 0xb0, 0x15, 0x10, 0xb1, 0x06, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x0a, 0xd0, 0xb0, 0x06, 0x10, 0xb0, 0x0e, 0xd0, 0xb2, 0x16, 0x02, 0x04, 0x11, 0x12, 0x39, + 0x30, 0x31, 0x01, 0x21, 0x01, 0x33, 0x01, 0x23, 0x03, 0x23, 0x11, 0x23, 0x11, 0x23, 0x03, 0x23, 0x13, 0x21, 0x11, + 0x23, 0x11, 0x33, 0x01, 0x21, 0x03, 0x01, 0x8a, 0x01, 0x87, 0x01, 0x35, 0xab, 0x02, 0x04, 0xc5, 0x96, 0xaa, 0xbc, + 0x9e, 0x98, 0xc5, 0x9e, 0xfe, 0xb3, 0xc1, 0xc1, 0x02, 0x45, 0x01, 0x93, 0xc7, 0x02, 0x59, 0x03, 0x57, 0xfa, 0x50, + 0x01, 0xb6, 0xfe, 0x4a, 0x01, 0xb6, 0xfe, 0x4a, 0x01, 0xb8, 0xfe, 0x48, 0x05, 0xb0, 0xfc, 0xaa, 0x02, 0x49, 0x00, + 0x02, 0x00, 0xbc, 0x00, 0x00, 0x05, 0xe4, 0x04, 0x3a, 0x00, 0x13, 0x00, 0x18, 0x00, 0x80, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x12, 0x2f, 0x1b, 0xb1, + 0x12, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, + 0xb1, 0x0c, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x12, 0x3e, 0x59, 0xb2, + 0x00, 0x10, 0x12, 0x11, 0x12, 0x39, 0xb0, 0x00, 0x2f, 0xb0, 0x01, 0xd0, 0xb1, 0x0e, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0b, 0xd0, 0xb0, 0x07, 0xd0, 0xb0, 0x01, 0x10, 0xb0, 0x14, 0xd0, 0xb0, 0x15, + 0xd0, 0xb2, 0x17, 0x12, 0x04, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x21, 0x01, 0x33, 0x01, 0x23, 0x03, 0x23, 0x11, + 0x23, 0x11, 0x23, 0x03, 0x23, 0x13, 0x23, 0x11, 0x23, 0x11, 0x33, 0x01, 0x21, 0x03, 0x27, 0x07, 0x01, 0x76, 0x01, + 0x0f, 0x01, 0x03, 0x9f, 0x01, 0xbd, 0xbe, 0x7a, 0x75, 0xb9, 0x7c, 0x77, 0xbd, 0x79, 0xd1, 0xba, 0xba, 0x01, 0xc9, + 0x01, 0x2f, 0x80, 0x18, 0x18, 0x01, 0xc1, 0x02, 0x79, 0xfb, 0xc6, 0x01, 0x29, 0xfe, 0xd7, 0x01, 0x29, 0xfe, 0xd7, + 0x01, 0x28, 0xfe, 0xd8, 0x04, 0x3a, 0xfd, 0x87, 0x01, 0x3b, 0x59, 0x59, 0x00, 0x02, 0x00, 0x93, 0x00, 0x00, 0x06, + 0x3f, 0x05, 0xb0, 0x00, 0x1d, 0x00, 0x21, 0x00, 0x78, 0xb2, 0x1e, 0x22, 0x23, 0x11, 0x12, 0x39, 0xb0, 0x1e, 0x10, + 0xb0, 0x0e, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x1c, 0x2f, 0x1b, 0xb1, 0x1c, 0x1e, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, + 0xb1, 0x0d, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x15, 0x2f, 0x1b, 0xb1, 0x15, 0x12, 0x3e, 0x59, 0xb2, + 0x01, 0x0d, 0x1c, 0x11, 0x12, 0x39, 0xb0, 0x01, 0x2f, 0xb1, 0x0a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb0, 0x10, 0xd0, 0xb0, 0x01, 0x10, 0xb0, 0x1a, 0xd0, 0xb0, 0x01, 0x10, 0xb0, 0x1e, 0xd0, 0xb0, 0x1c, + 0x10, 0xb1, 0x20, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x33, 0x32, 0x16, + 0x17, 0x11, 0x23, 0x11, 0x26, 0x26, 0x27, 0x23, 0x07, 0x11, 0x23, 0x11, 0x27, 0x23, 0x22, 0x06, 0x07, 0x11, 0x23, + 0x11, 0x36, 0x36, 0x33, 0x33, 0x01, 0x21, 0x01, 0x33, 0x01, 0x21, 0x04, 0x41, 0x1b, 0xf4, 0xec, 0x03, 0xc1, 0x01, + 0x7c, 0x9a, 0x85, 0x15, 0xc1, 0x0d, 0x88, 0x9e, 0x82, 0x04, 0xc0, 0x03, 0xec, 0xf3, 0x2a, 0xfe, 0x78, 0x04, 0xb2, + 0xfd, 0x9f, 0x10, 0x01, 0x1a, 0xfd, 0xbb, 0x03, 0x2a, 0xd4, 0xd8, 0xfe, 0x82, 0x01, 0x78, 0x90, 0x82, 0x02, 0x23, + 0xfd, 0x97, 0x02, 0x76, 0x16, 0x7b, 0x8d, 0xfe, 0x7c, 0x01, 0x7e, 0xd8, 0xd4, 0x02, 0x86, 0xfd, 0x7a, 0x01, 0xe8, + 0x00, 0x00, 0x02, 0x00, 0x96, 0x00, 0x00, 0x05, 0x4b, 0x04, 0x3a, 0x00, 0x1b, 0x00, 0x1f, 0x00, 0x75, 0xb2, 0x1c, + 0x20, 0x21, 0x11, 0x12, 0x39, 0xb0, 0x1c, 0x10, 0xb0, 0x14, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, + 0x1b, 0xb1, 0x06, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x1b, 0x2f, 0x1b, 0xb1, 0x1b, 0x12, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x14, 0x2f, 0x1b, 0xb1, 0x14, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, + 0x2f, 0x1b, 0xb1, 0x0c, 0x12, 0x3e, 0x59, 0xb2, 0x1c, 0x14, 0x06, 0x11, 0x12, 0x39, 0xb0, 0x1c, 0x2f, 0xb0, 0x04, + 0xd0, 0xb0, 0x1c, 0x10, 0xb0, 0x07, 0xd0, 0xb1, 0x10, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb0, 0x17, 0xd0, 0xb0, 0x06, 0x10, 0xb1, 0x1e, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, + 0x31, 0x33, 0x35, 0x36, 0x36, 0x37, 0x01, 0x21, 0x01, 0x16, 0x16, 0x17, 0x15, 0x23, 0x35, 0x26, 0x26, 0x23, 0x23, + 0x07, 0x11, 0x23, 0x11, 0x27, 0x23, 0x22, 0x06, 0x07, 0x15, 0x01, 0x33, 0x13, 0x21, 0x96, 0x04, 0xca, 0xd2, 0xfe, + 0xe1, 0x03, 0xbf, 0xfe, 0xe0, 0xce, 0xc5, 0x02, 0xba, 0x02, 0x73, 0x8c, 0x35, 0x0b, 0xb9, 0x06, 0x3e, 0x8c, 0x75, + 0x02, 0x01, 0xa2, 0x08, 0xb7, 0xfe, 0x8b, 0xb6, 0xcd, 0xd2, 0x06, 0x01, 0xdf, 0xfe, 0x21, 0x0b, 0xd3, 0xd0, 0xad, + 0xb1, 0x92, 0x81, 0x13, 0xfe, 0x4f, 0x01, 0xbb, 0x09, 0x7e, 0x95, 0xb1, 0x02, 0x5c, 0x01, 0x46, 0x00, 0x02, 0x00, + 0xb6, 0x00, 0x00, 0x08, 0x72, 0x05, 0xb0, 0x00, 0x22, 0x00, 0x26, 0x00, 0x95, 0xb2, 0x26, 0x27, 0x28, 0x11, 0x12, + 0x39, 0xb0, 0x26, 0x10, 0xb0, 0x1e, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1e, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x22, 0x2f, 0x1b, 0xb1, 0x22, + 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x1b, 0x2f, 0x1b, 0xb1, 0x1b, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x13, 0x2f, 0x1b, 0xb1, 0x13, 0x12, 0x3e, 0x59, 0xb2, 0x09, 0x05, 0x08, 0x11, 0x12, 0x39, 0xb0, 0x09, + 0x2f, 0xb1, 0x04, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x09, 0x10, 0xb0, 0x23, 0xd0, + 0xb0, 0x0d, 0xd0, 0xb0, 0x04, 0x10, 0xb0, 0x1e, 0xd0, 0xb0, 0x18, 0xd0, 0xb0, 0x0b, 0x10, 0xb1, 0x26, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x21, 0x11, 0x36, 0x37, 0x21, 0x11, 0x23, 0x11, 0x33, + 0x11, 0x21, 0x01, 0x21, 0x01, 0x33, 0x32, 0x16, 0x17, 0x11, 0x23, 0x11, 0x26, 0x26, 0x27, 0x23, 0x07, 0x11, 0x23, + 0x11, 0x27, 0x23, 0x22, 0x06, 0x07, 0x11, 0x01, 0x33, 0x01, 0x21, 0x02, 0xc5, 0x01, 0x4f, 0xfe, 0x62, 0xc1, 0xc1, + 0x03, 0x59, 0xfe, 0x79, 0x04, 0xb3, 0xfe, 0x78, 0x1b, 0xf4, 0xec, 0x03, 0xc1, 0x01, 0x7c, 0x9a, 0x85, 0x16, 0xc0, + 0x0e, 0x87, 0x9e, 0x82, 0x04, 0x02, 0x15, 0x10, 0x01, 0x1a, 0xfd, 0xbb, 0x01, 0x78, 0xb3, 0x69, 0xfd, 0x6c, 0x05, + 0xb0, 0xfd, 0x7c, 0x02, 0x84, 0xfd, 0x7a, 0xd4, 0xd8, 0xfe, 0x82, 0x01, 0x78, 0x90, 0x82, 0x02, 0x25, 0xfd, 0x99, + 0x02, 0x75, 0x17, 0x7b, 0x8d, 0xfe, 0x7c, 0x03, 0x2a, 0x01, 0xe8, 0x00, 0x02, 0x00, 0x9b, 0x00, 0x00, 0x07, 0x3b, + 0x04, 0x3a, 0x00, 0x21, 0x00, 0x25, 0x00, 0x98, 0xb2, 0x1e, 0x26, 0x27, 0x11, 0x12, 0x39, 0xb0, 0x1e, 0x10, 0xb0, + 0x25, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, + 0x00, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x12, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x11, 0x2f, 0x1b, 0xb1, 0x11, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x19, 0x2f, 0x1b, + 0xb1, 0x19, 0x12, 0x3e, 0x59, 0xb2, 0x0a, 0x0b, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x0a, 0x2f, 0xb1, 0x1d, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0xd0, 0xb0, 0x0a, 0x10, 0xb0, 0x0d, 0xd0, 0xb0, 0x1d, + 0x10, 0xb0, 0x16, 0xd0, 0xb0, 0x0a, 0x10, 0xb0, 0x22, 0xd0, 0xb0, 0x0b, 0x10, 0xb1, 0x24, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x21, 0x35, 0x36, 0x37, 0x21, 0x11, 0x23, 0x11, 0x33, 0x11, 0x21, + 0x01, 0x21, 0x01, 0x16, 0x16, 0x17, 0x15, 0x23, 0x35, 0x26, 0x26, 0x23, 0x23, 0x07, 0x11, 0x23, 0x11, 0x27, 0x23, + 0x06, 0x06, 0x07, 0x15, 0x01, 0x33, 0x13, 0x21, 0x02, 0x86, 0x02, 0x46, 0xfe, 0x87, 0xba, 0xba, 0x02, 0xd1, 0xfe, + 0xe1, 0x03, 0xbf, 0xfe, 0xe0, 0xce, 0xc5, 0x02, 0xba, 0x02, 0x73, 0x8c, 0x35, 0x0b, 0xb9, 0x06, 0x4b, 0x85, 0x6f, + 0x02, 0x01, 0xa2, 0x08, 0xb7, 0xfe, 0x8b, 0xaf, 0xad, 0x68, 0xfe, 0x3c, 0x04, 0x3a, 0xfe, 0x22, 0x01, 0xde, 0xfe, + 0x21, 0x0b, 0xd3, 0xd0, 0xad, 0xb1, 0x92, 0x81, 0x13, 0xfe, 0x4f, 0x01, 0xbb, 0x09, 0x02, 0x80, 0x93, 0xaf, 0x02, + 0x5c, 0x01, 0x46, 0x00, 0x00, 0x02, 0x00, 0x50, 0xfe, 0x46, 0x03, 0xaa, 0x07, 0x86, 0x00, 0x29, 0x00, 0x32, 0x00, + 0x8a, 0xb2, 0x2a, 0x33, 0x34, 0x11, 0x12, 0x39, 0xb0, 0x2a, 0x10, 0xb0, 0x02, 0xd0, 0x00, 0xb0, 0x19, 0x2f, 0xb0, + 0x2e, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x12, 0x2f, 0x1b, 0xb1, 0x12, 0x12, 0x3e, 0x59, 0xb0, 0x05, 0x10, 0xb1, 0x03, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x28, 0x05, 0x12, 0x11, 0x12, 0x39, 0xb0, 0x28, 0x2f, 0xb1, 0x25, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x0c, 0x25, 0x28, 0x11, 0x12, 0x39, 0xb0, 0x12, 0x10, 0xb1, + 0x1f, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x0f, 0x2e, 0x01, 0x5d, 0xb0, 0x2e, 0x10, + 0xb0, 0x2b, 0xd0, 0xb0, 0x2b, 0x2f, 0xb4, 0x0f, 0x2b, 0x1f, 0x2b, 0x02, 0x5d, 0xb2, 0x2a, 0x2e, 0x2b, 0x11, 0x12, + 0x39, 0xb0, 0x32, 0xd0, 0x30, 0x31, 0x01, 0x34, 0x26, 0x23, 0x21, 0x35, 0x21, 0x32, 0x04, 0x15, 0x14, 0x06, 0x07, + 0x16, 0x16, 0x15, 0x14, 0x04, 0x23, 0x23, 0x06, 0x15, 0x14, 0x17, 0x17, 0x07, 0x26, 0x26, 0x35, 0x34, 0x36, 0x37, + 0x33, 0x36, 0x36, 0x35, 0x10, 0x25, 0x23, 0x35, 0x33, 0x20, 0x03, 0x37, 0x33, 0x15, 0x03, 0x23, 0x03, 0x35, 0x33, + 0x02, 0xda, 0x9d, 0x87, 0xfe, 0xce, 0x01, 0x2b, 0xde, 0x01, 0x06, 0x81, 0x73, 0x82, 0x89, 0xfe, 0xf7, 0xe0, 0x34, + 0x8d, 0x82, 0x1f, 0x4a, 0x7a, 0x8d, 0xa5, 0xa2, 0x34, 0x86, 0x9f, 0xfe, 0xbe, 0x99, 0x86, 0x01, 0x3f, 0xbb, 0x97, + 0xa0, 0xfe, 0x72, 0xfa, 0x9d, 0x04, 0x2a, 0x6e, 0x80, 0x98, 0xd8, 0xb2, 0x67, 0xa4, 0x2d, 0x29, 0xad, 0x82, 0xc4, + 0xe5, 0x03, 0x6d, 0x69, 0x42, 0x0f, 0x7d, 0x35, 0xa8, 0x63, 0x7a, 0x83, 0x01, 0x01, 0x94, 0x79, 0x01, 0x08, 0x05, + 0x98, 0x03, 0xa5, 0xaa, 0x0a, 0xfe, 0xee, 0x01, 0x12, 0x0a, 0x00, 0x00, 0x02, 0x00, 0x4c, 0xfe, 0x46, 0x03, 0x76, + 0x06, 0x30, 0x00, 0x29, 0x00, 0x32, 0x00, 0x9f, 0xb2, 0x2e, 0x33, 0x34, 0x11, 0x12, 0x39, 0xb0, 0x2e, 0x10, 0xb0, + 0x1f, 0xd0, 0x00, 0xb0, 0x18, 0x2f, 0xb0, 0x2e, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, + 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x11, 0x2f, 0x1b, 0xb1, 0x11, 0x12, 0x3e, 0x59, 0xb0, 0x05, 0x10, + 0xb1, 0x03, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x28, 0x05, 0x11, 0x11, 0x12, 0x39, + 0xb0, 0x28, 0x2f, 0xb2, 0x2f, 0x28, 0x01, 0x5d, 0xb4, 0xbf, 0x28, 0xcf, 0x28, 0x02, 0x5d, 0xb4, 0x9f, 0x28, 0xaf, + 0x28, 0x02, 0x71, 0xb4, 0x6f, 0x28, 0x7f, 0x28, 0x02, 0x72, 0xb1, 0x25, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb2, 0x0c, 0x25, 0x28, 0x11, 0x12, 0x39, 0xb0, 0x11, 0x10, 0xb1, 0x1e, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x2e, 0x10, 0xb0, 0x2b, 0xd0, 0xb0, 0x2b, 0x2f, 0xb4, 0x0f, 0x2b, 0x1f, + 0x2b, 0x02, 0x5d, 0xb2, 0x2a, 0x2e, 0x2b, 0x11, 0x12, 0x39, 0xb0, 0x32, 0xd0, 0x30, 0x31, 0x01, 0x34, 0x26, 0x27, + 0x21, 0x35, 0x21, 0x32, 0x16, 0x15, 0x14, 0x06, 0x07, 0x16, 0x15, 0x14, 0x06, 0x23, 0x23, 0x06, 0x15, 0x14, 0x17, + 0x17, 0x07, 0x26, 0x26, 0x35, 0x34, 0x36, 0x37, 0x33, 0x36, 0x37, 0x36, 0x35, 0x34, 0x25, 0x23, 0x35, 0x33, 0x20, + 0x03, 0x37, 0x33, 0x15, 0x03, 0x23, 0x03, 0x35, 0x33, 0x02, 0xa7, 0x7f, 0x70, 0xfe, 0xc9, 0x01, 0x27, 0xca, 0xee, + 0x66, 0x5b, 0xd7, 0xf3, 0xc8, 0x32, 0x8d, 0x82, 0x1f, 0x4b, 0x7c, 0x8a, 0xa5, 0xa2, 0x36, 0x72, 0x43, 0x3f, 0xfe, + 0xe8, 0x99, 0x88, 0x01, 0x13, 0xd9, 0x97, 0xa0, 0xfe, 0x72, 0xfa, 0x9d, 0x03, 0x09, 0x43, 0x53, 0x02, 0x99, 0xaa, + 0x8b, 0x49, 0x77, 0x24, 0x42, 0xaf, 0x94, 0xaf, 0x03, 0x6d, 0x69, 0x42, 0x0f, 0x7d, 0x37, 0xa8, 0x61, 0x7a, 0x83, + 0x01, 0x02, 0x30, 0x2e, 0x48, 0xa2, 0x03, 0x98, 0x03, 0x1d, 0xaa, 0x0a, 0xfe, 0xee, 0x01, 0x12, 0x0a, 0x00, 0x03, + 0x00, 0x67, 0xff, 0xec, 0x04, 0xfa, 0x05, 0xc4, 0x00, 0x11, 0x00, 0x18, 0x00, 0x1f, 0x00, 0x8c, 0xb2, 0x04, 0x20, + 0x21, 0x11, 0x12, 0x39, 0xb0, 0x04, 0x10, 0xb0, 0x12, 0xd0, 0xb0, 0x04, 0x10, 0xb0, 0x19, 0xd0, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, + 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb0, 0x0d, 0x10, 0xb1, 0x12, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb2, 0x16, 0x0d, 0x04, 0x11, 0x12, 0x39, 0xb0, 0x16, 0x2f, 0xb2, 0x2f, 0x16, 0x01, 0x5d, 0xb2, 0xcf, 0x16, + 0x01, 0x5d, 0xb2, 0x2f, 0x16, 0x01, 0x71, 0xb2, 0xff, 0x16, 0x01, 0x5d, 0xb2, 0x5f, 0x16, 0x01, 0x5d, 0xb4, 0x4f, + 0x16, 0x5f, 0x16, 0x02, 0x71, 0xb2, 0x9f, 0x16, 0x01, 0x71, 0xb0, 0x04, 0x10, 0xb1, 0x19, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x16, 0x10, 0xb1, 0x1c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0x30, 0x31, 0x01, 0x14, 0x02, 0x04, 0x23, 0x22, 0x24, 0x02, 0x27, 0x35, 0x34, 0x12, 0x24, 0x33, 0x32, + 0x04, 0x12, 0x17, 0x01, 0x22, 0x02, 0x07, 0x21, 0x26, 0x02, 0x03, 0x32, 0x12, 0x37, 0x21, 0x16, 0x12, 0x04, 0xfa, + 0x8f, 0xfe, 0xf8, 0xb1, 0xac, 0xfe, 0xf6, 0x93, 0x02, 0x92, 0x01, 0x0b, 0xac, 0xaf, 0x01, 0x08, 0x91, 0x02, 0xfd, + 0xb6, 0xb6, 0xd0, 0x04, 0x03, 0x14, 0x04, 0xce, 0xb6, 0xb6, 0xca, 0x08, 0xfc, 0xec, 0x08, 0xd3, 0x02, 0xa9, 0xd5, + 0xfe, 0xc2, 0xaa, 0xa9, 0x01, 0x39, 0xce, 0x69, 0xd2, 0x01, 0x42, 0xab, 0xa8, 0xfe, 0xc5, 0xcf, 0x02, 0x0d, 0xfe, + 0xed, 0xf2, 0xf8, 0x01, 0x0d, 0xfb, 0x70, 0x01, 0x00, 0xf4, 0xec, 0xfe, 0xf8, 0x00, 0x03, 0x00, 0x5b, 0xff, 0xec, + 0x04, 0x34, 0x04, 0x4e, 0x00, 0x0f, 0x00, 0x15, 0x00, 0x1c, 0x00, 0x8a, 0xb2, 0x04, 0x1d, 0x1e, 0x11, 0x12, 0x39, + 0xb0, 0x04, 0x10, 0xb0, 0x13, 0xd0, 0xb0, 0x04, 0x10, 0xb0, 0x16, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, + 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x12, 0x3e, + 0x59, 0xb2, 0x1a, 0x0c, 0x04, 0x11, 0x12, 0x39, 0xb0, 0x1a, 0x2f, 0xb4, 0xbf, 0x1a, 0xcf, 0x1a, 0x02, 0x5d, 0xb4, + 0x9f, 0x1a, 0xaf, 0x1a, 0x02, 0x71, 0xb2, 0xff, 0x1a, 0x01, 0x5d, 0xb2, 0x0f, 0x1a, 0x01, 0x71, 0xb4, 0x2f, 0x1a, + 0x3f, 0x1a, 0x02, 0x5d, 0xb4, 0xcf, 0x1a, 0xdf, 0x1a, 0x02, 0x71, 0xb1, 0x10, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0c, 0x10, 0xb1, 0x14, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb0, 0x04, 0x10, 0xb1, 0x16, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x13, 0x34, + 0x36, 0x36, 0x33, 0x32, 0x00, 0x17, 0x17, 0x14, 0x06, 0x06, 0x23, 0x22, 0x00, 0x35, 0x05, 0x21, 0x16, 0x16, 0x20, + 0x36, 0x01, 0x22, 0x06, 0x07, 0x21, 0x26, 0x26, 0x5b, 0x7b, 0xe1, 0x8f, 0xd4, 0x01, 0x0e, 0x0b, 0x01, 0x7c, 0xe0, + 0x90, 0xde, 0xfe, 0xf1, 0x03, 0x1c, 0xfd, 0x9f, 0x0d, 0xa4, 0x01, 0x02, 0xa1, 0xfe, 0xdc, 0x7d, 0xa2, 0x0f, 0x02, + 0x5e, 0x12, 0xa3, 0x02, 0x27, 0x9f, 0xfd, 0x8b, 0xfe, 0xe2, 0xe5, 0x3a, 0x9e, 0xfe, 0x89, 0x01, 0x33, 0xfb, 0x44, + 0x9b, 0xb8, 0xba, 0x02, 0x79, 0xb5, 0x93, 0x97, 0xb1, 0x00, 0x00, 0x01, 0x00, 0x16, 0x00, 0x00, 0x04, 0xdd, 0x05, + 0xc3, 0x00, 0x0f, 0x00, 0x47, 0xb2, 0x02, 0x10, 0x11, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, + 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0f, 0x2f, 0x1b, 0xb1, 0x0f, 0x1e, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x12, 0x3e, 0x59, 0xb2, 0x01, 0x06, 0x0c, 0x11, + 0x12, 0x39, 0xb0, 0x06, 0x10, 0xb1, 0x08, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, + 0x01, 0x17, 0x37, 0x01, 0x36, 0x36, 0x33, 0x17, 0x07, 0x22, 0x06, 0x07, 0x01, 0x23, 0x01, 0x33, 0x02, 0x43, 0x21, + 0x23, 0x01, 0x08, 0x33, 0x86, 0x67, 0x2e, 0x01, 0x40, 0x40, 0x1f, 0xfe, 0x7c, 0xaa, 0xfe, 0x07, 0xd0, 0x01, 0x76, + 0x82, 0x81, 0x03, 0x3f, 0x97, 0x78, 0x01, 0xab, 0x3c, 0x54, 0xfb, 0x79, 0x05, 0xb0, 0x00, 0x00, 0x01, 0x00, 0x2e, + 0x00, 0x00, 0x04, 0x0b, 0x04, 0x4d, 0x00, 0x11, 0x00, 0x47, 0xb2, 0x02, 0x12, 0x13, 0x11, 0x12, 0x39, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x11, 0x2f, + 0x1b, 0xb1, 0x11, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0e, 0x2f, 0x1b, 0xb1, 0x0e, 0x12, 0x3e, 0x59, + 0xb2, 0x01, 0x05, 0x0e, 0x11, 0x12, 0x39, 0xb0, 0x05, 0x10, 0xb1, 0x0a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x17, 0x37, 0x13, 0x36, 0x33, 0x32, 0x17, 0x07, 0x26, 0x23, 0x22, 0x06, 0x07, + 0x01, 0x23, 0x01, 0x33, 0x01, 0xdb, 0x17, 0x19, 0x9d, 0x4d, 0xac, 0x47, 0x23, 0x15, 0x0d, 0x1d, 0x1f, 0x3c, 0x10, + 0xfe, 0xd7, 0x8d, 0xfe, 0x83, 0xbd, 0x01, 0x3c, 0x64, 0x64, 0x02, 0x1f, 0xf2, 0x18, 0x94, 0x08, 0x30, 0x2d, 0xfc, + 0xb4, 0x04, 0x3a, 0x00, 0x02, 0x00, 0x67, 0xff, 0x73, 0x04, 0xfa, 0x06, 0x34, 0x00, 0x13, 0x00, 0x27, 0x00, 0x54, + 0xb2, 0x05, 0x28, 0x29, 0x11, 0x12, 0x39, 0xb0, 0x05, 0x10, 0xb0, 0x19, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x12, + 0x3e, 0x59, 0xb0, 0x06, 0xd0, 0xb0, 0x0d, 0x10, 0xb0, 0x10, 0xd0, 0xb1, 0x17, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x1a, 0xd0, 0xb0, 0x03, 0x10, 0xb1, 0x24, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x21, 0xd0, 0x30, 0x31, 0x01, 0x10, 0x00, 0x07, 0x15, 0x23, 0x35, 0x26, 0x00, 0x03, 0x35, + 0x10, 0x00, 0x37, 0x35, 0x33, 0x15, 0x16, 0x00, 0x11, 0x27, 0x34, 0x02, 0x27, 0x15, 0x23, 0x35, 0x06, 0x02, 0x15, + 0x15, 0x14, 0x12, 0x17, 0x35, 0x33, 0x15, 0x36, 0x12, 0x35, 0x04, 0xfa, 0xfe, 0xfe, 0xe3, 0xb9, 0xe5, 0xfe, 0xf1, + 0x01, 0x01, 0x0e, 0xe7, 0xb9, 0xe2, 0x01, 0x03, 0xbf, 0x99, 0x8d, 0xb9, 0x93, 0xa3, 0xa4, 0x92, 0xb9, 0x8f, 0x97, + 0x02, 0xa9, 0xfe, 0xdd, 0xfe, 0x91, 0x23, 0x81, 0x7f, 0x1f, 0x01, 0x71, 0x01, 0x23, 0x60, 0x01, 0x24, 0x01, 0x76, + 0x1f, 0x76, 0x78, 0x25, 0xfe, 0x90, 0xfe, 0xd9, 0x07, 0xe0, 0x01, 0x09, 0x23, 0x61, 0x64, 0x1f, 0xfe, 0xee, 0xdf, + 0x5d, 0xde, 0xfe, 0xec, 0x1f, 0x66, 0x64, 0x22, 0x01, 0x0b, 0xe2, 0x00, 0x00, 0x02, 0x00, 0x5b, 0xff, 0x89, 0x04, + 0x34, 0x04, 0xb5, 0x00, 0x13, 0x00, 0x25, 0x00, 0x5a, 0xb2, 0x03, 0x26, 0x27, 0x11, 0x12, 0x39, 0xb0, 0x03, 0x10, + 0xb0, 0x1c, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1a, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x12, 0x3e, 0x59, 0xb0, 0x03, 0x10, 0xb0, 0x06, 0xd0, 0xb0, 0x10, + 0x10, 0xb0, 0x0d, 0xd0, 0xb0, 0x10, 0x10, 0xb1, 0x23, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb0, 0x14, 0xd0, 0xb0, 0x03, 0x10, 0xb1, 0x1d, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x1a, 0xd0, 0x30, 0x31, 0x13, 0x34, 0x12, 0x37, 0x35, 0x33, 0x15, 0x16, 0x12, 0x15, 0x15, 0x14, 0x02, 0x07, 0x15, + 0x23, 0x35, 0x26, 0x02, 0x35, 0x01, 0x36, 0x36, 0x35, 0x34, 0x26, 0x27, 0x15, 0x23, 0x35, 0x06, 0x06, 0x15, 0x14, + 0x16, 0x17, 0x35, 0x33, 0x5b, 0xd4, 0xb9, 0xb9, 0xba, 0xd9, 0xdd, 0xb6, 0xb9, 0xb4, 0xd9, 0x02, 0x46, 0x63, 0x76, + 0x74, 0x65, 0xb9, 0x62, 0x72, 0x71, 0x63, 0xb9, 0x02, 0x27, 0xd2, 0x01, 0x2a, 0x22, 0x70, 0x6f, 0x20, 0xfe, 0xd8, + 0xdd, 0x10, 0xd8, 0xfe, 0xd8, 0x1d, 0x6b, 0x6c, 0x1f, 0x01, 0x27, 0xdc, 0xfe, 0x79, 0x1f, 0xcd, 0xab, 0x91, 0xd0, + 0x20, 0x62, 0x61, 0x21, 0xd0, 0xa5, 0x92, 0xcb, 0x22, 0x66, 0x00, 0x00, 0x03, 0x00, 0x9c, 0xff, 0xeb, 0x06, 0x6f, + 0x07, 0x51, 0x00, 0x2c, 0x00, 0x40, 0x00, 0x49, 0x00, 0xaa, 0xb2, 0x0a, 0x4a, 0x4b, 0x11, 0x12, 0x39, 0xb0, 0x0a, + 0x10, 0xb0, 0x32, 0xd0, 0xb0, 0x0a, 0x10, 0xb0, 0x49, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x14, 0x2f, 0x1b, + 0xb1, 0x14, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x12, 0x3e, 0x59, 0xb0, + 0x14, 0x10, 0xb0, 0x00, 0xd0, 0xb0, 0x0d, 0x10, 0xb0, 0x07, 0xd0, 0xb2, 0x0a, 0x0d, 0x14, 0x11, 0x12, 0x39, 0xb0, + 0x14, 0x10, 0xb1, 0x15, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0d, 0x10, 0xb1, 0x1c, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x20, 0x14, 0x0d, 0x11, 0x12, 0x39, 0xb0, 0x25, + 0xd0, 0xb0, 0x15, 0x10, 0xb0, 0x2c, 0xd0, 0xb0, 0x14, 0x10, 0xb0, 0x38, 0xd0, 0xb0, 0x38, 0x2f, 0xb0, 0x2f, 0xd0, + 0xb1, 0x2d, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x2f, 0x10, 0xb0, 0x34, 0xd0, 0xb0, + 0x34, 0x2f, 0xb1, 0x3c, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x38, 0x10, 0xb0, 0x44, + 0xd0, 0xb0, 0x49, 0xd0, 0xb0, 0x49, 0x2f, 0x30, 0x31, 0x01, 0x32, 0x16, 0x15, 0x11, 0x14, 0x06, 0x23, 0x22, 0x26, + 0x27, 0x06, 0x06, 0x23, 0x22, 0x26, 0x27, 0x11, 0x34, 0x36, 0x33, 0x15, 0x22, 0x06, 0x15, 0x11, 0x14, 0x16, 0x33, + 0x32, 0x36, 0x35, 0x11, 0x33, 0x11, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x11, 0x34, 0x26, 0x23, 0x13, 0x15, 0x23, + 0x22, 0x2e, 0x02, 0x23, 0x22, 0x15, 0x15, 0x23, 0x35, 0x34, 0x36, 0x33, 0x32, 0x1e, 0x02, 0x01, 0x36, 0x37, 0x35, + 0x33, 0x15, 0x14, 0x06, 0x07, 0x04, 0xdb, 0xbb, 0xd9, 0xd9, 0xbb, 0x70, 0xb2, 0x34, 0x34, 0xb0, 0x70, 0xb9, 0xd8, + 0x04, 0xd8, 0xbd, 0x63, 0x71, 0x72, 0x62, 0x72, 0x82, 0xc1, 0x82, 0x73, 0x63, 0x70, 0x6f, 0x64, 0x68, 0x2b, 0x50, + 0x82, 0xb8, 0x34, 0x18, 0x71, 0x80, 0x7f, 0x6e, 0x28, 0x48, 0xbf, 0x6a, 0xfe, 0x40, 0x42, 0x03, 0x9d, 0x5b, 0x3b, + 0x05, 0xaf, 0xf0, 0xd6, 0xfd, 0xc6, 0xd4, 0xf0, 0x55, 0x58, 0x58, 0x55, 0xe8, 0xcd, 0x02, 0x4a, 0xd4, 0xf1, 0x9e, + 0x9d, 0x89, 0xfd, 0xc4, 0x8c, 0x9b, 0x89, 0x7c, 0x01, 0xac, 0xfe, 0x54, 0x7a, 0x8b, 0x9c, 0x8c, 0x02, 0x3a, 0x88, + 0x9f, 0x01, 0xc2, 0x7f, 0x22, 0x50, 0x0c, 0x70, 0x0f, 0x24, 0x6e, 0x6c, 0x11, 0x52, 0x1b, 0xfe, 0x90, 0x50, 0x3c, + 0x69, 0x66, 0x32, 0x75, 0x20, 0x00, 0x03, 0x00, 0x7e, 0xff, 0xeb, 0x05, 0xaa, 0x05, 0xf1, 0x00, 0x2b, 0x00, 0x3f, + 0x00, 0x48, 0x00, 0xb0, 0xb2, 0x09, 0x49, 0x4a, 0x11, 0x12, 0x39, 0xb0, 0x09, 0x10, 0xb0, 0x3c, 0xd0, 0xb0, 0x09, + 0x10, 0xb0, 0x48, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x13, 0x2f, 0x1b, 0xb1, 0x13, 0x1a, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x12, 0x3e, 0x59, 0xb0, 0x13, 0x10, 0xb0, 0x00, 0xd0, 0xb0, + 0x0c, 0x10, 0xb0, 0x07, 0xd0, 0xb2, 0x09, 0x0c, 0x13, 0x11, 0x12, 0x39, 0xb0, 0x13, 0x10, 0xb1, 0x14, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0c, 0x10, 0xb1, 0x1b, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x1f, 0x13, 0x0c, 0x11, 0x12, 0x39, 0xb0, 0x24, 0xd0, 0xb0, 0x14, 0x10, 0xb0, 0x2b, + 0xd0, 0xb0, 0x13, 0x10, 0xb0, 0x37, 0xd0, 0xb0, 0x37, 0x2f, 0xb0, 0x2d, 0xd0, 0xb0, 0x2d, 0x2f, 0xb1, 0x2c, 0x02, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x2d, 0x10, 0xb0, 0x33, 0xd0, 0xb0, 0x33, 0x2f, 0xb1, + 0x3b, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x37, 0x10, 0xb0, 0x43, 0xd0, 0xb0, 0x43, + 0x2f, 0xb0, 0x48, 0xd0, 0xb0, 0x48, 0x2f, 0x30, 0x31, 0x01, 0x32, 0x16, 0x15, 0x11, 0x14, 0x06, 0x23, 0x22, 0x27, + 0x06, 0x06, 0x23, 0x22, 0x26, 0x27, 0x11, 0x34, 0x36, 0x33, 0x15, 0x22, 0x06, 0x15, 0x11, 0x14, 0x16, 0x33, 0x32, + 0x36, 0x35, 0x35, 0x33, 0x15, 0x16, 0x16, 0x33, 0x32, 0x36, 0x35, 0x11, 0x34, 0x26, 0x23, 0x13, 0x15, 0x23, 0x22, + 0x2e, 0x02, 0x23, 0x22, 0x15, 0x15, 0x23, 0x35, 0x34, 0x36, 0x33, 0x32, 0x1e, 0x02, 0x01, 0x36, 0x37, 0x35, 0x33, + 0x15, 0x14, 0x06, 0x07, 0x04, 0x42, 0xa8, 0xc0, 0xc0, 0xa8, 0xd0, 0x5f, 0x2f, 0x9c, 0x62, 0xa3, 0xc1, 0x04, 0xc0, + 0xa8, 0x52, 0x5d, 0x5c, 0x53, 0x62, 0x6f, 0xb9, 0x01, 0x70, 0x61, 0x51, 0x5d, 0x5d, 0x51, 0xaa, 0x2c, 0x4f, 0x7e, + 0xc0, 0x30, 0x18, 0x72, 0x80, 0x7f, 0x6f, 0x29, 0x4a, 0xb7, 0x6d, 0xfe, 0x41, 0x41, 0x03, 0x9e, 0x5b, 0x3b, 0x04, + 0x44, 0xdb, 0xc2, 0xfe, 0xdf, 0xc1, 0xda, 0x95, 0x4b, 0x4a, 0xd0, 0xbb, 0x01, 0x32, 0xc1, 0xdb, 0x98, 0x88, 0x7c, + 0xfe, 0xde, 0x7b, 0x89, 0x78, 0x67, 0xeb, 0xee, 0x67, 0x75, 0x88, 0x7d, 0x01, 0x21, 0x7c, 0x88, 0x01, 0xc7, 0x7f, + 0x20, 0x52, 0x0b, 0x6f, 0x0f, 0x24, 0x6e, 0x6c, 0x12, 0x50, 0x1c, 0xfe, 0x86, 0x4e, 0x3f, 0x68, 0x66, 0x32, 0x75, + 0x20, 0x00, 0x02, 0x00, 0x9c, 0xff, 0xec, 0x06, 0x75, 0x07, 0x03, 0x00, 0x20, 0x00, 0x28, 0x00, 0x84, 0xb2, 0x07, + 0x29, 0x2a, 0x11, 0x12, 0x39, 0xb0, 0x07, 0x10, 0xb0, 0x27, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0f, 0x2f, + 0x1b, 0xb1, 0x0f, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x17, 0x2f, 0x1b, 0xb1, 0x17, 0x1e, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x20, 0x2f, 0x1b, 0xb1, 0x20, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, + 0x2f, 0x1b, 0xb1, 0x0a, 0x12, 0x3e, 0x59, 0xb0, 0x04, 0xd0, 0xb2, 0x07, 0x0a, 0x0f, 0x11, 0x12, 0x39, 0xb0, 0x0a, + 0x10, 0xb1, 0x13, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x1c, 0xd0, 0xb0, 0x0f, 0x10, + 0xb0, 0x27, 0xd0, 0xb0, 0x27, 0x2f, 0xb0, 0x28, 0xd0, 0xb0, 0x28, 0x2f, 0xb1, 0x22, 0x06, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x28, 0x10, 0xb0, 0x25, 0xd0, 0xb0, 0x25, 0x2f, 0x30, 0x31, 0x01, 0x11, 0x14, + 0x06, 0x23, 0x22, 0x26, 0x27, 0x06, 0x06, 0x23, 0x22, 0x26, 0x27, 0x11, 0x33, 0x11, 0x14, 0x16, 0x33, 0x32, 0x36, + 0x35, 0x11, 0x33, 0x11, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x11, 0x25, 0x35, 0x21, 0x17, 0x21, 0x15, 0x23, 0x35, + 0x06, 0x75, 0xe1, 0xc3, 0x6d, 0xab, 0x31, 0x34, 0xb2, 0x71, 0xbd, 0xd7, 0x01, 0xc1, 0x72, 0x62, 0x72, 0x82, 0xc7, + 0x7c, 0x69, 0x6a, 0x7a, 0xfc, 0x42, 0x03, 0x2c, 0x01, 0xfe, 0xb5, 0xa8, 0x05, 0xb0, 0xfb, 0xde, 0xc6, 0xdc, 0x57, + 0x59, 0x59, 0x57, 0xdb, 0xc3, 0x04, 0x26, 0xfb, 0xdd, 0x7b, 0x8a, 0x89, 0x7c, 0x04, 0x23, 0xfb, 0xdd, 0x7d, 0x88, + 0x89, 0x7d, 0x04, 0x22, 0xe8, 0x6b, 0x6b, 0x7d, 0x7d, 0x00, 0x00, 0x02, 0x00, 0x81, 0xff, 0xeb, 0x05, 0xad, 0x05, + 0xb0, 0x00, 0x1e, 0x00, 0x26, 0x00, 0x87, 0xb2, 0x06, 0x27, 0x28, 0x11, 0x12, 0x39, 0xb0, 0x06, 0x10, 0xb0, 0x23, + 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x15, 0x2f, 0x1b, 0xb1, 0x15, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x1e, 0x2f, 0x1b, 0xb1, 0x1e, + 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x12, 0x3e, 0x59, 0xb0, 0x04, 0xd0, + 0xb0, 0x04, 0x2f, 0xb2, 0x06, 0x08, 0x0d, 0x11, 0x12, 0x39, 0xb0, 0x08, 0x10, 0xb1, 0x11, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x1a, 0xd0, 0xb0, 0x0d, 0x10, 0xb0, 0x25, 0xd0, 0xb0, 0x25, 0x2f, 0xb0, + 0x26, 0xd0, 0xb0, 0x26, 0x2f, 0xb1, 0x20, 0x06, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x26, + 0x10, 0xb0, 0x23, 0xd0, 0xb0, 0x23, 0x2f, 0x30, 0x31, 0x01, 0x11, 0x14, 0x06, 0x23, 0x22, 0x27, 0x06, 0x23, 0x22, + 0x26, 0x27, 0x11, 0x33, 0x11, 0x16, 0x16, 0x33, 0x32, 0x36, 0x35, 0x11, 0x33, 0x11, 0x14, 0x16, 0x33, 0x32, 0x36, + 0x37, 0x11, 0x01, 0x35, 0x21, 0x17, 0x21, 0x15, 0x23, 0x35, 0x05, 0xad, 0xca, 0xae, 0xc6, 0x59, 0x5f, 0xce, 0xa7, + 0xc0, 0x01, 0xb9, 0x01, 0x5b, 0x53, 0x62, 0x6f, 0xba, 0x65, 0x5c, 0x59, 0x65, 0x01, 0xfc, 0x93, 0x03, 0x2c, 0x03, + 0xfe, 0xb3, 0xa9, 0x04, 0x3a, 0xfd, 0x27, 0xb0, 0xc6, 0x94, 0x94, 0xc3, 0xb0, 0x02, 0xdc, 0xfd, 0x23, 0x66, 0x75, + 0x78, 0x67, 0x02, 0xd9, 0xfd, 0x27, 0x67, 0x78, 0x75, 0x66, 0x02, 0xdd, 0x01, 0x0b, 0x6b, 0x6b, 0x80, 0x80, 0x00, + 0x00, 0x01, 0x00, 0x75, 0xfe, 0x84, 0x04, 0xbc, 0x05, 0xc5, 0x00, 0x19, 0x00, 0x4b, 0xb2, 0x18, 0x1a, 0x1b, 0x11, + 0x12, 0x39, 0x00, 0xb0, 0x00, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1e, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x0a, 0x10, 0xb0, 0x0e, 0xd0, + 0xb0, 0x0a, 0x10, 0xb1, 0x11, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x02, 0x10, 0xb1, + 0x19, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x23, 0x11, 0x26, 0x00, 0x35, + 0x35, 0x34, 0x12, 0x24, 0x33, 0x32, 0x00, 0x17, 0x23, 0x26, 0x26, 0x23, 0x22, 0x02, 0x15, 0x15, 0x14, 0x12, 0x17, + 0x33, 0x03, 0x14, 0xbf, 0xd8, 0xfe, 0xf8, 0x8e, 0x01, 0x00, 0xa0, 0xf7, 0x01, 0x20, 0x02, 0xc1, 0x02, 0xb5, 0xa1, + 0xa0, 0xcd, 0xc5, 0x9d, 0x7c, 0xfe, 0x84, 0x01, 0x6c, 0x1c, 0x01, 0x56, 0xff, 0xf4, 0xb1, 0x01, 0x20, 0x9f, 0xfe, + 0xf8, 0xe0, 0x9e, 0xac, 0xfe, 0xfc, 0xd4, 0xf4, 0xca, 0xfe, 0xfb, 0x04, 0x00, 0x01, 0x00, 0x64, 0xfe, 0x82, 0x03, + 0xe0, 0x04, 0x4e, 0x00, 0x19, 0x00, 0x4b, 0xb2, 0x18, 0x1a, 0x1b, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x2f, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, + 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x0a, 0x10, 0xb0, 0x0e, 0xd0, 0xb0, 0x0a, 0x10, 0xb1, 0x11, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x02, 0x10, 0xb1, 0x18, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x23, 0x11, 0x26, 0x02, 0x35, 0x35, 0x34, 0x36, 0x36, 0x33, 0x32, 0x16, + 0x15, 0x23, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x17, 0x33, 0x02, 0xa2, 0xb9, 0xb1, 0xd4, 0x77, + 0xd7, 0x8b, 0xb3, 0xf0, 0xaf, 0x8f, 0x65, 0x84, 0x9c, 0x96, 0x82, 0x6d, 0xfe, 0x82, 0x01, 0x70, 0x1e, 0x01, 0x26, + 0xd9, 0x23, 0x99, 0xf9, 0x8a, 0xe1, 0xa8, 0x65, 0x8c, 0xda, 0xb5, 0x1f, 0xa8, 0xdb, 0x03, 0x00, 0x00, 0x01, 0x00, + 0x74, 0x00, 0x00, 0x04, 0x90, 0x05, 0x3e, 0x00, 0x13, 0x00, 0x13, 0x00, 0xb0, 0x0e, 0x2f, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0x30, 0x31, 0x01, 0x05, 0x07, 0x25, 0x03, 0x23, 0x13, 0x25, + 0x37, 0x05, 0x13, 0x25, 0x37, 0x05, 0x13, 0x33, 0x03, 0x05, 0x07, 0x25, 0x02, 0x58, 0x01, 0x21, 0x44, 0xfe, 0xdd, + 0xb6, 0xa8, 0xe1, 0xfe, 0xdf, 0x44, 0x01, 0x25, 0xcd, 0xfe, 0xde, 0x46, 0x01, 0x23, 0xbc, 0xa5, 0xe7, 0x01, 0x25, + 0x48, 0xfe, 0xe0, 0x01, 0xbe, 0xac, 0x7b, 0xaa, 0xfe, 0xbf, 0x01, 0x8e, 0xab, 0x7b, 0xab, 0x01, 0x6d, 0xab, 0x7d, + 0xab, 0x01, 0x4b, 0xfe, 0x68, 0xab, 0x7a, 0xaa, 0x00, 0x01, 0xfc, 0x67, 0x04, 0xa6, 0xff, 0x27, 0x05, 0xfc, 0x00, + 0x07, 0x00, 0x12, 0x00, 0xb0, 0x00, 0x2f, 0xb1, 0x03, 0x06, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0x30, 0x31, 0x01, 0x15, 0x27, 0x37, 0x21, 0x27, 0x17, 0x15, 0xfd, 0x0d, 0xa6, 0x01, 0x02, 0x1b, 0x01, 0xa5, 0x05, + 0x23, 0x7d, 0x01, 0xe9, 0x6c, 0x01, 0xd8, 0x00, 0x01, 0xfc, 0x71, 0x05, 0x17, 0xff, 0x64, 0x06, 0x15, 0x00, 0x13, + 0x00, 0x30, 0x00, 0xb0, 0x0e, 0x2f, 0xb0, 0x08, 0xd0, 0xb0, 0x08, 0x2f, 0xb1, 0x00, 0x02, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0e, 0x10, 0xb0, 0x05, 0xd0, 0xb0, 0x05, 0x2f, 0xb0, 0x0e, 0x10, 0xb1, 0x0f, + 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x32, 0x16, 0x15, 0x15, 0x23, 0x35, + 0x34, 0x23, 0x22, 0x07, 0x07, 0x06, 0x07, 0x23, 0x35, 0x32, 0x3e, 0x02, 0xfe, 0x76, 0x6f, 0x7f, 0x80, 0x72, 0x2a, + 0x2d, 0x6f, 0x89, 0x76, 0x3c, 0x6c, 0x6a, 0xc1, 0x47, 0x06, 0x15, 0x6c, 0x6e, 0x24, 0x0e, 0x70, 0x12, 0x2f, 0x3a, + 0x02, 0x7e, 0x1b, 0x53, 0x11, 0x00, 0x01, 0xfd, 0x66, 0x05, 0x16, 0xfe, 0x54, 0x06, 0x57, 0x00, 0x05, 0x00, 0x0c, + 0x00, 0xb0, 0x01, 0x2f, 0xb0, 0x05, 0xd0, 0xb0, 0x05, 0x2f, 0x30, 0x31, 0x01, 0x35, 0x33, 0x15, 0x17, 0x07, 0xfd, + 0x66, 0xb3, 0x3b, 0x4d, 0x05, 0xdc, 0x7b, 0x8c, 0x74, 0x41, 0x00, 0x00, 0x01, 0xfd, 0xa4, 0x05, 0x16, 0xfe, 0x93, + 0x06, 0x57, 0x00, 0x05, 0x00, 0x0c, 0x00, 0xb0, 0x03, 0x2f, 0xb0, 0x00, 0xd0, 0xb0, 0x00, 0x2f, 0x30, 0x31, 0x01, + 0x27, 0x37, 0x27, 0x33, 0x15, 0xfd, 0xf1, 0x4d, 0x3b, 0x01, 0xb5, 0x05, 0x16, 0x41, 0x74, 0x8c, 0x7b, 0x00, 0x08, + 0xfa, 0x1b, 0xfe, 0xc4, 0x01, 0xb6, 0x05, 0xaf, 0x00, 0x0c, 0x00, 0x1a, 0x00, 0x27, 0x00, 0x35, 0x00, 0x42, 0x00, + 0x4f, 0x00, 0x5c, 0x00, 0x6a, 0x00, 0x7f, 0x00, 0xb0, 0x45, 0x2f, 0xb0, 0x53, 0x2f, 0xb0, 0x60, 0x2f, 0xb0, 0x38, + 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1e, 0x3e, 0x59, 0xb1, 0x09, 0x0b, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x45, 0x10, 0xb0, 0x10, 0xd0, 0xb0, 0x45, 0x10, 0xb1, 0x4c, 0x0b, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x17, 0xd0, 0xb0, 0x53, 0x10, 0xb0, 0x1e, 0xd0, 0xb0, + 0x53, 0x10, 0xb1, 0x5a, 0x0b, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x25, 0xd0, 0xb0, 0x60, + 0x10, 0xb0, 0x2b, 0xd0, 0xb0, 0x60, 0x10, 0xb1, 0x67, 0x0b, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb0, 0x32, 0xd0, 0xb0, 0x38, 0x10, 0xb1, 0x3f, 0x0b, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, + 0x31, 0x01, 0x34, 0x36, 0x32, 0x16, 0x15, 0x23, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x01, 0x34, 0x36, 0x33, 0x32, + 0x16, 0x15, 0x23, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x13, 0x34, 0x36, 0x33, 0x32, 0x16, 0x15, 0x23, 0x34, 0x26, + 0x22, 0x06, 0x15, 0x01, 0x34, 0x36, 0x33, 0x32, 0x16, 0x15, 0x23, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x01, 0x34, + 0x36, 0x32, 0x16, 0x15, 0x23, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x01, 0x34, 0x36, 0x32, 0x16, 0x15, 0x23, 0x34, + 0x26, 0x23, 0x22, 0x06, 0x15, 0x01, 0x34, 0x36, 0x33, 0x32, 0x16, 0x15, 0x23, 0x34, 0x26, 0x22, 0x06, 0x15, 0x13, + 0x34, 0x36, 0x33, 0x32, 0x16, 0x15, 0x23, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0xfd, 0x08, 0x73, 0xbe, 0x74, 0x70, + 0x33, 0x30, 0x2e, 0x33, 0x01, 0xde, 0x74, 0x5d, 0x5f, 0x75, 0x71, 0x35, 0x2e, 0x2c, 0x33, 0x48, 0x75, 0x5d, 0x5f, + 0x74, 0x70, 0x35, 0x5c, 0x33, 0xfe, 0xcb, 0x74, 0x5d, 0x5f, 0x74, 0x70, 0x35, 0x2e, 0x2d, 0x33, 0xfd, 0x4f, 0x73, + 0xbe, 0x74, 0x70, 0x33, 0x30, 0x2e, 0x33, 0xfd, 0x4d, 0x74, 0xbe, 0x74, 0x70, 0x33, 0x30, 0x2e, 0x33, 0xfe, 0xde, + 0x75, 0x5d, 0x5f, 0x74, 0x70, 0x35, 0x5c, 0x33, 0x35, 0x75, 0x5d, 0x5f, 0x75, 0x71, 0x35, 0x2e, 0x2d, 0x33, 0x04, + 0xf3, 0x54, 0x68, 0x68, 0x54, 0x2e, 0x37, 0x35, 0x30, 0xfe, 0xeb, 0x54, 0x68, 0x67, 0x55, 0x31, 0x34, 0x35, 0x30, + 0xfe, 0x09, 0x55, 0x67, 0x68, 0x54, 0x31, 0x34, 0x37, 0x2e, 0xfd, 0xf9, 0x54, 0x68, 0x68, 0x54, 0x31, 0x34, 0x37, + 0x2e, 0xfe, 0xe4, 0x54, 0x68, 0x68, 0x54, 0x2e, 0x37, 0x37, 0x2e, 0x05, 0x1a, 0x54, 0x68, 0x68, 0x54, 0x2e, 0x37, + 0x35, 0x30, 0xfe, 0x09, 0x55, 0x67, 0x68, 0x54, 0x31, 0x34, 0x37, 0x2e, 0xfd, 0xf9, 0x55, 0x67, 0x67, 0x55, 0x31, + 0x34, 0x35, 0x30, 0x00, 0x00, 0x08, 0xfa, 0x2c, 0xfe, 0x63, 0x01, 0x6b, 0x05, 0xc6, 0x00, 0x04, 0x00, 0x09, 0x00, + 0x0e, 0x00, 0x13, 0x00, 0x18, 0x00, 0x1d, 0x00, 0x22, 0x00, 0x27, 0x00, 0x39, 0x00, 0xb0, 0x21, 0x2f, 0xb0, 0x12, + 0x2f, 0xb0, 0x0b, 0x2f, 0xb0, 0x1b, 0x2f, 0xb0, 0x26, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, + 0x07, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x16, 0x2f, 0x1b, 0xb1, 0x16, 0x1c, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x14, 0x3e, 0x59, 0x30, 0x31, 0x05, 0x17, 0x03, 0x23, 0x13, 0x03, + 0x27, 0x13, 0x33, 0x03, 0x01, 0x37, 0x05, 0x15, 0x25, 0x05, 0x07, 0x25, 0x35, 0x05, 0x01, 0x37, 0x25, 0x17, 0x05, + 0x01, 0x07, 0x05, 0x27, 0x25, 0x03, 0x27, 0x03, 0x37, 0x13, 0x01, 0x17, 0x13, 0x07, 0x03, 0xfe, 0x2f, 0x0b, 0x7a, + 0x60, 0x46, 0x3a, 0x0c, 0x7a, 0x60, 0x46, 0x02, 0x1d, 0x0d, 0x01, 0x4d, 0xfe, 0xa6, 0xfb, 0x75, 0x0d, 0xfe, 0xb3, + 0x01, 0x5a, 0x03, 0x9c, 0x02, 0x01, 0x40, 0x44, 0xfe, 0xdb, 0xfc, 0xf3, 0x02, 0xfe, 0xc0, 0x45, 0x01, 0x26, 0x2b, + 0x11, 0x94, 0x41, 0xc6, 0x03, 0x60, 0x11, 0x94, 0x42, 0xc4, 0x3c, 0x0e, 0xfe, 0xad, 0x01, 0x61, 0x04, 0xa2, 0x0e, + 0x01, 0x52, 0xfe, 0xa0, 0xfe, 0x11, 0x0c, 0x7c, 0x62, 0x47, 0x3b, 0x0c, 0x7c, 0x62, 0x47, 0x01, 0xae, 0x10, 0x99, + 0x44, 0xc8, 0xfc, 0x8e, 0x11, 0x99, 0x45, 0xc8, 0x02, 0xe4, 0x02, 0x01, 0x46, 0x45, 0xfe, 0xd5, 0xfc, 0xe3, 0x02, + 0xfe, 0xbb, 0x47, 0x01, 0x2b, 0x00, 0xff, 0xff, 0x00, 0xb1, 0xfe, 0x9b, 0x05, 0xb3, 0x07, 0x19, 0x00, 0x26, 0x00, + 0xdc, 0x00, 0x00, 0x00, 0x27, 0x00, 0xa1, 0x01, 0x31, 0x01, 0x42, 0x01, 0x07, 0x00, 0x10, 0x04, 0x7f, 0xff, 0xbd, + 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1e, 0x3e, 0x59, 0xb0, 0x0d, 0xdc, + 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x9c, 0xfe, 0x9b, 0x04, 0xb5, 0x05, 0xc3, 0x00, 0x26, 0x00, 0xf0, 0x00, 0x00, + 0x00, 0x27, 0x00, 0xa1, 0x00, 0xa1, 0xff, 0xec, 0x01, 0x07, 0x00, 0x10, 0x03, 0x81, 0xff, 0xbd, 0x00, 0x13, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, 0x3e, 0x59, 0xb0, 0x0d, 0xdc, 0x30, 0x31, 0x00, + 0x00, 0x02, 0xff, 0xdc, 0x00, 0x00, 0x03, 0xfc, 0x06, 0x71, 0x00, 0x11, 0x00, 0x1a, 0x00, 0x77, 0xb2, 0x14, 0x1b, + 0x1c, 0x11, 0x12, 0x39, 0xb0, 0x14, 0x10, 0xb0, 0x03, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, + 0xb1, 0x0c, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x1e, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x12, 0x3e, 0x59, 0xb0, 0x10, 0x10, 0xb1, 0x00, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x02, 0x0c, 0x08, 0x11, 0x12, 0x39, 0xb0, 0x02, 0x2f, 0xb0, + 0x00, 0x10, 0xb0, 0x0a, 0xd0, 0xb0, 0x0b, 0xd0, 0xb0, 0x02, 0x10, 0xb1, 0x12, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, 0x10, 0xb1, 0x13, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0x30, 0x31, 0x01, 0x21, 0x11, 0x21, 0x16, 0x16, 0x10, 0x06, 0x07, 0x21, 0x11, 0x23, 0x35, 0x33, 0x35, 0x33, 0x15, + 0x21, 0x01, 0x11, 0x21, 0x32, 0x36, 0x35, 0x34, 0x26, 0x27, 0x02, 0x96, 0xfe, 0xbf, 0x01, 0x18, 0xbb, 0xd4, 0xd4, + 0xb7, 0xfe, 0x2a, 0xbf, 0xbf, 0xba, 0x01, 0x41, 0xfe, 0xbf, 0x01, 0x12, 0x69, 0x71, 0x6f, 0x64, 0x05, 0x18, 0xfd, + 0xd2, 0x02, 0xca, 0xfe, 0xb6, 0xd1, 0x03, 0x05, 0x18, 0x98, 0xc1, 0xc1, 0xfc, 0xa2, 0xfe, 0x45, 0x77, 0x64, 0x61, + 0x7d, 0x02, 0x00, 0x00, 0x02, 0x00, 0xa8, 0x00, 0x00, 0x04, 0xd7, 0x05, 0xb0, 0x00, 0x0e, 0x00, 0x1b, 0x00, 0x56, + 0xb2, 0x04, 0x1c, 0x1d, 0x11, 0x12, 0x39, 0xb0, 0x04, 0x10, 0xb0, 0x17, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x12, + 0x3e, 0x59, 0xb2, 0x16, 0x03, 0x01, 0x11, 0x12, 0x39, 0xb0, 0x16, 0x2f, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x09, 0x00, 0x03, 0x11, 0x12, 0x39, 0xb0, 0x03, 0x10, 0xb1, 0x14, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x11, 0x23, 0x11, 0x21, 0x32, 0x04, 0x15, 0x14, + 0x07, 0x17, 0x07, 0x27, 0x06, 0x23, 0x01, 0x36, 0x35, 0x34, 0x26, 0x27, 0x21, 0x11, 0x21, 0x32, 0x37, 0x27, 0x37, + 0x01, 0x69, 0xc1, 0x02, 0x19, 0xec, 0x01, 0x13, 0x67, 0x7e, 0x6d, 0x8b, 0x76, 0xa8, 0x01, 0x19, 0x25, 0xa5, 0x91, + 0xfe, 0xa0, 0x01, 0x58, 0x62, 0x45, 0x6e, 0x6e, 0x02, 0x3a, 0xfd, 0xc6, 0x05, 0xb0, 0xf2, 0xcb, 0xba, 0x70, 0x8a, + 0x67, 0x99, 0x37, 0x01, 0x1b, 0x41, 0x5b, 0x82, 0x9d, 0x02, 0xfd, 0xc5, 0x1d, 0x79, 0x66, 0x00, 0x00, 0x02, 0x00, + 0x8c, 0xfe, 0x60, 0x04, 0x23, 0x04, 0x4e, 0x00, 0x13, 0x00, 0x22, 0x00, 0x77, 0xb2, 0x1c, 0x23, 0x24, 0x11, 0x12, + 0x39, 0xb0, 0x1c, 0x10, 0xb0, 0x10, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x1a, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x14, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, + 0x12, 0x3e, 0x59, 0xb2, 0x02, 0x07, 0x10, 0x11, 0x12, 0x39, 0xb2, 0x09, 0x10, 0x07, 0x11, 0x12, 0x39, 0xb2, 0x0e, + 0x10, 0x07, 0x11, 0x12, 0x39, 0xb0, 0x10, 0x10, 0xb1, 0x17, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb0, 0x07, 0x10, 0xb1, 0x1c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, + 0x14, 0x07, 0x17, 0x07, 0x27, 0x06, 0x23, 0x22, 0x27, 0x11, 0x23, 0x11, 0x33, 0x17, 0x36, 0x33, 0x32, 0x12, 0x11, + 0x27, 0x34, 0x26, 0x23, 0x22, 0x07, 0x11, 0x16, 0x33, 0x32, 0x37, 0x27, 0x37, 0x17, 0x36, 0x04, 0x1e, 0x6a, 0x6f, + 0x6e, 0x6e, 0x59, 0x73, 0xc5, 0x71, 0xb9, 0xa9, 0x09, 0x71, 0xc9, 0xc3, 0xe3, 0xb9, 0x9c, 0x88, 0xa8, 0x54, 0x53, + 0xab, 0x52, 0x3c, 0x66, 0x6e, 0x5a, 0x32, 0x02, 0x11, 0xee, 0x97, 0x7d, 0x66, 0x7b, 0x38, 0x7d, 0xfd, 0xf7, 0x05, + 0xda, 0x78, 0x8c, 0xfe, 0xda, 0xfe, 0xfa, 0x04, 0xb7, 0xd4, 0x95, 0xfd, 0xfb, 0x94, 0x27, 0x73, 0x67, 0x67, 0x62, + 0x00, 0x00, 0x01, 0x00, 0xa2, 0x00, 0x00, 0x04, 0x23, 0x07, 0x00, 0x00, 0x09, 0x00, 0x36, 0xb2, 0x03, 0x0a, 0x0b, + 0x11, 0x12, 0x39, 0x00, 0xb0, 0x08, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb0, 0x06, 0x10, 0xb1, 0x02, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x23, 0x15, 0x21, 0x11, 0x23, 0x11, + 0x21, 0x11, 0x33, 0x04, 0x23, 0x03, 0xfd, 0x42, 0xc0, 0x02, 0xc8, 0xb9, 0x05, 0x18, 0x06, 0xfa, 0xee, 0x05, 0xb0, + 0x01, 0x50, 0x00, 0x01, 0x00, 0x91, 0x00, 0x00, 0x03, 0x42, 0x05, 0x76, 0x00, 0x07, 0x00, 0x2f, 0x00, 0xb0, 0x06, + 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x04, 0x10, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, 0x11, 0x23, 0x11, 0x21, 0x11, 0x33, 0x03, 0x42, 0xfe, 0x09, 0xba, + 0x01, 0xf8, 0xb9, 0x03, 0xa1, 0xfc, 0x5f, 0x04, 0x3a, 0x01, 0x3c, 0x00, 0x00, 0x01, 0x00, 0xb1, 0xfe, 0xdf, 0x04, + 0x7c, 0x05, 0xb0, 0x00, 0x15, 0x00, 0x5e, 0xb2, 0x0a, 0x16, 0x17, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x09, 0x2f, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x14, 0x2f, 0x1b, 0xb1, 0x14, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x12, 0x2f, + 0x1b, 0xb1, 0x12, 0x12, 0x3e, 0x59, 0xb0, 0x14, 0x10, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb2, 0x03, 0x14, 0x09, 0x11, 0x12, 0x39, 0xb0, 0x03, 0x2f, 0xb0, 0x09, 0x10, 0xb1, 0x0a, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x10, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, 0x11, 0x33, 0x20, 0x00, 0x11, 0x10, 0x02, 0x23, 0x27, 0x32, 0x36, + 0x35, 0x26, 0x26, 0x23, 0x23, 0x11, 0x23, 0x11, 0x21, 0x04, 0x30, 0xfd, 0x42, 0xb2, 0x01, 0x1c, 0x01, 0x3c, 0xf5, + 0xe4, 0x02, 0x91, 0x90, 0x01, 0xcc, 0xce, 0xb5, 0xc1, 0x03, 0x7f, 0x05, 0x12, 0xfe, 0x2f, 0xfe, 0xcf, 0xfe, 0xf0, + 0xfe, 0xf8, 0xfe, 0xe7, 0x93, 0xc3, 0xcb, 0xcb, 0xd4, 0xfd, 0x61, 0x05, 0xb0, 0x00, 0x01, 0x00, 0x91, 0xfe, 0xe5, + 0x03, 0xbe, 0x04, 0x3a, 0x00, 0x16, 0x00, 0x5e, 0xb2, 0x0b, 0x17, 0x18, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x0a, 0x2f, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x15, 0x2f, 0x1b, 0xb1, 0x15, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x13, + 0x2f, 0x1b, 0xb1, 0x13, 0x12, 0x3e, 0x59, 0xb0, 0x15, 0x10, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb2, 0x03, 0x15, 0x0a, 0x11, 0x12, 0x39, 0xb0, 0x03, 0x2f, 0xb0, 0x0a, 0x10, 0xb1, 0x0b, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x11, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, 0x11, 0x33, 0x32, 0x00, 0x15, 0x14, 0x06, 0x06, 0x07, 0x27, + 0x36, 0x36, 0x35, 0x34, 0x26, 0x23, 0x23, 0x11, 0x23, 0x11, 0x21, 0x03, 0x3e, 0xfe, 0x0d, 0x6c, 0xef, 0x01, 0x18, + 0x62, 0xaa, 0x75, 0x30, 0x80, 0x78, 0xb2, 0x98, 0x70, 0xba, 0x02, 0xad, 0x03, 0xa1, 0xfe, 0xe4, 0xfe, 0xfc, 0xd7, + 0x62, 0xc8, 0x86, 0x15, 0x92, 0x21, 0x99, 0x79, 0x91, 0xa8, 0xfe, 0x1d, 0x04, 0x3a, 0xff, 0xff, 0x00, 0x1b, 0xfe, + 0x99, 0x07, 0x82, 0x05, 0xb0, 0x00, 0x26, 0x00, 0xda, 0x00, 0x00, 0x00, 0x07, 0x02, 0x51, 0x06, 0x61, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x15, 0xfe, 0x99, 0x06, 0x3d, 0x04, 0x3a, 0x00, 0x26, 0x00, 0xee, 0x00, 0x00, 0x00, 0x07, 0x02, + 0x51, 0x05, 0x1c, 0x00, 0x00, 0xff, 0xff, 0x00, 0xb2, 0xfe, 0x97, 0x05, 0x44, 0x05, 0xb0, 0x00, 0x26, 0x02, 0x2c, + 0x00, 0x00, 0x00, 0x07, 0x02, 0x51, 0x04, 0x23, 0xff, 0xfe, 0xff, 0xff, 0x00, 0x9c, 0xfe, 0x99, 0x04, 0x81, 0x04, + 0x3a, 0x00, 0x26, 0x00, 0xf1, 0x00, 0x00, 0x00, 0x07, 0x02, 0x51, 0x03, 0x60, 0x00, 0x00, 0x00, 0x01, 0x00, 0xa3, + 0x00, 0x00, 0x04, 0xff, 0x05, 0xb0, 0x00, 0x14, 0x00, 0x63, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, + 0xb1, 0x00, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x1e, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, + 0x1b, 0xb1, 0x0a, 0x12, 0x3e, 0x59, 0xb0, 0x0f, 0xd0, 0xb0, 0x0f, 0x2f, 0xb2, 0x2f, 0x0f, 0x01, 0x5d, 0xb2, 0xcf, + 0x0f, 0x01, 0x5d, 0xb1, 0x08, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x01, 0x08, 0x0f, + 0x11, 0x12, 0x39, 0xb0, 0x05, 0xd0, 0xb0, 0x0f, 0x10, 0xb0, 0x12, 0xd0, 0x30, 0x31, 0x09, 0x02, 0x23, 0x01, 0x23, + 0x15, 0x23, 0x35, 0x23, 0x11, 0x23, 0x11, 0x33, 0x11, 0x33, 0x11, 0x33, 0x11, 0x33, 0x01, 0x04, 0xd2, 0xfe, 0x70, + 0x01, 0xbd, 0xf1, 0xfe, 0xa2, 0x50, 0x94, 0x68, 0xc1, 0xc1, 0x68, 0x94, 0x4d, 0x01, 0x43, 0x05, 0xb0, 0xfd, 0x4e, + 0xfd, 0x02, 0x02, 0x8e, 0xf4, 0xf4, 0xfd, 0x72, 0x05, 0xb0, 0xfd, 0x7f, 0x01, 0x00, 0xff, 0x00, 0x02, 0x81, 0x00, + 0x01, 0x00, 0x9a, 0x00, 0x00, 0x04, 0x7f, 0x04, 0x3a, 0x00, 0x14, 0x00, 0x7c, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x14, 0x2f, 0x1b, 0xb1, 0x14, 0x1a, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x12, 0x3e, 0x59, 0xb0, 0x0a, 0x10, 0xb0, 0x0e, 0xd0, 0xb0, 0x0e, 0x2f, 0xb2, + 0x9f, 0x0e, 0x01, 0x5d, 0xb2, 0xff, 0x0e, 0x01, 0x5d, 0xb2, 0x9f, 0x0e, 0x01, 0x71, 0xb4, 0xbf, 0x0e, 0xcf, 0x0e, + 0x02, 0x5d, 0xb2, 0x2f, 0x0e, 0x01, 0x5d, 0xb2, 0x6f, 0x0e, 0x01, 0x72, 0xb1, 0x09, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x01, 0x09, 0x0e, 0x11, 0x12, 0x39, 0xb0, 0x05, 0xd0, 0xb0, 0x0e, 0x10, 0xb0, + 0x12, 0xd0, 0x30, 0x31, 0x09, 0x02, 0x23, 0x01, 0x23, 0x15, 0x23, 0x35, 0x23, 0x11, 0x23, 0x11, 0x33, 0x11, 0x33, + 0x35, 0x33, 0x15, 0x33, 0x01, 0x04, 0x5a, 0xfe, 0xae, 0x01, 0x77, 0xeb, 0xfe, 0xeb, 0x32, 0x94, 0x65, 0xba, 0xba, + 0x65, 0x94, 0x2a, 0x01, 0x03, 0x04, 0x3a, 0xfd, 0xfe, 0xfd, 0xc8, 0x01, 0xcd, 0xc2, 0xc2, 0xfe, 0x33, 0x04, 0x3a, + 0xfe, 0x36, 0xd5, 0xd5, 0x01, 0xca, 0x00, 0x00, 0x01, 0x00, 0x44, 0x00, 0x00, 0x06, 0x8b, 0x05, 0xb0, 0x00, 0x0e, + 0x00, 0x6d, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, + 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x12, 0x3e, 0x59, 0xb2, 0x08, + 0x06, 0x02, 0x11, 0x12, 0x39, 0xb0, 0x08, 0x2f, 0xb2, 0x2f, 0x08, 0x01, 0x5d, 0xb2, 0xcf, 0x08, 0x01, 0x5d, 0xb1, + 0x01, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x06, 0x10, 0xb1, 0x04, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x0c, 0x01, 0x08, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x23, 0x11, + 0x23, 0x11, 0x21, 0x35, 0x21, 0x11, 0x33, 0x01, 0x33, 0x01, 0x01, 0x23, 0x03, 0x90, 0xb0, 0xc1, 0xfe, 0x25, 0x02, + 0x9c, 0x96, 0x01, 0xfc, 0xef, 0xfd, 0xd4, 0x02, 0x56, 0xec, 0x02, 0x8e, 0xfd, 0x72, 0x05, 0x18, 0x98, 0xfd, 0x7e, + 0x02, 0x82, 0xfd, 0x3f, 0xfd, 0x11, 0x00, 0x01, 0x00, 0x3e, 0x00, 0x00, 0x05, 0x7d, 0x04, 0x3a, 0x00, 0x0e, 0x00, + 0x82, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, + 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x12, 0x3e, 0x59, 0xb0, 0x02, 0x10, + 0xb0, 0x09, 0xd0, 0xb0, 0x09, 0x2f, 0xb2, 0x9f, 0x09, 0x01, 0x5d, 0xb2, 0xff, 0x09, 0x01, 0x5d, 0xb2, 0x9f, 0x09, + 0x01, 0x71, 0xb4, 0xbf, 0x09, 0xcf, 0x09, 0x02, 0x5d, 0xb2, 0x2f, 0x09, 0x01, 0x5d, 0xb2, 0x6f, 0x09, 0x01, 0x72, + 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x06, 0x10, 0xb1, 0x04, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x0c, 0x00, 0x09, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x23, + 0x11, 0x23, 0x11, 0x21, 0x35, 0x21, 0x11, 0x33, 0x01, 0x33, 0x01, 0x01, 0x23, 0x03, 0x1b, 0x88, 0xba, 0xfe, 0x65, + 0x02, 0x55, 0x7a, 0x01, 0x6b, 0xe1, 0xfe, 0x53, 0x01, 0xd1, 0xeb, 0x01, 0xcd, 0xfe, 0x33, 0x03, 0xa1, 0x99, 0xfe, + 0x36, 0x01, 0xca, 0xfd, 0xf8, 0xfd, 0xce, 0x00, 0xff, 0xff, 0x00, 0xa9, 0xfe, 0x99, 0x05, 0xa9, 0x05, 0xb0, 0x00, + 0x26, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x07, 0x02, 0x51, 0x04, 0x88, 0x00, 0x00, 0xff, 0xff, 0x00, 0x9c, 0xfe, 0x99, + 0x04, 0xa2, 0x04, 0x3a, 0x00, 0x26, 0x00, 0xf4, 0x00, 0x00, 0x00, 0x07, 0x02, 0x51, 0x03, 0x81, 0x00, 0x00, 0x00, + 0x01, 0x00, 0xa8, 0x00, 0x00, 0x07, 0x84, 0x05, 0xb0, 0x00, 0x0d, 0x00, 0x60, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x1e, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x12, 0x3e, 0x59, 0xb0, 0x01, 0xd0, 0xb0, 0x01, 0x2f, 0xb2, 0x2f, 0x01, 0x01, + 0x5d, 0xb0, 0x02, 0x10, 0xb1, 0x04, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x01, 0x10, + 0xb1, 0x08, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, 0x11, 0x21, 0x15, + 0x21, 0x11, 0x23, 0x11, 0x21, 0x11, 0x23, 0x11, 0x33, 0x01, 0x69, 0x02, 0xde, 0x03, 0x3d, 0xfd, 0x83, 0xc0, 0xfd, + 0x22, 0xc1, 0xc1, 0x03, 0x3e, 0x02, 0x72, 0x98, 0xfa, 0xe8, 0x02, 0xa1, 0xfd, 0x5f, 0x05, 0xb0, 0x00, 0x01, 0x00, + 0x91, 0x00, 0x00, 0x05, 0x69, 0x04, 0x3a, 0x00, 0x0d, 0x00, 0x9d, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, + 0x1b, 0xb1, 0x02, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x1a, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, + 0x2f, 0x1b, 0xb1, 0x0a, 0x12, 0x3e, 0x59, 0xb0, 0x06, 0x10, 0xb0, 0x01, 0xd0, 0xb0, 0x01, 0x2f, 0xb2, 0x6f, 0x01, + 0x01, 0x5d, 0xb4, 0xbf, 0x01, 0xcf, 0x01, 0x02, 0x5d, 0xb2, 0x3f, 0x01, 0x01, 0x71, 0xb4, 0xcf, 0x01, 0xdf, 0x01, + 0x02, 0x71, 0xb2, 0x0f, 0x01, 0x01, 0x72, 0xb4, 0x9f, 0x01, 0xaf, 0x01, 0x02, 0x71, 0xb2, 0xff, 0x01, 0x01, 0x5d, + 0xb2, 0x0f, 0x01, 0x01, 0x71, 0xb2, 0x9f, 0x01, 0x01, 0x5d, 0xb2, 0x2f, 0x01, 0x01, 0x5d, 0xb4, 0x6f, 0x01, 0x7f, + 0x01, 0x02, 0x72, 0xb0, 0x02, 0x10, 0xb1, 0x04, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x01, 0x10, 0xb1, 0x08, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, 0x11, + 0x21, 0x15, 0x21, 0x11, 0x23, 0x11, 0x21, 0x11, 0x23, 0x11, 0x33, 0x01, 0x4b, 0x01, 0xf1, 0x02, 0x2d, 0xfe, 0x8c, + 0xb9, 0xfe, 0x0f, 0xba, 0xba, 0x02, 0x65, 0x01, 0xd5, 0x99, 0xfc, 0x5f, 0x01, 0xce, 0xfe, 0x32, 0x04, 0x3a, 0x00, + 0x00, 0x01, 0x00, 0xb0, 0xfe, 0xdf, 0x07, 0xcd, 0x05, 0xb0, 0x00, 0x17, 0x00, 0x6b, 0xb2, 0x11, 0x18, 0x19, 0x11, + 0x12, 0x39, 0x00, 0xb0, 0x07, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x16, 0x2f, 0x1b, 0xb1, 0x16, 0x1e, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x14, 0x2f, 0x1b, 0xb1, 0x14, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x11, + 0x2f, 0x1b, 0xb1, 0x11, 0x12, 0x3e, 0x59, 0xb2, 0x01, 0x16, 0x07, 0x11, 0x12, 0x39, 0xb0, 0x01, 0x2f, 0xb0, 0x07, + 0x10, 0xb1, 0x08, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x01, 0x10, 0xb1, 0x0e, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x16, 0x10, 0xb1, 0x12, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x33, 0x20, 0x00, 0x11, 0x10, 0x02, 0x23, 0x27, 0x32, 0x36, 0x35, + 0x26, 0x26, 0x23, 0x23, 0x11, 0x23, 0x11, 0x21, 0x11, 0x23, 0x11, 0x21, 0x04, 0xff, 0x76, 0x01, 0x1c, 0x01, 0x3c, + 0xf5, 0xe4, 0x02, 0x91, 0x90, 0x01, 0xcc, 0xce, 0x79, 0xc1, 0xfd, 0x32, 0xc0, 0x04, 0x4f, 0x03, 0x41, 0xfe, 0xcf, + 0xfe, 0xf0, 0xfe, 0xf8, 0xfe, 0xe7, 0x93, 0xc3, 0xcb, 0xcb, 0xd4, 0xfd, 0x61, 0x05, 0x12, 0xfa, 0xee, 0x05, 0xb0, + 0x00, 0x01, 0x00, 0x91, 0xfe, 0xe5, 0x06, 0xb0, 0x04, 0x3a, 0x00, 0x18, 0x00, 0x6b, 0xb2, 0x12, 0x19, 0x1a, 0x11, + 0x12, 0x39, 0x00, 0xb0, 0x08, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x17, 0x2f, 0x1b, 0xb1, 0x17, 0x1a, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x15, 0x2f, 0x1b, 0xb1, 0x15, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x12, + 0x2f, 0x1b, 0xb1, 0x12, 0x12, 0x3e, 0x59, 0xb2, 0x01, 0x17, 0x08, 0x11, 0x12, 0x39, 0xb0, 0x01, 0x2f, 0xb0, 0x08, + 0x10, 0xb1, 0x09, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x01, 0x10, 0xb1, 0x0f, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x17, 0x10, 0xb1, 0x13, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x33, 0x32, 0x00, 0x15, 0x07, 0x06, 0x06, 0x07, 0x27, 0x36, 0x36, + 0x35, 0x34, 0x26, 0x23, 0x23, 0x11, 0x23, 0x11, 0x21, 0x11, 0x23, 0x11, 0x21, 0x03, 0xf6, 0xa0, 0xf8, 0x01, 0x22, + 0x03, 0x14, 0xd1, 0x99, 0x30, 0x7c, 0x7b, 0xbc, 0xa0, 0xa4, 0xb9, 0xfe, 0x0e, 0xba, 0x03, 0x65, 0x02, 0x85, 0xfe, + 0xfc, 0xd7, 0x26, 0xa3, 0xe1, 0x1b, 0x92, 0x20, 0x96, 0x7d, 0x92, 0xa7, 0xfe, 0x1d, 0x03, 0xa1, 0xfc, 0x5f, 0x04, + 0x3a, 0x00, 0x00, 0x02, 0x00, 0x71, 0xff, 0xe4, 0x05, 0xa2, 0x05, 0xc5, 0x00, 0x28, 0x00, 0x36, 0x00, 0xa0, 0xb2, + 0x18, 0x37, 0x38, 0x11, 0x12, 0x39, 0xb0, 0x18, 0x10, 0xb0, 0x29, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, + 0x2f, 0x1b, 0xb1, 0x0d, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x1f, 0x2f, 0x1b, 0xb1, 0x1f, 0x1e, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0xd0, 0xb0, 0x00, + 0x2f, 0xb2, 0x02, 0x04, 0x1f, 0x11, 0x12, 0x39, 0xb0, 0x02, 0x2f, 0xb0, 0x0d, 0x10, 0xb1, 0x0e, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0x10, 0xb1, 0x15, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x02, 0x10, 0xb1, 0x2c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, + 0x17, 0x02, 0x2c, 0x11, 0x12, 0x39, 0xb2, 0x26, 0x2c, 0x02, 0x11, 0x12, 0x39, 0xb0, 0x00, 0x10, 0xb1, 0x28, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x1f, 0x10, 0xb1, 0x33, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x05, 0x22, 0x27, 0x06, 0x23, 0x22, 0x24, 0x02, 0x35, 0x35, 0x34, 0x12, + 0x36, 0x33, 0x17, 0x22, 0x06, 0x15, 0x15, 0x14, 0x12, 0x33, 0x32, 0x37, 0x26, 0x02, 0x35, 0x35, 0x34, 0x36, 0x36, + 0x33, 0x32, 0x12, 0x15, 0x15, 0x14, 0x02, 0x07, 0x16, 0x33, 0x01, 0x14, 0x16, 0x17, 0x36, 0x36, 0x35, 0x35, 0x34, + 0x26, 0x23, 0x22, 0x06, 0x15, 0x05, 0xa2, 0xd7, 0xb3, 0x8e, 0xac, 0xb2, 0xfe, 0xe4, 0x9f, 0x75, 0xd2, 0x84, 0x01, + 0x76, 0x94, 0xec, 0xbf, 0x46, 0x38, 0x79, 0x84, 0x68, 0xbd, 0x76, 0xb6, 0xe6, 0x6f, 0x66, 0x68, 0x79, 0xfd, 0x7d, + 0x78, 0x75, 0x62, 0x68, 0x79, 0x63, 0x61, 0x7a, 0x1c, 0x49, 0x42, 0xb2, 0x01, 0x42, 0xc4, 0xac, 0xb1, 0x01, 0x22, + 0xa3, 0xa5, 0xfe, 0xd9, 0xa6, 0xec, 0xfe, 0xd7, 0x0d, 0x61, 0x01, 0x15, 0xaa, 0xe3, 0x9a, 0xfd, 0x8d, 0xfe, 0xcc, + 0xfd, 0xeb, 0x9e, 0xfe, 0xf6, 0x5f, 0x1a, 0x02, 0x34, 0x98, 0xed, 0x4a, 0x48, 0xe7, 0x8d, 0xf9, 0xb1, 0xce, 0xd2, + 0xb2, 0x00, 0x02, 0x00, 0x6d, 0xff, 0xeb, 0x04, 0x9c, 0x04, 0x4f, 0x00, 0x24, 0x00, 0x2f, 0x00, 0xa7, 0xb2, 0x04, + 0x30, 0x31, 0x11, 0x12, 0x39, 0xb0, 0x04, 0x10, 0xb0, 0x25, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, + 0x1b, 0xb1, 0x0c, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x1c, 0x2f, 0x1b, 0xb1, 0x1c, 0x1a, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, + 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb2, 0x02, 0x04, 0x1c, 0x11, 0x12, 0x39, 0xb0, 0x02, 0x2f, 0xb0, 0x0c, + 0x10, 0xb1, 0x0d, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0x10, 0xb1, 0x14, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x02, 0x10, 0xb1, 0x27, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x16, 0x14, 0x27, 0x11, 0x12, 0x39, 0xb0, 0x00, 0x10, 0xb1, 0x24, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x22, 0x27, 0x24, 0x11, 0x12, 0x39, 0xb0, 0x1c, 0x10, 0xb1, + 0x2c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x05, 0x22, 0x27, 0x06, 0x23, 0x22, + 0x26, 0x02, 0x35, 0x35, 0x34, 0x12, 0x33, 0x15, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x32, 0x37, 0x26, 0x11, + 0x35, 0x34, 0x36, 0x33, 0x32, 0x16, 0x15, 0x15, 0x14, 0x07, 0x16, 0x33, 0x01, 0x14, 0x17, 0x36, 0x37, 0x35, 0x34, + 0x26, 0x22, 0x06, 0x07, 0x04, 0x9c, 0xb2, 0x8c, 0x76, 0x8f, 0x8c, 0xe1, 0x7f, 0xc5, 0x9b, 0x49, 0x5d, 0xa9, 0x89, + 0x2e, 0x2c, 0xc1, 0xad, 0x8f, 0x8c, 0xb2, 0x80, 0x4f, 0x61, 0xfe, 0x0f, 0x9f, 0x66, 0x03, 0x49, 0x78, 0x46, 0x01, + 0x0c, 0x39, 0x42, 0x95, 0x01, 0x12, 0xa7, 0x3a, 0xcd, 0x01, 0x0e, 0x9e, 0xad, 0x92, 0x38, 0xc1, 0xf0, 0x0b, 0xa2, + 0x01, 0x11, 0x5e, 0xc0, 0xeb, 0xf9, 0xce, 0x62, 0xe3, 0x9d, 0x15, 0x01, 0xa9, 0xd6, 0x74, 0x73, 0xba, 0x75, 0x82, + 0x9e, 0x8d, 0x7a, 0xff, 0xff, 0x00, 0x39, 0xfe, 0x99, 0x04, 0xf8, 0x05, 0xb0, 0x00, 0x26, 0x00, 0x3c, 0x00, 0x00, + 0x00, 0x07, 0x02, 0x51, 0x03, 0xd7, 0x00, 0x00, 0xff, 0xff, 0x00, 0x29, 0xfe, 0x99, 0x04, 0x06, 0x04, 0x3a, 0x00, + 0x26, 0x00, 0x5c, 0x00, 0x00, 0x00, 0x07, 0x02, 0x51, 0x02, 0xe5, 0x00, 0x00, 0x00, 0x01, 0x00, 0x34, 0xfe, 0xa1, + 0x06, 0x93, 0x05, 0xb0, 0x00, 0x13, 0x00, 0x5d, 0x00, 0xb0, 0x11, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, + 0x1b, 0xb1, 0x07, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x1e, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x13, 0x2f, 0x1b, 0xb1, 0x13, 0x12, 0x3e, 0x59, 0xb0, 0x07, 0x10, 0xb1, 0x08, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x00, 0xd0, 0xb0, 0x07, 0x10, 0xb0, 0x05, 0xd0, 0xb0, + 0x03, 0xd0, 0xb0, 0x02, 0xd0, 0xb0, 0x13, 0x10, 0xb1, 0x0a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb0, 0x0e, 0xd0, 0x30, 0x31, 0x01, 0x21, 0x35, 0x21, 0x35, 0x33, 0x15, 0x21, 0x15, 0x21, 0x11, 0x21, 0x11, + 0x33, 0x11, 0x33, 0x03, 0x23, 0x11, 0x21, 0x01, 0xab, 0xfe, 0x89, 0x01, 0x77, 0xc1, 0x01, 0x81, 0xfe, 0x7f, 0x02, + 0xce, 0xc1, 0x98, 0x12, 0xac, 0xfb, 0xd6, 0x05, 0x18, 0x97, 0x01, 0x01, 0x97, 0xfb, 0x85, 0x05, 0x13, 0xfa, 0xf1, + 0xfe, 0x00, 0x01, 0x5f, 0x00, 0x01, 0x00, 0x1f, 0xfe, 0xbf, 0x05, 0x16, 0x04, 0x3a, 0x00, 0x0f, 0x00, 0x4d, 0x00, + 0xb0, 0x0d, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x0f, 0x2f, 0x1b, 0xb1, 0x0f, 0x12, 0x3e, 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x04, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x00, 0xd0, 0xb0, 0x0f, 0x10, 0xb1, 0x06, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb0, 0x08, 0xd0, 0xb0, 0x06, 0x10, 0xb0, 0x0a, 0xd0, 0x30, 0x31, + 0x01, 0x21, 0x35, 0x21, 0x15, 0x23, 0x11, 0x21, 0x11, 0x33, 0x11, 0x33, 0x03, 0x23, 0x11, 0x21, 0x01, 0x31, 0xfe, + 0xee, 0x02, 0xc4, 0xf9, 0x01, 0xf2, 0xba, 0x80, 0x12, 0xa5, 0xfc, 0xd2, 0x03, 0xa3, 0x97, 0x97, 0xfc, 0xf4, 0x03, + 0xa3, 0xfc, 0x5d, 0xfe, 0x28, 0x01, 0x41, 0xff, 0xff, 0x00, 0x96, 0xfe, 0x99, 0x05, 0x67, 0x05, 0xb0, 0x00, 0x26, + 0x00, 0xe1, 0x00, 0x00, 0x00, 0x07, 0x02, 0x51, 0x04, 0x46, 0x00, 0x00, 0xff, 0xff, 0x00, 0x67, 0xfe, 0x99, 0x04, + 0x5f, 0x04, 0x3b, 0x00, 0x26, 0x00, 0xf9, 0x00, 0x00, 0x00, 0x07, 0x02, 0x51, 0x03, 0x3e, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x96, 0x00, 0x00, 0x04, 0xc8, 0x05, 0xb0, 0x00, 0x17, 0x00, 0x50, 0xb2, 0x04, 0x18, 0x19, 0x11, 0x12, 0x39, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x12, + 0x3e, 0x59, 0xb2, 0x07, 0x00, 0x0c, 0x11, 0x12, 0x39, 0xb0, 0x07, 0x2f, 0xb0, 0x04, 0xd0, 0xb0, 0x07, 0x10, 0xb1, + 0x10, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x13, 0xd0, 0x30, 0x31, 0x01, 0x11, 0x16, + 0x16, 0x33, 0x11, 0x33, 0x11, 0x36, 0x37, 0x11, 0x33, 0x11, 0x23, 0x11, 0x06, 0x07, 0x15, 0x23, 0x35, 0x22, 0x26, + 0x27, 0x11, 0x01, 0x57, 0x01, 0x89, 0xa0, 0x95, 0x79, 0x78, 0xc1, 0xc1, 0x72, 0x7f, 0x95, 0xf8, 0xef, 0x04, 0x05, + 0xb0, 0xfe, 0x32, 0x9a, 0x84, 0x01, 0x36, 0xfe, 0xd2, 0x0d, 0x21, 0x02, 0xb6, 0xfa, 0x50, 0x02, 0x5b, 0x22, 0x0d, + 0xee, 0xe8, 0xd9, 0xda, 0x01, 0xd7, 0x00, 0x01, 0x00, 0x83, 0x00, 0x00, 0x03, 0xd9, 0x04, 0x3b, 0x00, 0x16, 0x00, + 0x50, 0xb2, 0x06, 0x17, 0x18, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, + 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x15, 0x2f, 0x1b, 0xb1, 0x15, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb2, 0x0f, 0x15, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x0f, + 0x2f, 0xb1, 0x07, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0xd0, 0xb0, 0x0f, 0x10, + 0xb0, 0x12, 0xd0, 0x30, 0x31, 0x21, 0x23, 0x11, 0x06, 0x07, 0x15, 0x23, 0x35, 0x26, 0x26, 0x27, 0x11, 0x33, 0x11, + 0x16, 0x17, 0x11, 0x33, 0x11, 0x36, 0x37, 0x11, 0x33, 0x03, 0xd9, 0xba, 0x46, 0x53, 0x96, 0xb0, 0xbb, 0x02, 0xb9, + 0x05, 0xaf, 0x96, 0x54, 0x45, 0xba, 0x01, 0x88, 0x13, 0x09, 0x87, 0x85, 0x0d, 0xcc, 0xb5, 0x01, 0x43, 0xfe, 0xb5, + 0xd3, 0x1a, 0x01, 0x18, 0xfe, 0xea, 0x0a, 0x11, 0x02, 0x1a, 0x00, 0x01, 0x00, 0x89, 0x00, 0x00, 0x04, 0xba, 0x05, + 0xb0, 0x00, 0x11, 0x00, 0x47, 0xb2, 0x05, 0x12, 0x13, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, + 0x2f, 0x1b, 0xb1, 0x01, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x12, 0x3e, 0x59, 0xb2, 0x05, 0x01, 0x00, 0x11, + 0x12, 0x39, 0xb0, 0x05, 0x2f, 0xb1, 0x0e, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, + 0x33, 0x11, 0x33, 0x11, 0x36, 0x33, 0x32, 0x16, 0x17, 0x11, 0x23, 0x11, 0x26, 0x26, 0x23, 0x22, 0x07, 0x11, 0x89, + 0xc0, 0xb9, 0xcb, 0xf8, 0xf2, 0x03, 0xc0, 0x01, 0x89, 0xa3, 0xbc, 0xc8, 0x05, 0xb0, 0xfd, 0xa4, 0x35, 0xd8, 0xdf, + 0xfe, 0x2e, 0x01, 0xcd, 0x98, 0x86, 0x37, 0xfd, 0x4c, 0x00, 0x02, 0x00, 0x3f, 0xff, 0xea, 0x05, 0xbd, 0x05, 0xc3, + 0x00, 0x1d, 0x00, 0x25, 0x00, 0x67, 0xb2, 0x17, 0x26, 0x27, 0x11, 0x12, 0x39, 0xb0, 0x17, 0x10, 0xb0, 0x24, 0xd0, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0f, 0x2f, 0x1b, 0xb1, 0x0f, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb2, 0x1f, 0x0f, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x1f, 0x2f, 0xb1, + 0x13, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0xd0, 0xb0, 0x1f, 0x10, 0xb0, 0x0b, + 0xd0, 0xb0, 0x00, 0x10, 0xb1, 0x18, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0f, 0x10, + 0xb1, 0x23, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x05, 0x20, 0x00, 0x11, 0x35, + 0x26, 0x26, 0x35, 0x33, 0x14, 0x16, 0x17, 0x34, 0x12, 0x36, 0x33, 0x20, 0x00, 0x11, 0x15, 0x21, 0x15, 0x14, 0x16, + 0x33, 0x32, 0x37, 0x17, 0x06, 0x06, 0x01, 0x21, 0x35, 0x34, 0x26, 0x23, 0x22, 0x02, 0x03, 0xe9, 0xfe, 0xe2, 0xfe, + 0xb3, 0x99, 0xa6, 0x98, 0x50, 0x57, 0x8e, 0xfd, 0x96, 0x01, 0x02, 0x01, 0x1c, 0xfc, 0x82, 0xde, 0xcc, 0xb3, 0xa6, + 0x2f, 0x40, 0xd2, 0xfd, 0xe0, 0x02, 0xbe, 0xb3, 0xab, 0x9e, 0xc2, 0x16, 0x01, 0x51, 0x01, 0x29, 0x5b, 0x13, 0xc5, + 0xa2, 0x5a, 0x7d, 0x14, 0xb4, 0x01, 0x1f, 0xa2, 0xfe, 0xa3, 0xfe, 0xbe, 0x6c, 0x5d, 0xdc, 0xf7, 0x53, 0x8f, 0x2d, + 0x35, 0x03, 0x5a, 0x21, 0xd9, 0xe5, 0xfe, 0xfd, 0x00, 0x00, 0x02, 0xff, 0xde, 0xff, 0xec, 0x04, 0x63, 0x04, 0x4e, + 0x00, 0x19, 0x00, 0x21, 0x00, 0x75, 0xb2, 0x14, 0x22, 0x23, 0x11, 0x12, 0x39, 0xb0, 0x14, 0x10, 0xb0, 0x1b, 0xd0, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb2, 0x1e, 0x0d, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x1e, 0x2f, 0xb4, + 0xbf, 0x1e, 0xcf, 0x1e, 0x02, 0x5d, 0xb1, 0x11, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x03, 0xd0, 0xb0, 0x1e, 0x10, 0xb0, 0x09, 0xd0, 0xb0, 0x00, 0x10, 0xb1, 0x15, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x17, 0x0d, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x0d, 0x10, 0xb1, 0x1a, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x05, 0x22, 0x00, 0x35, 0x26, 0x26, 0x35, 0x33, 0x14, 0x17, + 0x3e, 0x02, 0x33, 0x32, 0x12, 0x11, 0x15, 0x21, 0x16, 0x16, 0x33, 0x32, 0x37, 0x17, 0x06, 0x01, 0x22, 0x06, 0x07, + 0x21, 0x35, 0x26, 0x26, 0x02, 0xbd, 0xdc, 0xfe, 0xec, 0x78, 0x77, 0x93, 0x65, 0x14, 0x84, 0xc8, 0x70, 0xd3, 0xea, + 0xfd, 0x23, 0x04, 0xb3, 0x8a, 0xae, 0x6f, 0x71, 0x88, 0xfe, 0xd9, 0x70, 0x98, 0x12, 0x02, 0x1e, 0x08, 0x88, 0x14, + 0x01, 0x21, 0xfa, 0x1d, 0xae, 0x86, 0x93, 0x30, 0x82, 0xc9, 0x6e, 0xfe, 0xea, 0xfe, 0xfd, 0x4d, 0xa0, 0xc5, 0x92, + 0x58, 0xd1, 0x03, 0xca, 0xa3, 0x93, 0x0e, 0x8d, 0x9b, 0x00, 0x01, 0x00, 0xa3, 0xfe, 0xd6, 0x04, 0xcc, 0x05, 0xb0, + 0x00, 0x16, 0x00, 0x5f, 0xb2, 0x15, 0x17, 0x18, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x0e, 0x2f, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, + 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb2, 0x04, 0x00, + 0x02, 0x11, 0x12, 0x39, 0xb0, 0x04, 0x2f, 0xb0, 0x08, 0xd0, 0xb0, 0x0e, 0x10, 0xb1, 0x0f, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0x10, 0xb1, 0x16, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0x30, 0x31, 0x21, 0x23, 0x11, 0x33, 0x11, 0x33, 0x01, 0x33, 0x01, 0x16, 0x00, 0x15, 0x10, 0x02, 0x23, + 0x27, 0x32, 0x36, 0x35, 0x26, 0x26, 0x27, 0x21, 0x01, 0x64, 0xc1, 0xc1, 0x85, 0x02, 0x01, 0xe2, 0xfd, 0xf8, 0xf8, + 0x01, 0x0d, 0xf9, 0xe6, 0x02, 0x90, 0x90, 0x02, 0xc7, 0xc7, 0xfe, 0xec, 0x05, 0xb0, 0xfd, 0x8f, 0x02, 0x71, 0xfd, + 0x88, 0x16, 0xfe, 0xd2, 0xfa, 0xfe, 0xf8, 0xfe, 0xe4, 0x98, 0xc1, 0xc9, 0xca, 0xd2, 0x01, 0x00, 0x00, 0x01, 0x00, + 0x9a, 0xfe, 0xfe, 0x04, 0x19, 0x04, 0x3a, 0x00, 0x16, 0x00, 0x7b, 0xb2, 0x0d, 0x17, 0x18, 0x11, 0x12, 0x39, 0x00, + 0xb0, 0x07, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x11, 0x2f, 0x1b, 0xb1, 0x11, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x15, 0x2f, 0x1b, 0xb1, 0x15, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0f, 0x2f, 0x1b, 0xb1, + 0x0f, 0x12, 0x3e, 0x59, 0xb0, 0x13, 0xd0, 0xb0, 0x13, 0x2f, 0xb2, 0x9f, 0x13, 0x01, 0x5d, 0xb2, 0xff, 0x13, 0x01, + 0x5d, 0xb2, 0x9f, 0x13, 0x01, 0x71, 0xb4, 0xbf, 0x13, 0xcf, 0x13, 0x02, 0x5d, 0xb2, 0x2f, 0x13, 0x01, 0x5d, 0xb2, + 0xcf, 0x13, 0x01, 0x71, 0xb0, 0x00, 0xd0, 0xb0, 0x07, 0x10, 0xb1, 0x08, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x13, 0x10, 0xb1, 0x0e, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, + 0x31, 0x01, 0x16, 0x16, 0x15, 0x14, 0x06, 0x06, 0x07, 0x27, 0x36, 0x35, 0x34, 0x26, 0x27, 0x23, 0x11, 0x23, 0x11, + 0x33, 0x11, 0x33, 0x01, 0x33, 0x02, 0x7f, 0xc3, 0xce, 0x64, 0xac, 0x70, 0x30, 0xf8, 0xad, 0xa5, 0xb2, 0xba, 0xba, + 0x5b, 0x01, 0x8a, 0xe0, 0x02, 0x64, 0x1f, 0xe2, 0xb4, 0x5d, 0xc5, 0x7c, 0x13, 0x92, 0x39, 0xe6, 0x8a, 0x92, 0x02, + 0xfe, 0x33, 0x04, 0x3a, 0xfe, 0x36, 0x01, 0xca, 0x00, 0xff, 0xff, 0x00, 0x2f, 0xfe, 0x9b, 0x05, 0xa8, 0x05, 0xb0, + 0x00, 0x26, 0x00, 0xdd, 0x00, 0x00, 0x00, 0x07, 0x00, 0x10, 0x04, 0x74, 0xff, 0xbd, 0xff, 0xff, 0x00, 0x2c, 0xfe, + 0x9b, 0x04, 0xb7, 0x04, 0x3a, 0x00, 0x26, 0x00, 0xf2, 0x00, 0x00, 0x00, 0x07, 0x00, 0x10, 0x03, 0x83, 0xff, 0xbd, + 0x00, 0x01, 0x00, 0xb1, 0xfe, 0x4b, 0x04, 0xfe, 0x05, 0xb0, 0x00, 0x15, 0x00, 0xa9, 0xb2, 0x0a, 0x16, 0x17, 0x11, + 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, + 0x08, 0x14, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x13, 0x2f, 0x1b, 0xb1, 0x13, 0x12, 0x3e, 0x59, 0xb0, 0x02, + 0xd0, 0xb0, 0x02, 0x2f, 0xb2, 0x5f, 0x02, 0x01, 0x5d, 0xb2, 0xcf, 0x02, 0x01, 0x5d, 0xb2, 0x1f, 0x02, 0x01, 0x71, + 0xb4, 0x6f, 0x02, 0x7f, 0x02, 0x02, 0x71, 0xb4, 0xbf, 0x02, 0xcf, 0x02, 0x02, 0x71, 0xb4, 0x0f, 0x02, 0x1f, 0x02, + 0x02, 0x72, 0xb2, 0xef, 0x02, 0x01, 0x71, 0xb2, 0x9f, 0x02, 0x01, 0x71, 0xb2, 0x4f, 0x02, 0x01, 0x71, 0xb2, 0xff, + 0x02, 0x01, 0x5d, 0xb2, 0xaf, 0x02, 0x01, 0x5d, 0xb2, 0x2f, 0x02, 0x01, 0x5d, 0xb2, 0x3f, 0x02, 0x01, 0x72, 0xb0, + 0x08, 0x10, 0xb1, 0x0d, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x02, 0x10, 0xb1, 0x11, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x11, 0x21, 0x11, 0x33, 0x11, 0x14, + 0x06, 0x23, 0x22, 0x27, 0x37, 0x16, 0x33, 0x32, 0x36, 0x35, 0x11, 0x21, 0x11, 0x23, 0x11, 0x01, 0x72, 0x02, 0xcc, + 0xc0, 0xab, 0x9c, 0x3c, 0x36, 0x0e, 0x25, 0x3d, 0x41, 0x48, 0xfd, 0x34, 0xc1, 0x05, 0xb0, 0xfd, 0x6e, 0x02, 0x92, + 0xf9, 0xfd, 0xa8, 0xba, 0x12, 0x9a, 0x0e, 0x67, 0x5c, 0x02, 0xd5, 0xfd, 0x7f, 0x05, 0xb0, 0x00, 0x00, 0x01, 0x00, + 0x91, 0xfe, 0x4b, 0x03, 0xf5, 0x04, 0x3a, 0x00, 0x16, 0x00, 0xa1, 0xb2, 0x0a, 0x17, 0x18, 0x11, 0x12, 0x39, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, + 0x2f, 0x1b, 0xb1, 0x03, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x14, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x14, 0x2f, 0x1b, 0xb1, 0x14, 0x12, 0x3e, 0x59, 0xb0, 0x02, 0xd0, 0xb0, 0x02, + 0x2f, 0xb2, 0x6f, 0x02, 0x01, 0x5d, 0xb4, 0xbf, 0x02, 0xcf, 0x02, 0x02, 0x5d, 0xb2, 0x3f, 0x02, 0x01, 0x71, 0xb4, + 0xcf, 0x02, 0xdf, 0x02, 0x02, 0x71, 0xb2, 0x0f, 0x02, 0x01, 0x72, 0xb4, 0x9f, 0x02, 0xaf, 0x02, 0x02, 0x71, 0xb2, + 0xff, 0x02, 0x01, 0x5d, 0xb2, 0x0f, 0x02, 0x01, 0x71, 0xb2, 0x9f, 0x02, 0x01, 0x5d, 0xb2, 0x2f, 0x02, 0x01, 0x5d, + 0xb4, 0x6f, 0x02, 0x7f, 0x02, 0x02, 0x72, 0xb0, 0x08, 0x10, 0xb1, 0x0e, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x02, 0x10, 0xb1, 0x12, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, + 0x31, 0x01, 0x11, 0x21, 0x11, 0x33, 0x11, 0x14, 0x06, 0x23, 0x22, 0x27, 0x37, 0x16, 0x17, 0x17, 0x32, 0x36, 0x35, + 0x11, 0x21, 0x11, 0x23, 0x11, 0x01, 0x4b, 0x01, 0xf1, 0xb9, 0xab, 0x98, 0x3c, 0x34, 0x0f, 0x11, 0x3c, 0x14, 0x42, + 0x48, 0xfe, 0x0f, 0xba, 0x04, 0x3a, 0xfe, 0x2b, 0x01, 0xd5, 0xfb, 0x6d, 0xaa, 0xb2, 0x12, 0x93, 0x07, 0x05, 0x01, + 0x68, 0x5c, 0x02, 0x27, 0xfe, 0x32, 0x04, 0x3a, 0x00, 0xff, 0xff, 0x00, 0xa9, 0xfe, 0x9b, 0x05, 0xbb, 0x05, 0xb0, + 0x00, 0x26, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x07, 0x00, 0x10, 0x04, 0x87, 0xff, 0xbd, 0xff, 0xff, 0x00, 0x9c, 0xfe, + 0x9b, 0x04, 0xb4, 0x04, 0x3a, 0x00, 0x26, 0x00, 0xf4, 0x00, 0x00, 0x00, 0x07, 0x00, 0x10, 0x03, 0x80, 0xff, 0xbd, + 0xff, 0xff, 0x00, 0xa9, 0xfe, 0x9b, 0x06, 0xf9, 0x05, 0xb0, 0x00, 0x26, 0x00, 0x31, 0x00, 0x00, 0x00, 0x07, 0x00, + 0x10, 0x05, 0xc5, 0xff, 0xbd, 0xff, 0xff, 0x00, 0x9d, 0xfe, 0x9b, 0x06, 0x07, 0x04, 0x3a, 0x00, 0x26, 0x00, 0xf3, + 0x00, 0x00, 0x00, 0x07, 0x00, 0x10, 0x04, 0xd3, 0xff, 0xbd, 0x00, 0x02, 0x00, 0x5d, 0xff, 0xec, 0x05, 0x12, 0x05, + 0xc4, 0x00, 0x17, 0x00, 0x1f, 0x00, 0x61, 0xb2, 0x08, 0x20, 0x21, 0x11, 0x12, 0x39, 0xb0, 0x08, 0x10, 0xb0, 0x18, + 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x12, 0x3e, 0x59, 0xb2, 0x0d, 0x00, 0x08, 0x11, 0x12, 0x39, 0xb0, 0x0d, 0x2f, + 0xb0, 0x00, 0x10, 0xb1, 0x11, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, 0x10, 0xb1, + 0x18, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0d, 0x10, 0xb1, 0x1b, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x20, 0x00, 0x11, 0x15, 0x14, 0x02, 0x04, 0x23, 0x20, + 0x00, 0x11, 0x35, 0x21, 0x35, 0x10, 0x02, 0x23, 0x22, 0x07, 0x07, 0x27, 0x37, 0x36, 0x01, 0x32, 0x12, 0x37, 0x21, + 0x15, 0x14, 0x16, 0x02, 0x80, 0x01, 0x2e, 0x01, 0x64, 0x9c, 0xfe, 0xea, 0xa7, 0xfe, 0xe3, 0xfe, 0xc1, 0x03, 0xf4, + 0xf4, 0xdd, 0xa5, 0x8b, 0x3d, 0x2f, 0x16, 0x9e, 0x01, 0x21, 0xa9, 0xde, 0x0f, 0xfc, 0xcf, 0xd3, 0x05, 0xc4, 0xfe, + 0x87, 0xfe, 0xb1, 0x54, 0xc5, 0xfe, 0xbf, 0xb6, 0x01, 0x59, 0x01, 0x45, 0x75, 0x07, 0x01, 0x02, 0x01, 0x1c, 0x3a, + 0x1a, 0x8f, 0x0d, 0x58, 0xfa, 0xc6, 0x01, 0x05, 0xdb, 0x22, 0xda, 0xe4, 0x00, 0x00, 0x01, 0x00, 0x68, 0xff, 0xeb, + 0x04, 0x2c, 0x05, 0xb0, 0x00, 0x1b, 0x00, 0x6a, 0xb2, 0x0b, 0x1c, 0x1d, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, + 0x0b, 0x12, 0x3e, 0x59, 0xb0, 0x02, 0x10, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb0, 0x04, 0xd0, 0xb2, 0x05, 0x02, 0x0b, 0x11, 0x12, 0x39, 0xb0, 0x05, 0x2f, 0xb0, 0x0b, 0x10, 0xb0, 0x10, 0xd0, + 0xb0, 0x0b, 0x10, 0xb1, 0x13, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x05, 0x10, 0xb1, + 0x19, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x05, 0x10, 0xb0, 0x1b, 0xd0, 0x30, 0x31, + 0x01, 0x21, 0x35, 0x21, 0x17, 0x01, 0x16, 0x16, 0x15, 0x14, 0x04, 0x23, 0x22, 0x26, 0x26, 0x35, 0x33, 0x14, 0x16, + 0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x23, 0x23, 0x35, 0x03, 0x1d, 0xfd, 0x76, 0x03, 0x6b, 0x01, 0xfe, 0x6b, 0xd9, + 0xe9, 0xfe, 0xf3, 0xe0, 0x86, 0xdb, 0x76, 0xc0, 0x9c, 0x7b, 0x89, 0xa3, 0xa6, 0x9e, 0x8d, 0x05, 0x12, 0x9e, 0x7d, + 0xfe, 0x1e, 0x0e, 0xe7, 0xc6, 0xc3, 0xe8, 0x69, 0xbe, 0x82, 0x72, 0x9a, 0x92, 0x78, 0x9d, 0x8e, 0x97, 0x00, 0x01, + 0x00, 0x69, 0xfe, 0x75, 0x04, 0x28, 0x04, 0x3a, 0x00, 0x1a, 0x00, 0x5d, 0xb2, 0x0b, 0x1b, 0x1c, 0x11, 0x12, 0x39, + 0x00, 0xb0, 0x0b, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1a, 0x3e, 0x59, 0xb1, 0x00, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0xd0, 0xb2, 0x05, 0x02, 0x0b, 0x11, 0x12, + 0x39, 0xb0, 0x05, 0x2f, 0xb0, 0x0b, 0x10, 0xb0, 0x10, 0xd0, 0xb0, 0x0b, 0x10, 0xb1, 0x13, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x05, 0x10, 0xb1, 0x18, 0x03, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb0, 0x05, 0x10, 0xb0, 0x1a, 0xd0, 0x30, 0x31, 0x01, 0x21, 0x35, 0x21, 0x17, 0x01, 0x16, 0x16, 0x15, + 0x14, 0x04, 0x23, 0x22, 0x26, 0x26, 0x35, 0x33, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x10, 0x25, 0x23, 0x35, 0x03, + 0x0c, 0xfd, 0x88, 0x03, 0x65, 0x01, 0xfe, 0x72, 0xd4, 0xe8, 0xfe, 0xf4, 0xde, 0x84, 0xd7, 0x7a, 0xba, 0x9e, 0x7d, + 0x8d, 0xa4, 0xfe, 0xc9, 0xa0, 0x03, 0xa1, 0x99, 0x76, 0xfe, 0x11, 0x10, 0xe1, 0xc5, 0xc3, 0xe7, 0x66, 0xbf, 0x83, + 0x71, 0x9f, 0x95, 0x79, 0x01, 0x22, 0x08, 0x97, 0x00, 0xff, 0xff, 0x00, 0x3a, 0xfe, 0x4b, 0x04, 0x74, 0x05, 0xb0, + 0x00, 0x26, 0x00, 0xb1, 0x44, 0x00, 0x00, 0x26, 0x02, 0x26, 0xab, 0x40, 0x00, 0x07, 0x02, 0x54, 0x00, 0xf0, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x3b, 0xfe, 0x4b, 0x03, 0x96, 0x04, 0x3a, 0x00, 0x26, 0x00, 0xec, 0x4f, 0x00, 0x00, 0x26, + 0x02, 0x26, 0xac, 0x8e, 0x01, 0x07, 0x02, 0x54, 0x00, 0xe1, 0x00, 0x00, 0x00, 0x08, 0x00, 0xb2, 0x00, 0x06, 0x01, + 0x5d, 0x30, 0x31, 0xff, 0xff, 0x00, 0x39, 0xfe, 0x4b, 0x05, 0x0e, 0x05, 0xb0, 0x00, 0x26, 0x00, 0x3c, 0x00, 0x00, + 0x00, 0x07, 0x02, 0x54, 0x03, 0xa7, 0x00, 0x00, 0xff, 0xff, 0x00, 0x29, 0xfe, 0x4b, 0x04, 0x1c, 0x04, 0x3a, 0x00, + 0x26, 0x00, 0x5c, 0x00, 0x00, 0x00, 0x07, 0x02, 0x54, 0x02, 0xb5, 0x00, 0x00, 0x00, 0x02, 0x00, 0x57, 0x00, 0x00, + 0x04, 0x65, 0x05, 0xb0, 0x00, 0x0a, 0x00, 0x13, 0x00, 0x52, 0xb2, 0x04, 0x14, 0x15, 0x11, 0x12, 0x39, 0xb0, 0x04, + 0x10, 0xb0, 0x0d, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x1e, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x12, 0x3e, 0x59, 0xb2, 0x00, 0x01, 0x03, 0x11, 0x12, 0x39, + 0xb0, 0x00, 0x2f, 0xb0, 0x03, 0x10, 0xb1, 0x0b, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x00, 0x10, 0xb1, 0x0c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x11, 0x33, + 0x11, 0x21, 0x22, 0x24, 0x35, 0x34, 0x36, 0x37, 0x01, 0x11, 0x21, 0x22, 0x06, 0x15, 0x14, 0x16, 0x17, 0x03, 0xa3, + 0xc2, 0xfd, 0xdf, 0xe4, 0xfe, 0xf7, 0xff, 0xe0, 0x01, 0x6d, 0xfe, 0xa1, 0x8c, 0xa1, 0x9f, 0x8a, 0x03, 0x73, 0x02, + 0x3d, 0xfa, 0x50, 0xf2, 0xcb, 0xc7, 0xeb, 0x04, 0xfd, 0x2a, 0x02, 0x38, 0x96, 0x80, 0x82, 0x9f, 0x01, 0x00, 0x02, + 0x00, 0x59, 0x00, 0x00, 0x06, 0x67, 0x05, 0xb0, 0x00, 0x17, 0x00, 0x1f, 0x00, 0x5c, 0xb2, 0x07, 0x20, 0x21, 0x11, + 0x12, 0x39, 0xb0, 0x07, 0x10, 0xb0, 0x18, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, + 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb2, 0x07, 0x08, + 0x00, 0x11, 0x12, 0x39, 0xb0, 0x07, 0x2f, 0xb0, 0x00, 0x10, 0xb1, 0x18, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x0a, 0xd0, 0xb2, 0x10, 0x00, 0x08, 0x11, 0x12, 0x39, 0xb0, 0x07, 0x10, 0xb1, 0x19, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x21, 0x22, 0x24, 0x35, 0x34, 0x24, 0x37, 0x21, + 0x11, 0x33, 0x11, 0x37, 0x36, 0x36, 0x37, 0x36, 0x27, 0x33, 0x17, 0x16, 0x07, 0x06, 0x06, 0x23, 0x25, 0x11, 0x21, + 0x22, 0x06, 0x14, 0x16, 0x17, 0x02, 0x47, 0xe5, 0xfe, 0xf7, 0x01, 0x01, 0xe3, 0x01, 0x6a, 0xc1, 0x58, 0x6f, 0x72, + 0x03, 0x04, 0x40, 0xba, 0x16, 0x2f, 0x03, 0x04, 0xe5, 0xc3, 0xfe, 0xef, 0xfe, 0xa0, 0x8e, 0x9e, 0x98, 0x85, 0xf4, + 0xc9, 0xc6, 0xed, 0x03, 0x02, 0x3d, 0xfa, 0xeb, 0x01, 0x02, 0x92, 0x7b, 0xa2, 0xa7, 0x44, 0x97, 0x6e, 0xc3, 0xe8, + 0x9d, 0x02, 0x38, 0x97, 0xfe, 0x9f, 0x04, 0x00, 0x00, 0x02, 0x00, 0x64, 0xff, 0xe7, 0x06, 0x6e, 0x06, 0x18, 0x00, + 0x1f, 0x00, 0x2b, 0x00, 0x86, 0xb2, 0x1a, 0x2c, 0x2d, 0x11, 0x12, 0x39, 0xb0, 0x1a, 0x10, 0xb0, 0x2a, 0xd0, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x20, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, + 0x2f, 0x1b, 0xb1, 0x03, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x18, 0x2f, 0x1b, 0xb1, 0x18, 0x12, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x1c, 0x2f, 0x1b, 0xb1, 0x1c, 0x12, 0x3e, 0x59, 0xb2, 0x05, 0x03, 0x18, 0x11, + 0x12, 0x39, 0xb0, 0x18, 0x10, 0xb1, 0x0b, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x11, + 0x03, 0x18, 0x11, 0x12, 0x39, 0xb2, 0x1a, 0x03, 0x18, 0x11, 0x12, 0x39, 0xb0, 0x03, 0x10, 0xb1, 0x22, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x1c, 0x10, 0xb1, 0x28, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x13, 0x10, 0x12, 0x33, 0x32, 0x17, 0x11, 0x33, 0x11, 0x06, 0x16, 0x33, 0x36, + 0x36, 0x37, 0x36, 0x27, 0x37, 0x16, 0x16, 0x07, 0x0e, 0x02, 0x23, 0x06, 0x27, 0x06, 0x23, 0x22, 0x02, 0x35, 0x01, + 0x26, 0x23, 0x22, 0x06, 0x15, 0x14, 0x16, 0x33, 0x32, 0x37, 0x27, 0x64, 0xe2, 0xc4, 0xb7, 0x6a, 0xb9, 0x02, 0x5f, + 0x4e, 0x89, 0x97, 0x04, 0x04, 0x41, 0xb3, 0x1c, 0x29, 0x02, 0x02, 0x79, 0xd9, 0x89, 0xf2, 0x4e, 0x6c, 0xdb, 0xc0, + 0xe4, 0x02, 0xc7, 0x52, 0xa1, 0x87, 0x94, 0x91, 0x88, 0xa7, 0x53, 0x05, 0x02, 0x09, 0x01, 0x08, 0x01, 0x3d, 0x83, + 0x02, 0x4d, 0xfb, 0x41, 0x5f, 0x78, 0x02, 0xd0, 0xbd, 0xba, 0xd8, 0x01, 0x66, 0xc7, 0x66, 0xa9, 0xf9, 0x84, 0x04, + 0xba, 0xb6, 0x01, 0x1b, 0xf4, 0x01, 0x31, 0x86, 0xdf, 0xde, 0xad, 0xbf, 0x93, 0x3e, 0x00, 0x01, 0x00, 0x36, 0xff, + 0xe3, 0x05, 0xd5, 0x05, 0xb0, 0x00, 0x27, 0x00, 0x66, 0xb2, 0x10, 0x28, 0x29, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x21, 0x2f, 0x1b, + 0xb1, 0x21, 0x12, 0x3e, 0x59, 0xb2, 0x01, 0x28, 0x09, 0x11, 0x12, 0x39, 0xb0, 0x01, 0x2f, 0xb1, 0x00, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x09, 0x10, 0xb1, 0x07, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x0f, 0x00, 0x01, 0x11, 0x12, 0x39, 0xb0, 0x21, 0x10, 0xb1, 0x15, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x1a, 0x21, 0x09, 0x11, 0x12, 0x39, 0x30, 0x31, 0x13, 0x35, 0x33, + 0x36, 0x36, 0x35, 0x34, 0x21, 0x21, 0x35, 0x21, 0x16, 0x16, 0x15, 0x14, 0x07, 0x16, 0x13, 0x15, 0x14, 0x16, 0x33, + 0x36, 0x36, 0x37, 0x36, 0x27, 0x33, 0x17, 0x16, 0x07, 0x06, 0x02, 0x23, 0x04, 0x03, 0x35, 0x34, 0x26, 0x27, 0xfe, + 0x9b, 0x9f, 0x93, 0xfe, 0xcb, 0xfe, 0xa0, 0x01, 0x6b, 0xef, 0xfc, 0xed, 0xdb, 0x05, 0x53, 0x41, 0x74, 0x86, 0x04, + 0x04, 0x41, 0xba, 0x17, 0x30, 0x03, 0x04, 0xf6, 0xc7, 0xfe, 0xbd, 0x0f, 0x87, 0x75, 0x02, 0x79, 0x9e, 0x02, 0x7b, + 0x83, 0xfb, 0x9e, 0x01, 0xd1, 0xc9, 0xe8, 0x62, 0x45, 0xfe, 0xfc, 0x50, 0x4f, 0x5b, 0x02, 0xce, 0xb9, 0xbb, 0xd8, + 0x58, 0xbb, 0x80, 0xfd, 0xfe, 0xd7, 0x08, 0x01, 0x4d, 0x40, 0x78, 0x90, 0x01, 0x00, 0x00, 0x01, 0x00, 0x31, 0xff, + 0xe3, 0x04, 0xe8, 0x04, 0x3a, 0x00, 0x27, 0x00, 0x63, 0xb2, 0x0f, 0x28, 0x29, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x1f, 0x2f, 0x1b, 0xb1, 0x1f, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0e, 0x2f, 0x1b, + 0xb1, 0x0e, 0x12, 0x3e, 0x59, 0xb1, 0x02, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x07, + 0x0e, 0x1f, 0x11, 0x12, 0x39, 0xb2, 0x17, 0x28, 0x1f, 0x11, 0x12, 0x39, 0xb0, 0x17, 0x2f, 0xb1, 0x14, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x1f, 0x10, 0xb1, 0x1d, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x25, 0x14, 0x17, 0x11, 0x12, 0x39, 0x30, 0x31, 0x25, 0x06, 0x33, 0x36, 0x36, 0x37, + 0x36, 0x27, 0x33, 0x16, 0x16, 0x07, 0x06, 0x06, 0x23, 0x06, 0x26, 0x27, 0x35, 0x34, 0x23, 0x23, 0x27, 0x33, 0x36, + 0x36, 0x35, 0x34, 0x26, 0x23, 0x21, 0x27, 0x21, 0x16, 0x16, 0x15, 0x14, 0x07, 0x16, 0x17, 0x02, 0xe7, 0x02, 0x5f, + 0x70, 0x76, 0x03, 0x04, 0x42, 0xb4, 0x2d, 0x18, 0x01, 0x04, 0xe7, 0xb8, 0x87, 0x89, 0x07, 0xd8, 0xcd, 0x02, 0xc0, + 0x7a, 0x6e, 0x7d, 0x75, 0xfe, 0xfb, 0x06, 0x01, 0x18, 0xc4, 0xdc, 0xbc, 0xb6, 0x04, 0xd5, 0x58, 0x02, 0x9b, 0x89, + 0x99, 0xa6, 0x86, 0x80, 0x39, 0xcd, 0xf0, 0x03, 0x70, 0x83, 0x47, 0x9d, 0x96, 0x01, 0x57, 0x4a, 0x55, 0x5d, 0x96, + 0x03, 0xa7, 0x98, 0x9d, 0x4a, 0x34, 0xb2, 0x00, 0x00, 0x01, 0x00, 0x52, 0xfe, 0xd7, 0x03, 0xf5, 0x05, 0xaf, 0x00, + 0x21, 0x00, 0x60, 0xb2, 0x20, 0x22, 0x23, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x17, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x1a, 0x2f, 0x1b, 0xb1, 0x1a, 0x12, + 0x3e, 0x59, 0xb2, 0x01, 0x22, 0x09, 0x11, 0x12, 0x39, 0xb0, 0x01, 0x2f, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x09, 0x10, 0xb1, 0x07, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb2, 0x0f, 0x00, 0x01, 0x11, 0x12, 0x39, 0xb0, 0x1a, 0x10, 0xb0, 0x12, 0xb0, 0x0a, 0x2b, 0x58, 0xd8, 0x1b, + 0xdc, 0x59, 0x30, 0x31, 0x13, 0x35, 0x33, 0x36, 0x36, 0x35, 0x10, 0x21, 0x21, 0x35, 0x21, 0x16, 0x16, 0x15, 0x14, + 0x07, 0x16, 0x13, 0x15, 0x33, 0x15, 0x14, 0x06, 0x07, 0x27, 0x36, 0x37, 0x23, 0x26, 0x27, 0x35, 0x34, 0x26, 0x23, + 0xaf, 0xa9, 0xa4, 0x9b, 0xfe, 0xca, 0xfe, 0xf1, 0x01, 0x21, 0xe8, 0xf4, 0xe5, 0xde, 0x04, 0xa9, 0x61, 0x4d, 0x6a, + 0x51, 0x0e, 0x6b, 0x3c, 0x03, 0x92, 0x77, 0x02, 0x79, 0x97, 0x01, 0x7d, 0x85, 0x01, 0x05, 0x97, 0x03, 0xd2, 0xc9, + 0xe2, 0x64, 0x46, 0xfe, 0xf8, 0xa9, 0x94, 0x61, 0xc8, 0x40, 0x48, 0x73, 0x6e, 0x34, 0xab, 0x8f, 0x7e, 0x8d, 0x00, + 0x01, 0x00, 0x79, 0xfe, 0xc7, 0x03, 0xd9, 0x04, 0x3a, 0x00, 0x20, 0x00, 0x60, 0xb2, 0x20, 0x21, 0x22, 0x11, 0x12, + 0x39, 0x00, 0xb0, 0x17, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x1a, 0x2f, 0x1b, 0xb1, 0x1a, 0x12, 0x3e, 0x59, 0xb2, 0x01, 0x21, 0x08, 0x11, 0x12, 0x39, + 0xb0, 0x01, 0x2f, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, 0x10, 0xb1, + 0x06, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x0f, 0x00, 0x01, 0x11, 0x12, 0x39, 0xb0, + 0x1a, 0x10, 0xb0, 0x12, 0xb0, 0x0a, 0x2b, 0x58, 0xd8, 0x1b, 0xdc, 0x59, 0x30, 0x31, 0x13, 0x27, 0x33, 0x36, 0x35, + 0x34, 0x23, 0x21, 0x35, 0x21, 0x16, 0x17, 0x16, 0x15, 0x14, 0x07, 0x16, 0x17, 0x15, 0x33, 0x15, 0x14, 0x06, 0x07, + 0x27, 0x36, 0x37, 0x23, 0x26, 0x27, 0x35, 0x34, 0x23, 0xc2, 0x01, 0xdb, 0xe9, 0xf5, 0xfe, 0xe9, 0x01, 0x27, 0xdd, + 0x6c, 0x56, 0xbe, 0xbd, 0x01, 0x9a, 0x62, 0x4d, 0x69, 0x54, 0x0d, 0x67, 0x33, 0x02, 0xda, 0x01, 0xb8, 0x97, 0x02, + 0xa1, 0xb2, 0x96, 0x03, 0x67, 0x53, 0x84, 0xa1, 0x49, 0x35, 0xca, 0x4c, 0x94, 0x61, 0xca, 0x3e, 0x48, 0x74, 0x7d, + 0x21, 0x85, 0x5e, 0xb4, 0x00, 0x00, 0x01, 0x00, 0x44, 0xff, 0xeb, 0x07, 0x70, 0x05, 0xb0, 0x00, 0x23, 0x00, 0x65, + 0xb2, 0x00, 0x24, 0x25, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0e, 0x2f, 0x1b, 0xb1, 0x0e, 0x1e, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x20, 0x2f, 0x1b, 0xb1, 0x20, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x12, 0x3e, 0x59, 0xb0, 0x0e, 0x10, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x07, 0x10, 0xb1, 0x08, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb0, 0x20, 0x10, 0xb1, 0x13, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x19, 0x0e, + 0x20, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x21, 0x03, 0x02, 0x02, 0x06, 0x07, 0x23, 0x35, 0x37, 0x3e, 0x02, 0x37, + 0x13, 0x21, 0x11, 0x14, 0x16, 0x33, 0x32, 0x36, 0x37, 0x36, 0x27, 0x37, 0x16, 0x16, 0x07, 0x06, 0x02, 0x07, 0x07, + 0x22, 0x26, 0x35, 0x04, 0x27, 0xfe, 0x1a, 0x1a, 0x0f, 0x59, 0xac, 0x90, 0x3f, 0x28, 0x5d, 0x64, 0x34, 0x0b, 0x1e, + 0x03, 0x5f, 0x59, 0x4f, 0x82, 0x97, 0x04, 0x02, 0x3f, 0xba, 0x1c, 0x29, 0x02, 0x03, 0xe9, 0xc3, 0x2e, 0xb3, 0xb7, + 0x05, 0x12, 0xfd, 0xbf, 0xfe, 0xde, 0xfe, 0xdc, 0x89, 0x02, 0x9d, 0x02, 0x07, 0x6b, 0xea, 0xf3, 0x02, 0xc2, 0xfb, + 0xac, 0x60, 0x74, 0xcd, 0xbc, 0xc0, 0xd2, 0x01, 0x66, 0xc7, 0x66, 0xec, 0xfe, 0xda, 0x12, 0x02, 0xba, 0xb4, 0x00, + 0x01, 0x00, 0x3f, 0xff, 0xeb, 0x06, 0x3a, 0x04, 0x3a, 0x00, 0x21, 0x00, 0x65, 0xb2, 0x20, 0x22, 0x23, 0x11, 0x12, + 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x1e, 0x2f, 0x1b, 0xb1, 0x1e, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, + 0x12, 0x3e, 0x59, 0xb0, 0x0c, 0x10, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x06, 0x10, 0xb1, 0x07, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x1e, 0x10, 0xb1, 0x11, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x16, 0x1e, 0x0c, 0x11, 0x12, 0x39, 0x30, 0x31, + 0x01, 0x21, 0x03, 0x02, 0x06, 0x07, 0x23, 0x35, 0x37, 0x36, 0x36, 0x37, 0x13, 0x21, 0x11, 0x14, 0x16, 0x33, 0x32, + 0x36, 0x37, 0x36, 0x27, 0x33, 0x17, 0x16, 0x07, 0x0e, 0x02, 0x23, 0x22, 0x26, 0x27, 0x03, 0x31, 0xfe, 0xbb, 0x17, + 0x14, 0x9c, 0xa5, 0x41, 0x36, 0x55, 0x4d, 0x0d, 0x17, 0x02, 0xaf, 0x5a, 0x4f, 0x6c, 0x7b, 0x04, 0x04, 0x41, 0xb3, + 0x16, 0x30, 0x03, 0x02, 0x6c, 0xbe, 0x78, 0xae, 0xb3, 0x01, 0x03, 0xa1, 0xfe, 0x5a, 0xfe, 0xeb, 0xe4, 0x02, 0xa3, + 0x04, 0x0a, 0xa7, 0xd3, 0x02, 0x0f, 0xfd, 0x21, 0x60, 0x79, 0xb7, 0xab, 0xb2, 0xcb, 0x50, 0xb1, 0x7c, 0x9a, 0xe6, + 0x79, 0xb8, 0xb1, 0x00, 0x00, 0x01, 0x00, 0xa9, 0xff, 0xe7, 0x07, 0x71, 0x05, 0xb0, 0x00, 0x1d, 0x00, 0xb0, 0xb2, + 0x14, 0x1e, 0x1f, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1e, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x19, 0x2f, 0x1b, 0xb1, 0x19, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x11, 0x2f, 0x1b, 0xb1, 0x11, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x17, 0x2f, 0x1b, 0xb1, 0x17, 0x12, + 0x3e, 0x59, 0xb0, 0x11, 0x10, 0xb1, 0x04, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x0a, + 0x00, 0x11, 0x11, 0x12, 0x39, 0xb0, 0x17, 0x10, 0xb0, 0x1c, 0xd0, 0xb0, 0x1c, 0x2f, 0xb2, 0xef, 0x1c, 0x01, 0x71, + 0xb2, 0x5f, 0x1c, 0x01, 0x5d, 0xb2, 0xcf, 0x1c, 0x01, 0x5d, 0xb2, 0x1f, 0x1c, 0x01, 0x71, 0xb4, 0x6f, 0x1c, 0x7f, + 0x1c, 0x02, 0x71, 0xb4, 0xbf, 0x1c, 0xcf, 0x1c, 0x02, 0x71, 0xb2, 0x9f, 0x1c, 0x01, 0x71, 0xb2, 0x4f, 0x1c, 0x01, + 0x71, 0xb2, 0xff, 0x1c, 0x01, 0x5d, 0xb2, 0xaf, 0x1c, 0x01, 0x5d, 0xb2, 0x2f, 0x1c, 0x01, 0x5d, 0xb4, 0x0f, 0x1c, + 0x1f, 0x1c, 0x02, 0x72, 0xb2, 0x3f, 0x1c, 0x01, 0x72, 0xb1, 0x15, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0x30, 0x31, 0x01, 0x11, 0x14, 0x16, 0x33, 0x36, 0x36, 0x37, 0x36, 0x27, 0x37, 0x16, 0x16, 0x07, 0x0e, + 0x02, 0x23, 0x06, 0x26, 0x27, 0x11, 0x21, 0x11, 0x23, 0x11, 0x33, 0x11, 0x21, 0x11, 0x04, 0xe9, 0x5d, 0x4a, 0x86, + 0x94, 0x04, 0x04, 0x42, 0xbb, 0x1b, 0x2b, 0x02, 0x02, 0x7b, 0xd8, 0x8a, 0xab, 0xb5, 0x08, 0xfd, 0x42, 0xc1, 0xc1, + 0x02, 0xbe, 0x05, 0xb0, 0xfb, 0xac, 0x65, 0x6f, 0x02, 0xcd, 0xba, 0xb7, 0xdb, 0x01, 0x62, 0xca, 0x67, 0xa8, 0xfb, + 0x83, 0x04, 0xb8, 0xbb, 0x01, 0x27, 0xfd, 0x7f, 0x05, 0xb0, 0xfd, 0x6e, 0x02, 0x92, 0x00, 0x01, 0x00, 0x90, 0xff, + 0xe7, 0x06, 0x4d, 0x04, 0x3a, 0x00, 0x1c, 0x00, 0xa5, 0xb2, 0x1b, 0x1d, 0x1e, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, + 0xb1, 0x08, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x19, 0x2f, 0x1b, 0xb1, 0x19, 0x12, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x07, 0xd0, 0xb0, 0x07, 0x2f, 0xb2, + 0x6f, 0x07, 0x01, 0x5d, 0xb4, 0xbf, 0x07, 0xcf, 0x07, 0x02, 0x5d, 0xb2, 0x3f, 0x07, 0x01, 0x71, 0xb4, 0xcf, 0x07, + 0xdf, 0x07, 0x02, 0x71, 0xb2, 0x0f, 0x07, 0x01, 0x72, 0xb4, 0x9f, 0x07, 0xaf, 0x07, 0x02, 0x71, 0xb2, 0xff, 0x07, + 0x01, 0x5d, 0xb2, 0x0f, 0x07, 0x01, 0x71, 0xb2, 0x9f, 0x07, 0x01, 0x5d, 0xb2, 0x2f, 0x07, 0x01, 0x5d, 0xb4, 0x6f, + 0x07, 0x7f, 0x07, 0x02, 0x72, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x19, + 0x10, 0xb1, 0x0d, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x12, 0x19, 0x08, 0x11, 0x12, + 0x39, 0x30, 0x31, 0x01, 0x21, 0x11, 0x23, 0x11, 0x33, 0x11, 0x21, 0x11, 0x33, 0x11, 0x14, 0x16, 0x33, 0x36, 0x36, + 0x37, 0x36, 0x27, 0x33, 0x17, 0x16, 0x07, 0x06, 0x02, 0x23, 0x06, 0x26, 0x27, 0x03, 0x43, 0xfe, 0x06, 0xb9, 0xb9, + 0x01, 0xfa, 0xb9, 0x5c, 0x4d, 0x6c, 0x7c, 0x04, 0x04, 0x41, 0xb2, 0x17, 0x30, 0x03, 0x04, 0xe6, 0xbb, 0xa7, 0xb3, + 0x08, 0x01, 0xcd, 0xfe, 0x33, 0x04, 0x3a, 0xfe, 0x2a, 0x01, 0xd6, 0xfd, 0x21, 0x64, 0x75, 0x02, 0xb5, 0xab, 0xac, + 0xd1, 0x53, 0xb1, 0x79, 0xea, 0xfe, 0xf1, 0x04, 0xb7, 0xbb, 0x00, 0x01, 0x00, 0x76, 0xff, 0xeb, 0x04, 0xa0, 0x05, + 0xc5, 0x00, 0x22, 0x00, 0x49, 0xb2, 0x15, 0x23, 0x24, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, + 0x2f, 0x1b, 0xb1, 0x09, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, + 0x59, 0xb0, 0x09, 0x10, 0xb1, 0x0e, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x00, 0x10, + 0xb1, 0x16, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x1b, 0x00, 0x09, 0x11, 0x12, 0x39, + 0x30, 0x31, 0x05, 0x22, 0x24, 0x02, 0x27, 0x11, 0x34, 0x12, 0x24, 0x33, 0x32, 0x17, 0x07, 0x26, 0x23, 0x22, 0x02, + 0x15, 0x15, 0x14, 0x16, 0x16, 0x33, 0x36, 0x36, 0x37, 0x36, 0x27, 0x33, 0x17, 0x16, 0x07, 0x0e, 0x02, 0x02, 0xb9, + 0xa4, 0xfe, 0xf8, 0x95, 0x02, 0x94, 0x01, 0x0a, 0xa5, 0xdc, 0x87, 0x3b, 0x86, 0xa2, 0xac, 0xd7, 0x62, 0xb0, 0x71, + 0x8d, 0x96, 0x03, 0x03, 0x35, 0xba, 0x26, 0x13, 0x01, 0x02, 0x7b, 0xde, 0x15, 0x9b, 0x01, 0x18, 0xad, 0x01, 0x10, + 0xaf, 0x01, 0x1e, 0x9d, 0x58, 0x8a, 0x44, 0xfe, 0xfe, 0xd2, 0xfe, 0x83, 0xd5, 0x75, 0x02, 0x99, 0x86, 0x9a, 0xcf, + 0xb3, 0x5b, 0x5b, 0x88, 0xc9, 0x6d, 0x00, 0x01, 0x00, 0x65, 0xff, 0xeb, 0x03, 0xc7, 0x04, 0x4e, 0x00, 0x1e, 0x00, + 0x46, 0xb2, 0x13, 0x1f, 0x20, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x13, 0x2f, 0x1b, 0xb1, 0x13, + 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x12, 0x3e, 0x59, 0xb1, 0x00, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x05, 0x0b, 0x13, 0x11, 0x12, 0x39, 0xb0, 0x13, 0x10, + 0xb1, 0x18, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x25, 0x36, 0x36, 0x37, 0x34, + 0x27, 0x33, 0x16, 0x07, 0x06, 0x06, 0x23, 0x22, 0x00, 0x35, 0x35, 0x34, 0x36, 0x36, 0x33, 0x32, 0x17, 0x07, 0x26, + 0x23, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x02, 0x51, 0x60, 0x5a, 0x02, 0x14, 0xb2, 0x1c, 0x01, 0x04, 0xc4, 0xad, + 0xdc, 0xfe, 0xf0, 0x76, 0xd6, 0x8b, 0xb9, 0x60, 0x2c, 0x63, 0x8a, 0x83, 0x9b, 0xa6, 0x82, 0x02, 0x50, 0x59, 0x7a, + 0x72, 0x96, 0x56, 0x99, 0xa9, 0x01, 0x32, 0xf7, 0x1e, 0x97, 0xf9, 0x8c, 0x42, 0x90, 0x3a, 0xdc, 0xb3, 0x1f, 0xab, + 0xdb, 0x00, 0x01, 0x00, 0x23, 0xff, 0xe7, 0x05, 0x47, 0x05, 0xb0, 0x00, 0x18, 0x00, 0x4f, 0xb2, 0x05, 0x19, 0x1a, + 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1e, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x15, 0x2f, 0x1b, 0xb1, 0x15, 0x12, 0x3e, 0x59, 0xb0, 0x02, 0x10, 0xb1, 0x00, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0xd0, 0xb0, 0x05, 0xd0, 0xb0, 0x15, 0x10, 0xb1, 0x09, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x0e, 0x02, 0x15, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, + 0x21, 0x35, 0x21, 0x15, 0x21, 0x11, 0x14, 0x16, 0x33, 0x36, 0x36, 0x12, 0x27, 0x37, 0x16, 0x16, 0x07, 0x0e, 0x02, + 0x23, 0x06, 0x26, 0x27, 0x01, 0xfe, 0xfe, 0x25, 0x04, 0x80, 0xfe, 0x1c, 0x5c, 0x4c, 0x86, 0x94, 0x08, 0x42, 0xba, + 0x1b, 0x2b, 0x03, 0x02, 0x79, 0xd9, 0x89, 0xaa, 0xb7, 0x08, 0x05, 0x12, 0x9e, 0x9e, 0xfc, 0x48, 0x60, 0x72, 0x02, + 0xd0, 0x01, 0x6e, 0xdb, 0x01, 0x62, 0xca, 0x67, 0xa9, 0xf9, 0x84, 0x04, 0xb7, 0xbc, 0x00, 0x00, 0x01, 0x00, 0x46, + 0xff, 0xe7, 0x04, 0xb7, 0x04, 0x3a, 0x00, 0x18, 0x00, 0x4f, 0xb2, 0x16, 0x19, 0x1a, 0x11, 0x12, 0x39, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x15, 0x2f, + 0x1b, 0xb1, 0x15, 0x12, 0x3e, 0x59, 0xb0, 0x02, 0x10, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb0, 0x04, 0xd0, 0xb0, 0x05, 0xd0, 0xb0, 0x15, 0x10, 0xb1, 0x09, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x0e, 0x15, 0x02, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x21, 0x35, 0x21, 0x15, 0x21, + 0x11, 0x14, 0x16, 0x33, 0x36, 0x36, 0x37, 0x36, 0x27, 0x33, 0x16, 0x16, 0x07, 0x06, 0x06, 0x23, 0x06, 0x26, 0x27, + 0x01, 0xac, 0xfe, 0x9a, 0x03, 0x8b, 0xfe, 0x95, 0x5e, 0x4d, 0x71, 0x77, 0x03, 0x04, 0x40, 0xb2, 0x2a, 0x1b, 0x01, + 0x04, 0xe8, 0xb9, 0xaa, 0xb3, 0x08, 0x03, 0xa4, 0x96, 0x96, 0xfd, 0xb5, 0x63, 0x74, 0x02, 0x9d, 0x89, 0x97, 0xae, + 0x7d, 0x8c, 0x3c, 0xd0, 0xef, 0x04, 0xb9, 0xb9, 0x00, 0x01, 0x00, 0x96, 0xff, 0xec, 0x04, 0xff, 0x05, 0xc5, 0x00, + 0x29, 0x00, 0x72, 0xb2, 0x24, 0x2a, 0x2b, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x16, 0x2f, 0x1b, + 0xb1, 0x16, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x12, 0x3e, 0x59, 0xb1, + 0x03, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0b, 0x10, 0xb0, 0x06, 0xd0, 0xb2, 0x25, + 0x0b, 0x16, 0x11, 0x12, 0x39, 0xb0, 0x25, 0x2f, 0xb2, 0xcf, 0x25, 0x01, 0x5d, 0xb2, 0x9f, 0x25, 0x01, 0x71, 0xb1, + 0x26, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x10, 0x26, 0x25, 0x11, 0x12, 0x39, 0xb0, + 0x16, 0x10, 0xb0, 0x1b, 0xd0, 0xb0, 0x16, 0x10, 0xb1, 0x1e, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0x30, 0x31, 0x01, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x33, 0x14, 0x06, 0x06, 0x23, 0x20, 0x24, 0x35, 0x34, + 0x25, 0x26, 0x26, 0x35, 0x34, 0x24, 0x21, 0x32, 0x16, 0x16, 0x15, 0x23, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x14, + 0x16, 0x17, 0x33, 0x15, 0x23, 0x06, 0x06, 0x01, 0x58, 0xcf, 0xb0, 0x9b, 0xcc, 0xc1, 0x8d, 0xfe, 0x9d, 0xfe, 0xfb, + 0xfe, 0xc4, 0x01, 0x14, 0x78, 0x86, 0x01, 0x25, 0x01, 0x06, 0x93, 0xf5, 0x8c, 0xc1, 0xc1, 0x92, 0xa7, 0xc2, 0xad, + 0xa3, 0xc4, 0xc4, 0xb1, 0xb5, 0x01, 0x92, 0x78, 0x92, 0x98, 0x74, 0x83, 0xbe, 0x67, 0xe5, 0xc5, 0xff, 0x56, 0x30, + 0xa6, 0x65, 0xc4, 0xdb, 0x65, 0xba, 0x75, 0x67, 0x8f, 0x88, 0x76, 0x75, 0x7d, 0x02, 0x9e, 0x02, 0x7e, 0x00, 0xff, + 0xff, 0x00, 0x2f, 0xfe, 0x4b, 0x05, 0xac, 0x05, 0xb0, 0x00, 0x26, 0x00, 0xdd, 0x00, 0x00, 0x00, 0x07, 0x02, 0x54, + 0x04, 0x45, 0x00, 0x00, 0xff, 0xff, 0x00, 0x2c, 0xfe, 0x4b, 0x04, 0xbb, 0x04, 0x3a, 0x00, 0x26, 0x00, 0xf2, 0x00, + 0x00, 0x00, 0x07, 0x02, 0x54, 0x03, 0x54, 0x00, 0x00, 0x00, 0x02, 0x00, 0x6f, 0x04, 0x70, 0x02, 0xc9, 0x05, 0xd6, + 0x00, 0x05, 0x00, 0x0d, 0x00, 0x23, 0x00, 0xb0, 0x0b, 0x2f, 0xb0, 0x07, 0xd0, 0xb0, 0x07, 0x2f, 0xb0, 0x01, 0xd0, + 0xb0, 0x01, 0x2f, 0xb0, 0x0b, 0x10, 0xb0, 0x04, 0xd0, 0xb0, 0x04, 0x2f, 0xb0, 0x05, 0xd0, 0x19, 0xb0, 0x05, 0x2f, + 0x18, 0x30, 0x31, 0x01, 0x13, 0x33, 0x15, 0x03, 0x23, 0x01, 0x33, 0x15, 0x16, 0x17, 0x07, 0x26, 0x35, 0x01, 0x91, + 0x74, 0xc4, 0xdf, 0x59, 0xfe, 0xde, 0xa8, 0x03, 0x50, 0x49, 0xb2, 0x04, 0x94, 0x01, 0x42, 0x15, 0xfe, 0xc3, 0x01, + 0x52, 0x5b, 0x7b, 0x55, 0x3b, 0x5f, 0xbb, 0x00, 0xff, 0xff, 0x00, 0x25, 0x02, 0x1f, 0x02, 0x0d, 0x02, 0xb6, 0x00, + 0x06, 0x00, 0x11, 0x00, 0x00, 0xff, 0xff, 0x00, 0x25, 0x02, 0x1f, 0x02, 0x0d, 0x02, 0xb6, 0x00, 0x06, 0x00, 0x11, + 0x00, 0x00, 0xff, 0xff, 0x00, 0xa3, 0x02, 0x8b, 0x04, 0x8d, 0x03, 0x22, 0x00, 0x46, 0x01, 0xaf, 0xd9, 0x00, 0x4c, + 0xcd, 0x40, 0x00, 0xff, 0xff, 0x00, 0x91, 0x02, 0x8b, 0x05, 0xc9, 0x03, 0x22, 0x00, 0x46, 0x01, 0xaf, 0x84, 0x00, + 0x66, 0x66, 0x40, 0x00, 0x00, 0x02, 0x00, 0x0d, 0xfe, 0x6b, 0x03, 0xa1, 0x00, 0x00, 0x00, 0x03, 0x00, 0x07, 0x00, + 0x08, 0x00, 0xb2, 0x05, 0x02, 0x03, 0x2b, 0x30, 0x31, 0x01, 0x21, 0x35, 0x21, 0x35, 0x21, 0x35, 0x21, 0x03, 0xa1, + 0xfc, 0x6c, 0x03, 0x94, 0xfc, 0x6c, 0x03, 0x94, 0xfe, 0x6b, 0x97, 0x67, 0x97, 0x00, 0x00, 0x01, 0x00, 0x60, 0x04, + 0x31, 0x01, 0x78, 0x06, 0x13, 0x00, 0x08, 0x00, 0x21, 0xb2, 0x08, 0x09, 0x0a, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x20, 0x3e, 0x59, 0xb2, 0x05, 0x09, 0x00, 0x11, 0x12, 0x39, 0xb0, + 0x05, 0x2f, 0x30, 0x31, 0x01, 0x17, 0x06, 0x07, 0x15, 0x23, 0x35, 0x34, 0x36, 0x01, 0x0e, 0x6a, 0x5d, 0x03, 0xb8, + 0x61, 0x06, 0x13, 0x48, 0x7f, 0x93, 0x88, 0x74, 0x66, 0xc8, 0x00, 0x01, 0x00, 0x30, 0x04, 0x16, 0x01, 0x47, 0x06, + 0x00, 0x00, 0x08, 0x00, 0x21, 0xb2, 0x08, 0x09, 0x0a, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, + 0x2f, 0x1b, 0xb1, 0x04, 0x20, 0x3e, 0x59, 0xb2, 0x00, 0x09, 0x04, 0x11, 0x12, 0x39, 0xb0, 0x00, 0x2f, 0x30, 0x31, + 0x13, 0x27, 0x36, 0x37, 0x35, 0x33, 0x15, 0x06, 0x06, 0x99, 0x69, 0x5d, 0x03, 0xb7, 0x01, 0x61, 0x04, 0x16, 0x48, + 0x82, 0x90, 0x90, 0x82, 0x64, 0xc7, 0x00, 0x01, 0x00, 0x24, 0xfe, 0xe5, 0x01, 0x3b, 0x00, 0xb5, 0x00, 0x08, 0x00, + 0x1f, 0xb2, 0x08, 0x09, 0x0a, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x09, 0x2f, 0xb1, 0x04, 0x05, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x00, 0xd0, 0xb0, 0x00, 0x2f, 0x30, 0x31, 0x13, 0x27, 0x36, 0x37, 0x35, 0x33, + 0x15, 0x14, 0x06, 0x8d, 0x69, 0x5b, 0x03, 0xb9, 0x63, 0xfe, 0xe5, 0x49, 0x7f, 0x92, 0x76, 0x64, 0x65, 0xca, 0x00, + 0x00, 0x01, 0x00, 0x4f, 0x04, 0x16, 0x01, 0x67, 0x06, 0x00, 0x00, 0x08, 0x00, 0x0c, 0x00, 0xb0, 0x08, 0x2f, 0xb0, + 0x04, 0xd0, 0xb0, 0x04, 0x2f, 0x30, 0x31, 0x01, 0x15, 0x16, 0x17, 0x07, 0x26, 0x26, 0x27, 0x35, 0x01, 0x06, 0x04, + 0x5d, 0x6a, 0x4d, 0x5f, 0x02, 0x06, 0x00, 0x93, 0x90, 0x7f, 0x48, 0x40, 0xc2, 0x61, 0x87, 0x00, 0xff, 0xff, 0x00, + 0x68, 0x04, 0x31, 0x02, 0xbb, 0x06, 0x13, 0x00, 0x26, 0x01, 0x84, 0x08, 0x00, 0x00, 0x07, 0x01, 0x84, 0x01, 0x43, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x3c, 0x04, 0x16, 0x02, 0x86, 0x06, 0x00, 0x00, 0x26, 0x01, 0x85, 0x0c, 0x00, 0x00, + 0x07, 0x01, 0x85, 0x01, 0x3f, 0x00, 0x00, 0x00, 0x02, 0x00, 0x24, 0xfe, 0xd3, 0x02, 0x64, 0x00, 0xf6, 0x00, 0x08, + 0x00, 0x11, 0x00, 0x31, 0xb2, 0x0a, 0x12, 0x13, 0x11, 0x12, 0x39, 0xb0, 0x0a, 0x10, 0xb0, 0x05, 0xd0, 0x00, 0xb0, + 0x12, 0x2f, 0xb1, 0x04, 0x05, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x00, 0xd0, 0xb0, 0x00, + 0x2f, 0xb0, 0x09, 0xd0, 0xb0, 0x09, 0x2f, 0xb0, 0x04, 0x10, 0xb0, 0x0d, 0xd0, 0x30, 0x31, 0x13, 0x27, 0x36, 0x37, + 0x35, 0x33, 0x15, 0x14, 0x06, 0x17, 0x27, 0x36, 0x37, 0x35, 0x33, 0x15, 0x14, 0x06, 0x8d, 0x69, 0x5b, 0x03, 0xb9, + 0x63, 0xdd, 0x69, 0x5b, 0x03, 0xba, 0x61, 0xfe, 0xd3, 0x48, 0x89, 0x99, 0xb9, 0xa4, 0x6c, 0xd3, 0x40, 0x48, 0x89, + 0x99, 0xb9, 0xa4, 0x6b, 0xd1, 0x00, 0x01, 0x00, 0x46, 0x00, 0x00, 0x04, 0x24, 0x05, 0xb0, 0x00, 0x0b, 0x00, 0x4c, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1a, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x0a, 0x10, 0xb1, + 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0xd0, 0xb0, 0x05, 0xd0, 0x30, 0x31, + 0x01, 0x21, 0x11, 0x23, 0x11, 0x21, 0x35, 0x21, 0x11, 0x33, 0x11, 0x21, 0x04, 0x24, 0xfe, 0x6c, 0xba, 0xfe, 0x70, + 0x01, 0x90, 0xba, 0x01, 0x94, 0x03, 0xa1, 0xfc, 0x5f, 0x03, 0xa1, 0x99, 0x01, 0x76, 0xfe, 0x8a, 0x00, 0x00, 0x01, + 0x00, 0x57, 0xfe, 0x60, 0x04, 0x34, 0x05, 0xb0, 0x00, 0x13, 0x00, 0x7e, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, + 0x2f, 0x1b, 0xb1, 0x0c, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1a, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0e, 0x2f, 0x1b, 0xb1, 0x0e, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x14, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb1, 0x06, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0e, 0x10, 0xb1, 0x08, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x09, 0xd0, 0xb0, 0x10, 0xd0, 0xb0, 0x11, 0xd0, 0xb0, 0x06, 0x10, 0xb0, 0x12, 0xd0, + 0xb0, 0x13, 0xd0, 0x30, 0x31, 0x21, 0x21, 0x11, 0x23, 0x11, 0x21, 0x35, 0x21, 0x11, 0x21, 0x35, 0x21, 0x11, 0x33, + 0x11, 0x21, 0x15, 0x21, 0x11, 0x21, 0x04, 0x34, 0xfe, 0x6a, 0xba, 0xfe, 0x73, 0x01, 0x8d, 0xfe, 0x73, 0x01, 0x8d, + 0xba, 0x01, 0x96, 0xfe, 0x6a, 0x01, 0x96, 0xfe, 0x60, 0x01, 0xa0, 0x97, 0x03, 0x0a, 0x99, 0x01, 0x76, 0xfe, 0x8a, + 0x99, 0xfc, 0xf6, 0x00, 0x00, 0x01, 0x00, 0x8a, 0x02, 0x17, 0x02, 0x22, 0x03, 0xcb, 0x00, 0x0d, 0x00, 0x17, 0xb2, + 0x0a, 0x0e, 0x0f, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x03, 0x2f, 0xb0, 0x0a, 0xb0, 0x0a, 0x2b, 0x58, 0xd8, 0x1b, 0xdc, + 0x59, 0x30, 0x31, 0x13, 0x34, 0x36, 0x33, 0x32, 0x16, 0x15, 0x15, 0x14, 0x06, 0x23, 0x22, 0x26, 0x35, 0x8a, 0x6f, + 0x5c, 0x5b, 0x72, 0x6e, 0x5e, 0x5d, 0x6f, 0x03, 0x04, 0x57, 0x70, 0x6d, 0x5d, 0x25, 0x57, 0x6e, 0x6f, 0x58, 0x00, + 0xff, 0xff, 0x00, 0x94, 0xff, 0xf5, 0x03, 0x2f, 0x00, 0xd1, 0x00, 0x26, 0x00, 0x12, 0x04, 0x00, 0x00, 0x07, 0x00, + 0x12, 0x01, 0xb9, 0x00, 0x00, 0xff, 0xff, 0x00, 0x94, 0xff, 0xf5, 0x04, 0xce, 0x00, 0xd1, 0x00, 0x26, 0x00, 0x12, + 0x04, 0x00, 0x00, 0x27, 0x00, 0x12, 0x01, 0xb9, 0x00, 0x00, 0x00, 0x07, 0x00, 0x12, 0x03, 0x58, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x52, 0x02, 0x02, 0x01, 0x2c, 0x02, 0xd5, 0x00, 0x0b, 0x00, 0x19, 0xb2, 0x03, 0x0c, 0x0d, 0x11, 0x12, + 0x39, 0x00, 0xb0, 0x03, 0x2f, 0xb1, 0x09, 0x05, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, + 0x13, 0x34, 0x36, 0x33, 0x32, 0x16, 0x15, 0x14, 0x06, 0x23, 0x22, 0x26, 0x52, 0x36, 0x36, 0x36, 0x38, 0x38, 0x36, + 0x36, 0x36, 0x02, 0x6b, 0x2d, 0x3d, 0x3d, 0x2d, 0x2d, 0x3c, 0x3c, 0x00, 0x00, 0x06, 0x00, 0x44, 0xff, 0xeb, 0x07, + 0x57, 0x05, 0xc5, 0x00, 0x15, 0x00, 0x23, 0x00, 0x27, 0x00, 0x35, 0x00, 0x43, 0x00, 0x51, 0x00, 0xbc, 0xb2, 0x02, + 0x52, 0x53, 0x11, 0x12, 0x39, 0xb0, 0x02, 0x10, 0xb0, 0x1b, 0xd0, 0xb0, 0x02, 0x10, 0xb0, 0x26, 0xd0, 0xb0, 0x02, + 0x10, 0xb0, 0x28, 0xd0, 0xb0, 0x02, 0x10, 0xb0, 0x36, 0xd0, 0xb0, 0x02, 0x10, 0xb0, 0x49, 0xd0, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x19, 0x2f, 0x1b, 0xb1, 0x19, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x12, 0x2f, 0x1b, + 0xb1, 0x12, 0x12, 0x3e, 0x59, 0xb0, 0x03, 0xd0, 0xb0, 0x03, 0x2f, 0xb0, 0x07, 0xd0, 0xb0, 0x07, 0x2f, 0xb0, 0x12, + 0x10, 0xb0, 0x0e, 0xd0, 0xb0, 0x0e, 0x2f, 0xb0, 0x19, 0x10, 0xb0, 0x20, 0xd0, 0xb0, 0x20, 0x2f, 0xb2, 0x24, 0x12, + 0x19, 0x11, 0x12, 0x39, 0xb0, 0x24, 0x2f, 0xb2, 0x26, 0x19, 0x12, 0x11, 0x12, 0x39, 0xb0, 0x26, 0x2f, 0xb0, 0x12, + 0x10, 0xb1, 0x2b, 0x04, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x32, 0x04, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x2b, 0x10, 0xb0, 0x39, 0xd0, 0xb0, 0x32, 0x10, 0xb0, + 0x40, 0xd0, 0xb0, 0x20, 0x10, 0xb1, 0x47, 0x04, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x19, + 0x10, 0xb1, 0x4e, 0x04, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x34, 0x36, 0x33, + 0x32, 0x17, 0x36, 0x33, 0x32, 0x16, 0x15, 0x15, 0x14, 0x06, 0x23, 0x22, 0x27, 0x06, 0x23, 0x22, 0x26, 0x35, 0x01, + 0x34, 0x36, 0x33, 0x32, 0x16, 0x15, 0x15, 0x14, 0x06, 0x23, 0x22, 0x26, 0x35, 0x01, 0x27, 0x01, 0x17, 0x03, 0x14, + 0x16, 0x33, 0x32, 0x36, 0x35, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x05, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, + 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x01, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x35, 0x34, 0x26, 0x23, 0x22, + 0x06, 0x15, 0x03, 0x37, 0xa7, 0x83, 0x98, 0x4d, 0x4f, 0x97, 0x83, 0xa8, 0xa7, 0x82, 0x99, 0x4f, 0x4c, 0x97, 0x82, + 0xaa, 0xfd, 0x0d, 0xa7, 0x83, 0x84, 0xa7, 0xa5, 0x84, 0x82, 0xaa, 0x01, 0x69, 0x68, 0x02, 0xc7, 0x68, 0xb3, 0x58, + 0x4a, 0x48, 0x56, 0x57, 0x49, 0x47, 0x59, 0x01, 0xcb, 0x58, 0x49, 0x48, 0x56, 0x57, 0x49, 0x48, 0x57, 0xfb, 0x42, + 0x58, 0x4a, 0x47, 0x57, 0x56, 0x4a, 0x48, 0x58, 0x01, 0x65, 0x83, 0xa9, 0x79, 0x79, 0xa8, 0x8b, 0x47, 0x83, 0xa9, + 0x78, 0x78, 0xa7, 0x8b, 0x03, 0x7b, 0x83, 0xaa, 0xaa, 0x88, 0x48, 0x81, 0xaa, 0xa7, 0x8b, 0xfc, 0x1c, 0x42, 0x04, + 0x72, 0x42, 0xfc, 0x37, 0x4f, 0x65, 0x63, 0x55, 0x4a, 0x4f, 0x64, 0x63, 0x54, 0x4a, 0x4f, 0x65, 0x66, 0x52, 0x4a, + 0x4f, 0x64, 0x64, 0x53, 0x02, 0xea, 0x4e, 0x65, 0x62, 0x55, 0x49, 0x4e, 0x66, 0x65, 0x53, 0x00, 0x00, 0x01, 0x00, + 0x6c, 0x00, 0x99, 0x02, 0x20, 0x03, 0xb5, 0x00, 0x06, 0x00, 0x10, 0x00, 0xb0, 0x05, 0x2f, 0xb2, 0x02, 0x07, 0x05, + 0x11, 0x12, 0x39, 0xb0, 0x02, 0x2f, 0x30, 0x31, 0x01, 0x01, 0x23, 0x01, 0x35, 0x01, 0x33, 0x01, 0x1e, 0x01, 0x02, + 0x8d, 0xfe, 0xd9, 0x01, 0x27, 0x8d, 0x02, 0x26, 0xfe, 0x73, 0x01, 0x84, 0x13, 0x01, 0x85, 0x00, 0x01, 0x00, 0x59, + 0x00, 0x98, 0x02, 0x0e, 0x03, 0xb5, 0x00, 0x06, 0x00, 0x10, 0x00, 0xb0, 0x00, 0x2f, 0xb2, 0x03, 0x07, 0x00, 0x11, + 0x12, 0x39, 0xb0, 0x03, 0x2f, 0x30, 0x31, 0x13, 0x01, 0x15, 0x01, 0x23, 0x01, 0x01, 0xe7, 0x01, 0x27, 0xfe, 0xd9, + 0x8e, 0x01, 0x02, 0xfe, 0xfe, 0x03, 0xb5, 0xfe, 0x7b, 0x13, 0xfe, 0x7b, 0x01, 0x8e, 0x01, 0x8f, 0x00, 0x01, 0x00, + 0x3b, 0x00, 0x6e, 0x03, 0x6a, 0x05, 0x22, 0x00, 0x03, 0x00, 0x09, 0x00, 0xb0, 0x00, 0x2f, 0xb0, 0x02, 0x2f, 0x30, + 0x31, 0x37, 0x27, 0x01, 0x17, 0xa3, 0x68, 0x02, 0xc7, 0x68, 0x6e, 0x42, 0x04, 0x72, 0x42, 0x00, 0xff, 0xff, 0x00, + 0x36, 0x02, 0x9b, 0x02, 0xbb, 0x05, 0xb0, 0x03, 0x07, 0x02, 0x20, 0x00, 0x00, 0x02, 0x9b, 0x00, 0x13, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x1e, 0x3e, 0x59, 0xb0, 0x0d, 0xd0, 0x30, 0x31, 0x00, 0x00, + 0x01, 0x00, 0x7a, 0x02, 0x8b, 0x02, 0xf8, 0x05, 0xba, 0x00, 0x0f, 0x00, 0x54, 0xb2, 0x0a, 0x10, 0x11, 0x11, 0x12, + 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, + 0x16, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x16, 0x3e, 0x59, 0xb2, 0x01, 0x0d, + 0x03, 0x11, 0x12, 0x39, 0xb0, 0x03, 0x10, 0xb1, 0x0a, 0x03, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0x30, 0x31, 0x13, 0x17, 0x36, 0x33, 0x20, 0x11, 0x11, 0x23, 0x11, 0x26, 0x23, 0x22, 0x07, 0x11, 0x23, 0x11, 0xfa, + 0x1e, 0x4a, 0x92, 0x01, 0x04, 0xaa, 0x03, 0x8d, 0x6e, 0x2c, 0xaa, 0x05, 0xab, 0x7b, 0x8a, 0xfe, 0xc6, 0xfe, 0x0b, + 0x01, 0xe6, 0xb9, 0x6d, 0xfd, 0xce, 0x03, 0x20, 0x00, 0x01, 0x00, 0x5b, 0x00, 0x00, 0x04, 0x68, 0x05, 0xc4, 0x00, + 0x29, 0x00, 0x9a, 0xb2, 0x21, 0x2a, 0x2b, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x19, 0x2f, 0x1b, + 0xb1, 0x19, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x12, 0x3e, 0x59, 0xb2, + 0x29, 0x19, 0x06, 0x11, 0x12, 0x39, 0xb0, 0x29, 0x2f, 0xb1, 0x00, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb0, 0x06, 0x10, 0xb1, 0x04, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, + 0xd0, 0xb0, 0x09, 0xd0, 0xb0, 0x00, 0x10, 0xb0, 0x0e, 0xd0, 0xb0, 0x29, 0x10, 0xb0, 0x10, 0xd0, 0xb0, 0x29, 0x10, + 0xb0, 0x15, 0xd0, 0xb0, 0x15, 0x2f, 0xb6, 0x0f, 0x15, 0x1f, 0x15, 0x2f, 0x15, 0x03, 0x5d, 0xb1, 0x12, 0x02, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x19, 0x10, 0xb0, 0x1d, 0xd0, 0xb0, 0x19, 0x10, 0xb1, 0x20, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x15, 0x10, 0xb0, 0x24, 0xd0, 0xb0, 0x12, 0x10, + 0xb0, 0x26, 0xd0, 0x30, 0x31, 0x01, 0x21, 0x17, 0x14, 0x07, 0x21, 0x07, 0x21, 0x35, 0x33, 0x36, 0x36, 0x37, 0x35, + 0x27, 0x23, 0x35, 0x33, 0x27, 0x23, 0x35, 0x33, 0x27, 0x34, 0x36, 0x33, 0x32, 0x16, 0x15, 0x23, 0x34, 0x26, 0x23, + 0x22, 0x06, 0x15, 0x17, 0x21, 0x15, 0x21, 0x17, 0x21, 0x03, 0x15, 0xfe, 0xb1, 0x03, 0x3e, 0x02, 0xdd, 0x01, 0xfb, + 0xf8, 0x4d, 0x28, 0x32, 0x02, 0x03, 0xaa, 0xa6, 0x04, 0xa2, 0x9d, 0x06, 0xf5, 0xc8, 0xbe, 0xde, 0xbf, 0x7f, 0x6f, + 0x69, 0x82, 0x06, 0x01, 0x5c, 0xfe, 0xa9, 0x04, 0x01, 0x53, 0x01, 0xd6, 0x44, 0x9a, 0x5b, 0x9d, 0x9d, 0x09, 0x83, + 0x60, 0x08, 0x45, 0x7d, 0x88, 0x7d, 0xb7, 0xc7, 0xee, 0xd4, 0xb1, 0x6b, 0x7c, 0x9a, 0x7d, 0xb7, 0x7d, 0x88, 0x00, + 0x05, 0x00, 0x1f, 0x00, 0x00, 0x06, 0x36, 0x05, 0xb0, 0x00, 0x1b, 0x00, 0x1f, 0x00, 0x23, 0x00, 0x26, 0x00, 0x29, + 0x00, 0xb3, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x17, 0x2f, 0x1b, 0xb1, 0x17, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x1a, 0x2f, 0x1b, 0xb1, 0x1a, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, + 0x0c, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x12, 0x3e, 0x59, 0xb2, 0x10, + 0x0c, 0x17, 0x11, 0x12, 0x39, 0xb0, 0x10, 0x2f, 0xb0, 0x14, 0xd0, 0xb0, 0x14, 0x2f, 0xb4, 0x0f, 0x14, 0x1f, 0x14, + 0x02, 0x5d, 0xb0, 0x24, 0xd0, 0xb0, 0x24, 0x2f, 0xb0, 0x18, 0xd0, 0xb0, 0x18, 0x2f, 0xb0, 0x00, 0xd0, 0xb0, 0x00, + 0x2f, 0xb0, 0x14, 0x10, 0xb1, 0x13, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x1f, 0xd0, + 0xb0, 0x23, 0xd0, 0xb0, 0x03, 0xd0, 0xb0, 0x10, 0x10, 0xb0, 0x1c, 0xd0, 0xb0, 0x1c, 0x2f, 0xb0, 0x20, 0xd0, 0xb0, + 0x20, 0x2f, 0xb0, 0x04, 0xd0, 0xb0, 0x04, 0x2f, 0xb0, 0x10, 0x10, 0xb1, 0x0f, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0b, 0xd0, 0xb0, 0x29, 0xd0, 0xb0, 0x07, 0xd0, 0xb2, 0x26, 0x17, 0x0c, 0x11, 0x12, + 0x39, 0xb2, 0x27, 0x09, 0x1a, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x33, 0x15, 0x23, 0x15, 0x33, 0x15, 0x23, 0x11, + 0x23, 0x01, 0x21, 0x11, 0x23, 0x11, 0x23, 0x35, 0x33, 0x35, 0x23, 0x35, 0x33, 0x11, 0x33, 0x01, 0x21, 0x11, 0x33, + 0x01, 0x21, 0x27, 0x23, 0x05, 0x33, 0x35, 0x21, 0x25, 0x33, 0x27, 0x01, 0x35, 0x23, 0x05, 0x57, 0xdf, 0xdf, 0xdf, + 0xdf, 0xc2, 0xfe, 0xc1, 0xfe, 0x62, 0xc0, 0xd9, 0xd9, 0xd9, 0xd9, 0xc0, 0x01, 0x51, 0x01, 0x8f, 0xbf, 0xfc, 0x61, + 0x01, 0x3b, 0x61, 0xda, 0x02, 0x14, 0xcc, 0xfe, 0xd4, 0xfe, 0x4c, 0x77, 0x77, 0x02, 0xe0, 0x68, 0x03, 0xac, 0x98, + 0x94, 0x98, 0xfe, 0x18, 0x01, 0xe8, 0xfe, 0x18, 0x01, 0xe8, 0x98, 0x94, 0x98, 0x02, 0x04, 0xfd, 0xfc, 0x02, 0x04, + 0xfc, 0xd0, 0x94, 0x94, 0x94, 0x98, 0xb6, 0xfc, 0xe7, 0x9f, 0x00, 0x00, 0x02, 0x00, 0xa7, 0xff, 0xec, 0x06, 0x03, + 0x05, 0xb0, 0x00, 0x1f, 0x00, 0x28, 0x00, 0xa6, 0xb2, 0x23, 0x29, 0x2a, 0x11, 0x12, 0x39, 0xb0, 0x23, 0x10, 0xb0, + 0x11, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x16, 0x2f, 0x1b, 0xb1, 0x16, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x1a, 0x2f, 0x1b, 0xb1, 0x1a, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x1e, 0x2f, 0x1b, 0xb1, + 0x1e, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x12, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x14, 0x2f, 0x1b, 0xb1, 0x14, 0x12, 0x3e, 0x59, 0xb0, 0x1e, 0x10, 0xb1, 0x00, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0a, 0x10, 0xb1, 0x05, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x00, 0x10, 0xb0, 0x0e, 0xd0, 0xb0, 0x0f, 0xd0, 0xb2, 0x21, 0x14, 0x16, 0x11, 0x12, 0x39, + 0xb0, 0x21, 0x2f, 0xb1, 0x12, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x1e, 0x10, 0xb0, + 0x1d, 0xd0, 0xb0, 0x1d, 0x2f, 0xb0, 0x16, 0x10, 0xb1, 0x27, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0x30, 0x31, 0x01, 0x23, 0x11, 0x14, 0x16, 0x33, 0x32, 0x37, 0x17, 0x06, 0x23, 0x22, 0x26, 0x35, 0x11, 0x23, + 0x06, 0x06, 0x07, 0x23, 0x11, 0x23, 0x11, 0x21, 0x32, 0x16, 0x17, 0x33, 0x11, 0x33, 0x11, 0x33, 0x01, 0x33, 0x32, + 0x36, 0x35, 0x34, 0x26, 0x27, 0x23, 0x05, 0xfe, 0xca, 0x36, 0x41, 0x23, 0x34, 0x01, 0x49, 0x46, 0x7c, 0x7e, 0x8f, + 0x14, 0xe7, 0xc7, 0xc9, 0xb9, 0x01, 0x79, 0xca, 0xed, 0x14, 0x8f, 0xba, 0xca, 0xfb, 0x62, 0xc0, 0x8b, 0x8b, 0x87, + 0x84, 0xcb, 0x03, 0xab, 0xfd, 0x61, 0x41, 0x41, 0x0c, 0x96, 0x14, 0x96, 0x8a, 0x02, 0x9f, 0xb7, 0xbd, 0x02, 0xfd, + 0xcb, 0x05, 0xb0, 0xc0, 0xb6, 0x01, 0x06, 0xfe, 0xfa, 0xfe, 0x92, 0x8d, 0x97, 0x98, 0x8e, 0x02, 0xff, 0xff, 0x00, + 0xa8, 0xff, 0xec, 0x08, 0x10, 0x05, 0xb0, 0x00, 0x26, 0x00, 0x36, 0x00, 0x00, 0x00, 0x07, 0x00, 0x57, 0x04, 0x55, + 0x00, 0x00, 0x00, 0x07, 0x00, 0x1f, 0x00, 0x00, 0x05, 0xcc, 0x05, 0xb0, 0x00, 0x1f, 0x00, 0x23, 0x00, 0x27, 0x00, + 0x2b, 0x00, 0x30, 0x00, 0x35, 0x00, 0x3a, 0x00, 0xfe, 0xb2, 0x39, 0x3b, 0x3c, 0x11, 0x12, 0x39, 0xb0, 0x39, 0x10, + 0xb0, 0x1e, 0xd0, 0xb0, 0x39, 0x10, 0xb0, 0x22, 0xd0, 0xb0, 0x39, 0x10, 0xb0, 0x27, 0xd0, 0xb0, 0x39, 0x10, 0xb0, + 0x2b, 0xd0, 0xb0, 0x39, 0x10, 0xb0, 0x2d, 0xd0, 0xb0, 0x39, 0x10, 0xb0, 0x33, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, + 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x12, 0x3e, 0x59, 0xb2, 0x08, 0x02, + 0x0c, 0x11, 0x12, 0x39, 0xb0, 0x08, 0x2f, 0xb0, 0x04, 0xd0, 0xb0, 0x04, 0x2f, 0xb0, 0x00, 0xd0, 0xb0, 0x04, 0x10, + 0xb1, 0x06, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, 0x10, 0xb1, 0x0a, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0e, 0xd0, 0xb0, 0x0a, 0x10, 0xb0, 0x12, 0xd0, 0xb0, 0x08, + 0x10, 0xb0, 0x14, 0xd0, 0xb0, 0x06, 0x10, 0xb0, 0x16, 0xd0, 0xb0, 0x04, 0x10, 0xb0, 0x18, 0xd0, 0xb0, 0x02, 0x10, + 0xb0, 0x1a, 0xd0, 0xb0, 0x04, 0x10, 0xb0, 0x1c, 0xd0, 0xb0, 0x02, 0x10, 0xb0, 0x1e, 0xd0, 0xb0, 0x08, 0x10, 0xb0, + 0x20, 0xd0, 0xb0, 0x06, 0x10, 0xb0, 0x22, 0xd0, 0xb0, 0x08, 0x10, 0xb0, 0x24, 0xd0, 0xb0, 0x06, 0x10, 0xb0, 0x26, + 0xd0, 0xb0, 0x08, 0x10, 0xb0, 0x28, 0xd0, 0xb0, 0x06, 0x10, 0xb0, 0x2a, 0xd0, 0xb0, 0x0a, 0x10, 0xb0, 0x2d, 0xd0, + 0xb2, 0x30, 0x02, 0x0c, 0x11, 0x12, 0x39, 0xb0, 0x0a, 0x10, 0xb0, 0x32, 0xd0, 0xb2, 0x35, 0x02, 0x0c, 0x11, 0x12, + 0x39, 0xb0, 0x04, 0x10, 0xb0, 0x36, 0xd0, 0xb2, 0x39, 0x02, 0x0c, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x33, 0x13, + 0x33, 0x03, 0x33, 0x15, 0x23, 0x07, 0x33, 0x15, 0x23, 0x03, 0x23, 0x03, 0x23, 0x03, 0x23, 0x03, 0x23, 0x35, 0x33, + 0x27, 0x23, 0x35, 0x33, 0x03, 0x33, 0x13, 0x33, 0x13, 0x33, 0x01, 0x33, 0x37, 0x23, 0x05, 0x33, 0x37, 0x23, 0x05, + 0x33, 0x27, 0x23, 0x03, 0x37, 0x23, 0x17, 0x17, 0x25, 0x37, 0x23, 0x17, 0x17, 0x01, 0x33, 0x27, 0x27, 0x07, 0x03, + 0xa7, 0xea, 0x58, 0xc1, 0x65, 0x87, 0xa8, 0x29, 0xd1, 0xf1, 0x66, 0xb8, 0x56, 0xe5, 0x58, 0xb8, 0x67, 0xec, 0xcc, + 0x29, 0xa3, 0x82, 0x65, 0xc0, 0x5b, 0xf1, 0x56, 0xb3, 0xfe, 0x48, 0x70, 0x23, 0xb8, 0x02, 0x71, 0x6c, 0x24, 0xb3, + 0xfe, 0xdc, 0xae, 0x22, 0x68, 0xd6, 0x02, 0x37, 0x01, 0x17, 0x02, 0x65, 0x01, 0x35, 0x02, 0x1b, 0xfe, 0xc0, 0x32, + 0x01, 0x18, 0x18, 0x03, 0xd4, 0x01, 0xdc, 0xfe, 0x24, 0x98, 0xc2, 0x98, 0xfe, 0x1e, 0x01, 0xe2, 0xfe, 0x1e, 0x01, + 0xe2, 0x98, 0xc2, 0x98, 0x01, 0xdc, 0xfe, 0x24, 0x01, 0xdc, 0xfc, 0xca, 0xc2, 0xc2, 0xc2, 0xc2, 0xc2, 0xfe, 0x9c, + 0x0a, 0x06, 0xd2, 0xd2, 0x06, 0x07, 0xcb, 0x02, 0xc4, 0x07, 0xad, 0xb1, 0x00, 0x00, 0x02, 0x00, 0x8c, 0x00, 0x00, + 0x05, 0x9e, 0x04, 0x3a, 0x00, 0x0d, 0x00, 0x1b, 0x00, 0x66, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x16, 0x2f, 0x1b, + 0xb1, 0x16, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1a, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0e, 0x2f, + 0x1b, 0xb1, 0x0e, 0x12, 0x3e, 0x59, 0xb1, 0x11, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, + 0x05, 0x11, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x05, 0x2f, 0xb0, 0x00, 0x10, 0xb1, 0x0a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x0f, 0x0a, 0x0b, 0x11, 0x12, 0x39, 0xb0, 0x0f, 0x2f, 0x30, 0x31, 0x01, 0x32, + 0x16, 0x17, 0x11, 0x23, 0x11, 0x34, 0x26, 0x27, 0x21, 0x11, 0x23, 0x11, 0x01, 0x11, 0x33, 0x11, 0x21, 0x32, 0x36, + 0x37, 0x11, 0x33, 0x11, 0x06, 0x06, 0x07, 0x02, 0xba, 0xaf, 0xa8, 0x04, 0xb9, 0x65, 0x6f, 0xfe, 0xbd, 0xb9, 0x01, + 0x89, 0xb9, 0x01, 0x3e, 0x71, 0x67, 0x01, 0xb9, 0x02, 0xa5, 0xad, 0x04, 0x3a, 0xc1, 0xbf, 0xfe, 0xa3, 0x01, 0x4c, + 0x7f, 0x78, 0x01, 0xfc, 0x5f, 0x04, 0x3a, 0xfb, 0xc6, 0x02, 0xdd, 0xfd, 0xbb, 0x75, 0x7e, 0x02, 0xaf, 0xfd, 0x4e, + 0xc2, 0xc4, 0x02, 0x00, 0x00, 0x01, 0x00, 0x5f, 0xff, 0xec, 0x04, 0x1c, 0x05, 0xc4, 0x00, 0x23, 0x00, 0x8b, 0xb2, + 0x15, 0x24, 0x25, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x16, 0x2f, 0x1b, 0xb1, 0x16, 0x1e, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x12, 0x3e, 0x59, 0xb2, 0x23, 0x09, 0x16, 0x11, + 0x12, 0x39, 0xb0, 0x23, 0x2f, 0xb1, 0x00, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x09, + 0x10, 0xb1, 0x04, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x00, 0x10, 0xb0, 0x0c, 0xd0, + 0xb0, 0x23, 0x10, 0xb0, 0x0f, 0xd0, 0xb0, 0x23, 0x10, 0xb0, 0x1f, 0xd0, 0xb0, 0x1f, 0x2f, 0xb6, 0x0f, 0x1f, 0x1f, + 0x1f, 0x2f, 0x1f, 0x03, 0x5d, 0xb1, 0x20, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x10, + 0xd0, 0xb0, 0x1f, 0x10, 0xb0, 0x13, 0xd0, 0xb0, 0x16, 0x10, 0xb1, 0x1b, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, 0x16, 0x16, 0x33, 0x32, 0x37, 0x17, 0x06, 0x23, 0x22, 0x00, 0x03, 0x23, + 0x35, 0x33, 0x35, 0x23, 0x35, 0x33, 0x12, 0x00, 0x33, 0x32, 0x17, 0x07, 0x26, 0x23, 0x22, 0x06, 0x07, 0x21, 0x15, + 0x21, 0x15, 0x21, 0x03, 0x51, 0xfe, 0x80, 0x04, 0xb4, 0xa5, 0x74, 0x66, 0x14, 0x78, 0x78, 0xf8, 0xfe, 0xe3, 0x06, + 0xb2, 0xb2, 0xb2, 0xb2, 0x0a, 0x01, 0x1d, 0xf3, 0x6a, 0x87, 0x14, 0x6d, 0x6e, 0xa4, 0xb1, 0x06, 0x01, 0x7f, 0xfe, + 0x80, 0x01, 0x80, 0x02, 0x1d, 0xc3, 0xd2, 0x22, 0xa0, 0x1e, 0x01, 0x25, 0x01, 0x0c, 0x7c, 0x89, 0x7d, 0x01, 0x06, + 0x01, 0x1f, 0x1f, 0xa2, 0x23, 0xcb, 0xbc, 0x7d, 0x89, 0x00, 0x04, 0x00, 0x1f, 0x00, 0x00, 0x05, 0xbc, 0x05, 0xb0, + 0x00, 0x19, 0x00, 0x1e, 0x00, 0x23, 0x00, 0x28, 0x00, 0xbc, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, + 0xb1, 0x0b, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x12, 0x3e, 0x59, 0xb0, + 0x0b, 0x10, 0xb1, 0x28, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x24, 0x28, 0x01, 0x11, + 0x12, 0x39, 0xb0, 0x24, 0x2f, 0xb2, 0x70, 0x24, 0x01, 0x71, 0xb6, 0x00, 0x24, 0x10, 0x24, 0x20, 0x24, 0x03, 0x5d, + 0xb1, 0x1c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x1d, 0xd0, 0xb0, 0x1d, 0x2f, 0xb2, + 0x70, 0x1d, 0x01, 0x71, 0xb6, 0x00, 0x1d, 0x10, 0x1d, 0x20, 0x1d, 0x03, 0x5d, 0xb1, 0x20, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x21, 0xd0, 0xb0, 0x21, 0x2f, 0xb2, 0x70, 0x21, 0x01, 0x71, 0xb2, 0x20, + 0x21, 0x01, 0x5d, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x20, 0x10, 0xb0, + 0x03, 0xd0, 0xb0, 0x1d, 0x10, 0xb0, 0x06, 0xd0, 0xb0, 0x06, 0x2f, 0xb0, 0x1c, 0x10, 0xb0, 0x07, 0xd0, 0xb0, 0x24, + 0x10, 0xb0, 0x0a, 0xd0, 0xb0, 0x24, 0x10, 0xb0, 0x0f, 0xd0, 0xb0, 0x1c, 0x10, 0xb0, 0x12, 0xd0, 0xb0, 0x1d, 0x10, + 0xb0, 0x14, 0xd0, 0xb0, 0x14, 0x2f, 0x30, 0x31, 0x01, 0x11, 0x23, 0x11, 0x23, 0x35, 0x33, 0x35, 0x23, 0x35, 0x33, + 0x35, 0x21, 0x32, 0x16, 0x17, 0x33, 0x15, 0x23, 0x17, 0x07, 0x33, 0x15, 0x23, 0x06, 0x21, 0x01, 0x27, 0x21, 0x15, + 0x21, 0x07, 0x21, 0x15, 0x21, 0x32, 0x01, 0x21, 0x26, 0x23, 0x21, 0x01, 0xa5, 0xc0, 0xc6, 0xc6, 0xc6, 0xc6, 0x02, + 0x19, 0xb1, 0xeb, 0x36, 0xec, 0xc3, 0x03, 0x02, 0xc2, 0xe5, 0x6b, 0xfe, 0x8c, 0x01, 0x44, 0x04, 0xfd, 0x6d, 0x02, + 0x95, 0x3f, 0xfd, 0xaa, 0x01, 0x59, 0xac, 0xfd, 0xfb, 0x02, 0x4a, 0x54, 0x9e, 0xfe, 0xa8, 0x02, 0x3a, 0xfd, 0xc6, + 0x03, 0x30, 0x97, 0x5e, 0x97, 0xf4, 0x84, 0x70, 0x97, 0x32, 0x2c, 0x97, 0xf6, 0x01, 0xb7, 0x34, 0x5e, 0x97, 0x59, + 0x01, 0xe5, 0x56, 0x00, 0x00, 0x01, 0x00, 0x2a, 0x00, 0x00, 0x03, 0xf8, 0x05, 0xb0, 0x00, 0x1a, 0x00, 0x69, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x19, 0x2f, 0x1b, 0xb1, 0x19, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, + 0x2f, 0x1b, 0xb1, 0x0c, 0x12, 0x3e, 0x59, 0xb0, 0x19, 0x10, 0xb1, 0x18, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x01, 0xd0, 0xb0, 0x18, 0x10, 0xb0, 0x14, 0xd0, 0xb0, 0x14, 0x2f, 0xb0, 0x03, 0xd0, 0xb0, + 0x14, 0x10, 0xb1, 0x13, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x06, 0xd0, 0xb0, 0x13, + 0x10, 0xb0, 0x0e, 0xd0, 0xb0, 0x0e, 0x2f, 0xb1, 0x09, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb2, 0x0d, 0x09, 0x0e, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x23, 0x16, 0x17, 0x33, 0x07, 0x23, 0x06, 0x06, 0x23, + 0x01, 0x15, 0x23, 0x01, 0x27, 0x33, 0x36, 0x36, 0x37, 0x21, 0x37, 0x21, 0x26, 0x27, 0x21, 0x37, 0x21, 0x03, 0xca, + 0xec, 0x40, 0x11, 0xc9, 0x2e, 0x98, 0x12, 0xf6, 0xdb, 0x01, 0xed, 0xe3, 0xfd, 0xee, 0x01, 0xf9, 0x7d, 0x9c, 0x15, + 0xfd, 0xbd, 0x2e, 0x02, 0x13, 0x30, 0xf6, 0xfe, 0xe7, 0x2f, 0x03, 0x9d, 0x05, 0x12, 0x51, 0x75, 0x9e, 0xb2, 0xb4, + 0xfd, 0xc4, 0x0c, 0x02, 0x69, 0x7d, 0x01, 0x6b, 0x5c, 0x9e, 0xbe, 0x08, 0x9e, 0x00, 0x00, 0x01, 0x00, 0x20, 0xff, + 0xee, 0x04, 0x1a, 0x05, 0xb0, 0x00, 0x1e, 0x00, 0x90, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x11, 0x2f, 0x1b, 0xb1, + 0x11, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x12, 0x3e, 0x59, 0xb2, 0x13, + 0x11, 0x05, 0x11, 0x12, 0x39, 0xb0, 0x13, 0x2f, 0xb0, 0x17, 0xd0, 0xb0, 0x17, 0x2f, 0xb2, 0x00, 0x17, 0x01, 0x5d, + 0xb1, 0x18, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x19, 0xd0, 0xb0, 0x08, 0xd0, 0xb0, + 0x09, 0xd0, 0xb0, 0x17, 0x10, 0xb0, 0x16, 0xd0, 0xb0, 0x0b, 0xd0, 0xb0, 0x0a, 0xd0, 0xb0, 0x13, 0x10, 0xb1, 0x14, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x15, 0xd0, 0xb0, 0x0c, 0xd0, 0xb0, 0x0d, 0xd0, + 0xb0, 0x13, 0x10, 0xb0, 0x12, 0xd0, 0xb0, 0x0f, 0xd0, 0xb0, 0x0e, 0xd0, 0xb0, 0x05, 0x10, 0xb1, 0x1a, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x1e, 0x05, 0x11, 0x11, 0x12, 0x39, 0xb0, 0x1e, 0x2f, 0x30, + 0x31, 0x01, 0x15, 0x06, 0x02, 0x04, 0x23, 0x22, 0x27, 0x11, 0x07, 0x35, 0x37, 0x35, 0x07, 0x35, 0x37, 0x11, 0x33, + 0x11, 0x37, 0x15, 0x07, 0x15, 0x37, 0x15, 0x07, 0x11, 0x36, 0x12, 0x11, 0x35, 0x04, 0x1a, 0x02, 0x90, 0xfe, 0xf7, + 0xaf, 0x50, 0x6c, 0xf4, 0xf4, 0xf4, 0xf4, 0xc0, 0xfb, 0xfb, 0xfb, 0xfb, 0xbe, 0xc9, 0x03, 0x03, 0x64, 0xd2, 0xfe, + 0xc7, 0xa6, 0x12, 0x02, 0x5a, 0x6f, 0xb2, 0x6f, 0x99, 0x6f, 0xb2, 0x6f, 0x01, 0x59, 0xfe, 0xff, 0x73, 0xb2, 0x73, + 0x99, 0x73, 0xb2, 0x73, 0xfd, 0xde, 0x02, 0x01, 0x10, 0x01, 0x09, 0x58, 0x00, 0x00, 0x01, 0x00, 0x5d, 0x00, 0x00, + 0x04, 0xeb, 0x04, 0x3a, 0x00, 0x17, 0x00, 0x5d, 0xb2, 0x00, 0x18, 0x19, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x16, 0x2f, 0x1b, 0xb1, 0x16, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, + 0x04, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x12, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x12, 0x3e, 0x59, 0xb2, 0x00, 0x0a, 0x16, 0x11, 0x12, 0x39, 0xb0, + 0x00, 0x2f, 0xb1, 0x09, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0c, 0xd0, 0xb0, 0x00, + 0x10, 0xb0, 0x15, 0xd0, 0x30, 0x31, 0x01, 0x16, 0x00, 0x11, 0x15, 0x23, 0x35, 0x26, 0x02, 0x27, 0x11, 0x23, 0x11, + 0x06, 0x02, 0x07, 0x15, 0x23, 0x35, 0x12, 0x00, 0x37, 0x35, 0x33, 0x02, 0xff, 0xe7, 0x01, 0x05, 0xb9, 0x02, 0x9e, + 0x93, 0xb9, 0x8f, 0x9f, 0x02, 0xb9, 0x03, 0x01, 0x07, 0xdf, 0xb9, 0x03, 0x71, 0x21, 0xfe, 0x8d, 0xfe, 0xda, 0xb7, + 0xc8, 0xdf, 0x01, 0x05, 0x20, 0xfd, 0x34, 0x02, 0xca, 0x21, 0xfe, 0xf5, 0xd8, 0xc6, 0xc5, 0x01, 0x1d, 0x01, 0x6d, + 0x22, 0xc9, 0x00, 0x00, 0x02, 0x00, 0x1f, 0x00, 0x00, 0x05, 0x03, 0x05, 0xb0, 0x00, 0x16, 0x00, 0x1f, 0x00, 0x70, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x12, 0x3e, 0x59, 0xb2, 0x06, 0x03, 0x0c, 0x11, 0x12, 0x39, 0xb0, 0x06, 0x2f, 0xb1, + 0x05, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x01, 0xd0, 0xb0, 0x06, 0x10, 0xb0, 0x0a, + 0xd0, 0xb0, 0x0a, 0x2f, 0xb4, 0x0f, 0x0a, 0x1f, 0x0a, 0x02, 0x5d, 0xb1, 0x09, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x14, 0xd0, 0xb0, 0x06, 0x10, 0xb0, 0x15, 0xd0, 0xb0, 0x0a, 0x10, 0xb0, 0x17, 0xd0, + 0xb0, 0x0c, 0x10, 0xb1, 0x1f, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, + 0x11, 0x23, 0x11, 0x23, 0x35, 0x33, 0x35, 0x23, 0x35, 0x33, 0x11, 0x21, 0x32, 0x04, 0x15, 0x14, 0x04, 0x07, 0x21, + 0x15, 0x21, 0x01, 0x21, 0x32, 0x36, 0x35, 0x34, 0x26, 0x27, 0x21, 0x02, 0xfc, 0xfe, 0xb1, 0xbf, 0xcf, 0xcf, 0xcf, + 0xcf, 0x02, 0x19, 0xea, 0x01, 0x12, 0xfe, 0xf9, 0xf2, 0xfe, 0xa3, 0x01, 0x4f, 0xfe, 0xb1, 0x01, 0x5a, 0x9b, 0xa2, + 0xa8, 0x8f, 0xfe, 0xa0, 0x01, 0x13, 0xfe, 0xed, 0x01, 0x13, 0x9e, 0x89, 0x9d, 0x02, 0xd9, 0xee, 0xcb, 0xd5, 0xe7, + 0x01, 0x89, 0x01, 0x26, 0x92, 0x8c, 0x7f, 0x9d, 0x01, 0x00, 0x00, 0x04, 0x00, 0x7a, 0xff, 0xeb, 0x05, 0x83, 0x05, + 0xc5, 0x00, 0x1b, 0x00, 0x27, 0x00, 0x35, 0x00, 0x39, 0x00, 0xbb, 0xb2, 0x1c, 0x3a, 0x3b, 0x11, 0x12, 0x39, 0xb0, + 0x1c, 0x10, 0xb0, 0x00, 0xd0, 0xb0, 0x1c, 0x10, 0xb0, 0x28, 0xd0, 0xb0, 0x1c, 0x10, 0xb0, 0x38, 0xd0, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x25, 0x2f, + 0x1b, 0xb1, 0x25, 0x12, 0x3e, 0x59, 0xb0, 0x0a, 0x10, 0xb0, 0x03, 0xd0, 0xb0, 0x03, 0x2f, 0xb2, 0x0e, 0x0a, 0x03, + 0x11, 0x12, 0x39, 0xb6, 0x2a, 0x0e, 0x3a, 0x0e, 0x4a, 0x0e, 0x03, 0x5d, 0xb0, 0x0a, 0x10, 0xb1, 0x11, 0x04, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x18, 0x04, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x1b, 0x03, 0x0a, 0x11, 0x12, 0x39, 0xb4, 0x36, 0x1b, 0x46, 0x1b, 0x02, 0x5d, 0xb2, + 0x25, 0x1b, 0x01, 0x5d, 0xb0, 0x25, 0x10, 0xb0, 0x1f, 0xd0, 0xb0, 0x1f, 0x2f, 0xb0, 0x25, 0x10, 0xb1, 0x2b, 0x04, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x1f, 0x10, 0xb1, 0x32, 0x04, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x36, 0x25, 0x0a, 0x11, 0x12, 0x39, 0xb0, 0x36, 0x2f, 0xb2, 0x38, 0x0a, 0x25, + 0x11, 0x12, 0x39, 0xb0, 0x38, 0x2f, 0x30, 0x31, 0x01, 0x14, 0x06, 0x23, 0x22, 0x26, 0x35, 0x35, 0x34, 0x36, 0x33, + 0x32, 0x16, 0x15, 0x23, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x01, 0x34, + 0x36, 0x20, 0x16, 0x15, 0x15, 0x14, 0x06, 0x20, 0x26, 0x35, 0x17, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x35, 0x34, + 0x26, 0x23, 0x22, 0x06, 0x15, 0x05, 0x27, 0x01, 0x17, 0x02, 0xa8, 0x98, 0x7b, 0x7a, 0xa1, 0x9e, 0x7b, 0x79, 0x9c, + 0x8a, 0x49, 0x42, 0x41, 0x4d, 0x4f, 0x41, 0x3d, 0x4c, 0x01, 0x10, 0xa7, 0x01, 0x06, 0xa8, 0xa7, 0xfe, 0xfc, 0xaa, + 0x8a, 0x58, 0x4a, 0x48, 0x56, 0x57, 0x49, 0x47, 0x59, 0xfe, 0x06, 0x69, 0x02, 0xc7, 0x69, 0x04, 0x1e, 0x6e, 0x90, + 0xa8, 0x89, 0x47, 0x82, 0xab, 0x91, 0x6f, 0x3a, 0x4d, 0x66, 0x52, 0x49, 0x4e, 0x65, 0x4c, 0x3a, 0xfd, 0x47, 0x83, + 0xa9, 0xa8, 0x8b, 0x47, 0x83, 0xa9, 0xa7, 0x8b, 0x06, 0x4f, 0x65, 0x63, 0x55, 0x4a, 0x4f, 0x64, 0x63, 0x54, 0xf3, + 0x42, 0x04, 0x72, 0x42, 0x00, 0x00, 0x02, 0x00, 0x68, 0xff, 0xeb, 0x03, 0x6a, 0x06, 0x13, 0x00, 0x17, 0x00, 0x21, + 0x00, 0x67, 0xb2, 0x13, 0x22, 0x23, 0x11, 0x12, 0x39, 0xb0, 0x13, 0x10, 0xb0, 0x18, 0xd0, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x20, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, + 0x00, 0x12, 0x3e, 0x59, 0xb2, 0x06, 0x0c, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x06, 0x2f, 0xb1, 0x05, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x13, 0xd0, 0xb0, 0x00, 0x10, 0xb1, 0x17, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x06, 0x10, 0xb0, 0x18, 0xd0, 0xb0, 0x0c, 0x10, 0xb1, 0x1f, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x05, 0x22, 0x26, 0x35, 0x06, 0x23, 0x35, 0x32, 0x37, + 0x11, 0x36, 0x36, 0x33, 0x32, 0x16, 0x15, 0x15, 0x14, 0x02, 0x07, 0x15, 0x14, 0x16, 0x33, 0x03, 0x36, 0x36, 0x35, + 0x35, 0x34, 0x26, 0x23, 0x22, 0x07, 0x02, 0xcc, 0xc2, 0xd2, 0x62, 0x6e, 0x71, 0x5f, 0x01, 0x9d, 0x85, 0x78, 0x97, + 0xce, 0xab, 0x6b, 0x70, 0xdb, 0x59, 0x67, 0x30, 0x26, 0x67, 0x03, 0x15, 0xea, 0xeb, 0x1c, 0xb0, 0x23, 0x02, 0x24, + 0xb2, 0xc6, 0xad, 0x93, 0x25, 0xc1, 0xfe, 0x8f, 0x6b, 0x62, 0x9a, 0x8d, 0x02, 0x63, 0x55, 0xf5, 0x7b, 0x27, 0x52, + 0x4c, 0xd1, 0x00, 0x04, 0x00, 0xa2, 0x00, 0x00, 0x07, 0xc6, 0x05, 0xc0, 0x00, 0x03, 0x00, 0x10, 0x00, 0x1e, 0x00, + 0x28, 0x00, 0xa6, 0xb2, 0x1f, 0x29, 0x2a, 0x11, 0x12, 0x39, 0xb0, 0x1f, 0x10, 0xb0, 0x01, 0xd0, 0xb0, 0x1f, 0x10, + 0xb0, 0x04, 0xd0, 0xb0, 0x1f, 0x10, 0xb0, 0x11, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x27, 0x2f, 0x1b, 0xb1, + 0x27, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x25, 0x2f, 0x1b, 0xb1, 0x25, 0x1e, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x22, 0x2f, 0x1b, + 0xb1, 0x22, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x20, 0x2f, 0x1b, 0xb1, 0x20, 0x12, 0x3e, 0x59, 0xb0, + 0x07, 0x10, 0xb0, 0x0d, 0xd0, 0xb0, 0x02, 0xd0, 0xb0, 0x02, 0x2f, 0xb2, 0x10, 0x02, 0x01, 0x5d, 0xb1, 0x01, 0x03, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0d, 0x10, 0xb1, 0x14, 0x03, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x07, 0x10, 0xb1, 0x1b, 0x03, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb2, 0x21, 0x25, 0x20, 0x11, 0x12, 0x39, 0xb2, 0x26, 0x20, 0x25, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x21, + 0x35, 0x21, 0x01, 0x34, 0x36, 0x20, 0x16, 0x15, 0x15, 0x14, 0x06, 0x23, 0x22, 0x26, 0x35, 0x17, 0x14, 0x16, 0x33, + 0x32, 0x36, 0x37, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x01, 0x23, 0x01, 0x11, 0x23, 0x11, 0x33, 0x01, 0x11, + 0x33, 0x07, 0xa4, 0xfd, 0x99, 0x02, 0x67, 0xfd, 0x75, 0xba, 0x01, 0x38, 0xbb, 0xb9, 0x9c, 0x9e, 0xba, 0xa3, 0x5f, + 0x56, 0x54, 0x5d, 0x01, 0x5f, 0x55, 0x54, 0x5f, 0xfe, 0xbc, 0xcc, 0xfd, 0xaf, 0xb9, 0xcb, 0x02, 0x54, 0xb7, 0x01, + 0x9c, 0x8e, 0x02, 0x3d, 0x9b, 0xbe, 0xbb, 0xa3, 0x5d, 0x9d, 0xba, 0xbb, 0xa1, 0x05, 0x62, 0x6b, 0x6a, 0x60, 0x65, + 0x61, 0x6b, 0x6b, 0x63, 0xfb, 0x9b, 0x04, 0x6e, 0xfb, 0x92, 0x05, 0xb0, 0xfb, 0x8f, 0x04, 0x71, 0x00, 0x00, 0x02, + 0x00, 0x67, 0x03, 0x97, 0x04, 0x38, 0x05, 0xb0, 0x00, 0x0c, 0x00, 0x14, 0x00, 0x6e, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, + 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x13, 0x2f, 0x1b, 0xb1, 0x13, 0x1e, 0x3e, 0x59, 0xb2, 0x01, 0x15, + 0x06, 0x11, 0x12, 0x39, 0xb0, 0x01, 0x2f, 0xb2, 0x00, 0x09, 0x01, 0x11, 0x12, 0x39, 0xb2, 0x03, 0x01, 0x06, 0x11, + 0x12, 0x39, 0xb0, 0x04, 0xd0, 0xb2, 0x08, 0x01, 0x09, 0x11, 0x12, 0x39, 0xb0, 0x01, 0x10, 0xb0, 0x0b, 0xd0, 0xb0, + 0x06, 0x10, 0xb0, 0x0d, 0xb0, 0x0a, 0x2b, 0x58, 0xd8, 0x1b, 0xdc, 0x59, 0xb0, 0x01, 0x10, 0xb0, 0x0f, 0xd0, 0xb0, + 0x0d, 0x10, 0xb0, 0x11, 0xd0, 0xb0, 0x12, 0xd0, 0x30, 0x31, 0x01, 0x03, 0x23, 0x03, 0x11, 0x23, 0x11, 0x33, 0x13, + 0x13, 0x33, 0x11, 0x23, 0x01, 0x23, 0x11, 0x23, 0x11, 0x23, 0x35, 0x21, 0x03, 0xde, 0x8c, 0x34, 0x8c, 0x5a, 0x70, + 0x90, 0x90, 0x70, 0x5a, 0xfe, 0x0b, 0x93, 0x5b, 0x94, 0x01, 0x82, 0x05, 0x21, 0xfe, 0x76, 0x01, 0x89, 0xfe, 0x77, + 0x02, 0x19, 0xfe, 0x71, 0x01, 0x8f, 0xfd, 0xe7, 0x01, 0xc8, 0xfe, 0x38, 0x01, 0xc8, 0x51, 0x00, 0x02, 0x00, 0x98, + 0xff, 0xec, 0x04, 0x93, 0x04, 0x4e, 0x00, 0x15, 0x00, 0x1c, 0x00, 0x65, 0xb2, 0x02, 0x1d, 0x1e, 0x11, 0x12, 0x39, + 0xb0, 0x02, 0x10, 0xb0, 0x16, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1a, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb2, 0x1a, 0x0a, 0x02, 0x11, + 0x12, 0x39, 0xb0, 0x1a, 0x2f, 0xb1, 0x0f, 0x0a, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x02, + 0x10, 0xb1, 0x13, 0x0a, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x15, 0x0a, 0x02, 0x11, 0x12, + 0x39, 0xb0, 0x0a, 0x10, 0xb1, 0x16, 0x0a, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x25, + 0x06, 0x23, 0x22, 0x26, 0x02, 0x35, 0x34, 0x12, 0x36, 0x33, 0x32, 0x16, 0x16, 0x17, 0x15, 0x21, 0x11, 0x16, 0x33, + 0x32, 0x37, 0x01, 0x22, 0x07, 0x11, 0x21, 0x11, 0x26, 0x04, 0x16, 0xb7, 0xbb, 0x91, 0xf4, 0x87, 0x90, 0xf8, 0x84, + 0x85, 0xe3, 0x84, 0x03, 0xfd, 0x00, 0x77, 0x9a, 0xc4, 0xac, 0xfe, 0x90, 0x97, 0x7a, 0x02, 0x1c, 0x73, 0x5e, 0x72, + 0x9d, 0x01, 0x01, 0x93, 0x8f, 0x01, 0x03, 0x9f, 0x8b, 0xf3, 0x90, 0x3e, 0xfe, 0xb8, 0x6e, 0x7a, 0x03, 0x2a, 0x7a, + 0xfe, 0xeb, 0x01, 0x1e, 0x71, 0x00, 0xff, 0xff, 0x00, 0x54, 0xff, 0xf5, 0x05, 0xb3, 0x05, 0x9b, 0x00, 0x27, 0x01, + 0xc6, 0xff, 0xda, 0x02, 0x86, 0x00, 0x27, 0x01, 0x94, 0x00, 0xe6, 0x00, 0x00, 0x01, 0x07, 0x02, 0x24, 0x03, 0x14, + 0x00, 0x00, 0x00, 0x10, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x1e, 0x3e, 0x59, 0x30, + 0x31, 0xff, 0xff, 0x00, 0x64, 0xff, 0xf5, 0x06, 0x53, 0x05, 0xb4, 0x00, 0x27, 0x02, 0x1f, 0x00, 0x26, 0x02, 0x94, + 0x00, 0x27, 0x01, 0x94, 0x01, 0xa5, 0x00, 0x00, 0x01, 0x07, 0x02, 0x24, 0x03, 0xb4, 0x00, 0x00, 0x00, 0x10, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0e, 0x2f, 0x1b, 0xb1, 0x0e, 0x1e, 0x3e, 0x59, 0x30, 0x31, 0xff, 0xff, 0x00, 0x63, + 0xff, 0xf5, 0x06, 0x49, 0x05, 0xa4, 0x00, 0x27, 0x02, 0x21, 0x00, 0x08, 0x02, 0x8f, 0x00, 0x27, 0x01, 0x94, 0x01, + 0x83, 0x00, 0x00, 0x01, 0x07, 0x02, 0x24, 0x03, 0xaa, 0x00, 0x00, 0x00, 0x10, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x1e, 0x3e, 0x59, 0x30, 0x31, 0xff, 0xff, 0x00, 0x59, 0xff, 0xf5, 0x05, 0xfd, 0x05, + 0xa4, 0x00, 0x27, 0x02, 0x23, 0x00, 0x1f, 0x02, 0x8f, 0x00, 0x27, 0x01, 0x94, 0x01, 0x20, 0x00, 0x00, 0x01, 0x07, + 0x02, 0x24, 0x03, 0x5e, 0x00, 0x00, 0x00, 0x10, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, + 0x1e, 0x3e, 0x59, 0x30, 0x31, 0x00, 0x02, 0x00, 0x6a, 0xff, 0xeb, 0x04, 0x32, 0x05, 0xec, 0x00, 0x1b, 0x00, 0x2a, + 0x00, 0x5e, 0xb2, 0x15, 0x2b, 0x2c, 0x11, 0x12, 0x39, 0xb0, 0x15, 0x10, 0xb0, 0x23, 0xd0, 0x00, 0xb0, 0x0d, 0x2f, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x15, 0x2f, 0x1b, 0xb1, 0x15, 0x12, 0x3e, 0x59, 0xb2, 0x00, 0x0d, 0x15, 0x11, 0x12, + 0x39, 0xb0, 0x00, 0x2f, 0xb2, 0x03, 0x00, 0x15, 0x11, 0x12, 0x39, 0xb0, 0x0d, 0x10, 0xb1, 0x07, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x00, 0x10, 0xb1, 0x1c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x15, 0x10, 0xb1, 0x23, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, + 0x31, 0x01, 0x32, 0x16, 0x17, 0x2e, 0x02, 0x23, 0x22, 0x07, 0x27, 0x37, 0x36, 0x33, 0x20, 0x00, 0x11, 0x15, 0x14, + 0x02, 0x06, 0x23, 0x22, 0x00, 0x35, 0x35, 0x34, 0x00, 0x17, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x32, 0x36, + 0x35, 0x35, 0x27, 0x26, 0x26, 0x02, 0x3c, 0x5d, 0xa6, 0x3a, 0x0e, 0x69, 0xa6, 0x60, 0x81, 0x9b, 0x10, 0x31, 0x74, + 0x97, 0x01, 0x07, 0x01, 0x1f, 0x78, 0xde, 0x90, 0xda, 0xfe, 0xf8, 0x01, 0x00, 0xe4, 0x8c, 0x9f, 0x9f, 0x8a, 0x8e, + 0x9f, 0x04, 0x1c, 0xa0, 0x03, 0xfe, 0x4d, 0x44, 0x8c, 0xd9, 0x79, 0x3b, 0x97, 0x15, 0x30, 0xfe, 0x4e, 0xfe, 0x6e, + 0x32, 0xbc, 0xfe, 0xd6, 0xa5, 0x01, 0x23, 0xf6, 0x0e, 0xdc, 0x01, 0x10, 0x98, 0xbb, 0xa0, 0x10, 0xaa, 0xcf, 0xf9, + 0xdb, 0x3d, 0x0f, 0x5a, 0x6a, 0x00, 0x01, 0x00, 0xa9, 0xff, 0x2b, 0x04, 0xe5, 0x05, 0xb0, 0x00, 0x07, 0x00, 0x28, + 0x00, 0xb0, 0x04, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb0, 0x04, + 0x10, 0xb0, 0x01, 0xd0, 0xb0, 0x06, 0x10, 0xb1, 0x02, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0x30, 0x31, 0x05, 0x23, 0x11, 0x21, 0x11, 0x23, 0x11, 0x21, 0x04, 0xe5, 0xb9, 0xfd, 0x36, 0xb9, 0x04, 0x3c, 0xd5, + 0x05, 0xed, 0xfa, 0x13, 0x06, 0x85, 0x00, 0x00, 0x01, 0x00, 0x45, 0xfe, 0xf3, 0x04, 0xab, 0x05, 0xb0, 0x00, 0x0c, + 0x00, 0x37, 0x00, 0xb0, 0x03, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1e, 0x3e, 0x59, + 0xb0, 0x03, 0x10, 0xb1, 0x02, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x05, 0xd0, 0xb0, + 0x08, 0x10, 0xb1, 0x0a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x07, 0xd0, 0x30, 0x31, + 0x01, 0x01, 0x21, 0x15, 0x21, 0x35, 0x01, 0x01, 0x35, 0x21, 0x15, 0x21, 0x01, 0x03, 0x6b, 0xfd, 0xbb, 0x03, 0x85, + 0xfb, 0x9a, 0x02, 0x61, 0xfd, 0x9f, 0x04, 0x19, 0xfc, 0xc7, 0x02, 0x46, 0x02, 0x41, 0xfd, 0x4a, 0x98, 0x8f, 0x02, + 0xcc, 0x02, 0xd2, 0x90, 0x98, 0xfd, 0x42, 0x00, 0x01, 0x00, 0xa8, 0x02, 0x8b, 0x03, 0xeb, 0x03, 0x22, 0x00, 0x03, + 0x00, 0x1c, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x18, 0x3e, 0x59, 0xb1, 0x01, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, 0x35, 0x21, 0x03, 0xeb, 0xfc, 0xbd, + 0x03, 0x43, 0x02, 0x8b, 0x97, 0x00, 0x00, 0x01, 0x00, 0x3f, 0x00, 0x00, 0x04, 0x98, 0x05, 0xb0, 0x00, 0x08, 0x00, + 0x3d, 0xb2, 0x03, 0x09, 0x0a, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x07, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, + 0x1b, 0xb1, 0x01, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x12, 0x3e, 0x59, + 0xb2, 0x00, 0x01, 0x03, 0x11, 0x12, 0x39, 0xb0, 0x07, 0x10, 0xb1, 0x06, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x01, 0x33, 0x01, 0x23, 0x03, 0x23, 0x35, 0x21, 0x02, 0x30, 0x01, 0xab, 0xbd, + 0xfd, 0xe2, 0x8d, 0xf5, 0xb9, 0x01, 0x3b, 0x01, 0x1c, 0x04, 0x94, 0xfa, 0x50, 0x02, 0x74, 0x9a, 0x00, 0x00, 0x03, + 0x00, 0x62, 0xff, 0xeb, 0x07, 0xcb, 0x04, 0x4e, 0x00, 0x1c, 0x00, 0x2c, 0x00, 0x3c, 0x00, 0x71, 0xb2, 0x07, 0x3d, + 0x3e, 0x11, 0x12, 0x39, 0xb0, 0x07, 0x10, 0xb0, 0x24, 0xd0, 0xb0, 0x07, 0x10, 0xb0, 0x34, 0xd0, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, + 0xb1, 0x0a, 0x12, 0x3e, 0x59, 0xb0, 0x13, 0xd0, 0xb0, 0x13, 0x2f, 0xb0, 0x19, 0xd0, 0xb0, 0x19, 0x2f, 0xb2, 0x07, + 0x19, 0x04, 0x11, 0x12, 0x39, 0xb2, 0x16, 0x19, 0x04, 0x11, 0x12, 0x39, 0xb0, 0x0a, 0x10, 0xb1, 0x20, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x13, 0x10, 0xb1, 0x29, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x30, 0xd0, 0xb0, 0x20, 0x10, 0xb0, 0x39, 0xd0, 0x30, 0x31, 0x01, 0x14, 0x02, 0x06, + 0x23, 0x22, 0x26, 0x27, 0x06, 0x06, 0x23, 0x22, 0x26, 0x02, 0x35, 0x35, 0x34, 0x12, 0x36, 0x33, 0x32, 0x16, 0x17, + 0x36, 0x36, 0x33, 0x32, 0x00, 0x15, 0x05, 0x14, 0x16, 0x33, 0x32, 0x36, 0x37, 0x37, 0x35, 0x2e, 0x02, 0x23, 0x22, + 0x06, 0x15, 0x25, 0x34, 0x26, 0x23, 0x22, 0x06, 0x07, 0x07, 0x15, 0x1e, 0x02, 0x33, 0x32, 0x36, 0x35, 0x07, 0xcb, + 0x7e, 0xdf, 0x89, 0x91, 0xee, 0x50, 0x51, 0xec, 0x90, 0x89, 0xde, 0x80, 0x7e, 0xdf, 0x88, 0x91, 0xed, 0x51, 0x50, + 0xef, 0x92, 0xce, 0x01, 0x16, 0xf9, 0x50, 0xa6, 0x88, 0x72, 0xb9, 0x34, 0x0b, 0x18, 0x72, 0x92, 0x50, 0x86, 0xa6, + 0x05, 0xf7, 0xa6, 0x85, 0x73, 0xbc, 0x35, 0x09, 0x16, 0x75, 0x90, 0x50, 0x88, 0xa5, 0x02, 0x0f, 0x93, 0xff, 0x00, + 0x91, 0xb8, 0xb1, 0xb3, 0xb6, 0x8f, 0x01, 0x00, 0x97, 0x18, 0x93, 0x01, 0x00, 0x92, 0xb7, 0xb3, 0xb1, 0xb9, 0xfe, + 0xc1, 0xf3, 0x0d, 0xb1, 0xdc, 0xbc, 0xa3, 0x27, 0x2a, 0x63, 0xc0, 0x61, 0xdc, 0xb9, 0x08, 0xae, 0xdf, 0xbd, 0xa8, + 0x1f, 0x2a, 0x61, 0xc5, 0x60, 0xde, 0xb8, 0x00, 0x01, 0xff, 0xb0, 0xfe, 0x4b, 0x02, 0x8e, 0x06, 0x15, 0x00, 0x15, + 0x00, 0x3f, 0xb2, 0x02, 0x16, 0x17, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0e, 0x2f, 0x1b, 0xb1, + 0x0e, 0x20, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x14, 0x3e, 0x59, 0xb1, 0x08, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0e, 0x10, 0xb1, 0x13, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x05, 0x14, 0x06, 0x23, 0x22, 0x27, 0x37, 0x16, 0x33, 0x32, 0x35, + 0x11, 0x34, 0x36, 0x33, 0x32, 0x17, 0x07, 0x26, 0x23, 0x22, 0x15, 0x01, 0x65, 0xa4, 0x9e, 0x39, 0x3a, 0x12, 0x2e, + 0x21, 0x9b, 0xb1, 0xa1, 0x3c, 0x54, 0x18, 0x25, 0x36, 0xb6, 0x6b, 0xa2, 0xa8, 0x14, 0x91, 0x0d, 0xb1, 0x05, 0x19, + 0xaa, 0xbe, 0x15, 0x8e, 0x0b, 0xdb, 0x00, 0x02, 0x00, 0x65, 0x01, 0x18, 0x04, 0x0b, 0x03, 0xf4, 0x00, 0x15, 0x00, + 0x2b, 0x00, 0x91, 0xb2, 0x1c, 0x2c, 0x2d, 0x11, 0x12, 0x39, 0xb0, 0x1c, 0x10, 0xb0, 0x05, 0xd0, 0x00, 0xb0, 0x03, + 0x2f, 0xb2, 0x0f, 0x03, 0x01, 0x5d, 0xb0, 0x0d, 0xd0, 0xb0, 0x0d, 0x2f, 0xb2, 0x00, 0x0d, 0x01, 0x5d, 0xb1, 0x08, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb0, 0x0a, 0xd0, 0xb0, 0x0a, 0x2f, + 0xb0, 0x03, 0x10, 0xb1, 0x12, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0d, 0x10, 0xb0, + 0x15, 0xd0, 0xb0, 0x15, 0x2f, 0xb0, 0x0d, 0x10, 0xb0, 0x19, 0xd0, 0xb0, 0x19, 0x2f, 0xb0, 0x23, 0xd0, 0xb0, 0x23, + 0x2f, 0xb2, 0x00, 0x23, 0x01, 0x5d, 0xb1, 0x1e, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x19, 0x10, 0xb0, 0x20, 0xd0, 0xb0, 0x20, 0x2f, 0xb0, 0x19, 0x10, 0xb1, 0x28, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x23, 0x10, 0xb0, 0x2b, 0xd0, 0xb0, 0x2b, 0x2f, 0x30, 0x31, 0x13, 0x36, 0x36, 0x33, + 0x36, 0x17, 0x17, 0x16, 0x33, 0x32, 0x37, 0x15, 0x06, 0x23, 0x22, 0x27, 0x27, 0x26, 0x07, 0x22, 0x06, 0x07, 0x07, + 0x36, 0x36, 0x33, 0x36, 0x17, 0x17, 0x16, 0x33, 0x32, 0x37, 0x17, 0x06, 0x23, 0x22, 0x27, 0x27, 0x26, 0x07, 0x22, + 0x06, 0x07, 0x66, 0x30, 0x83, 0x42, 0x52, 0x4a, 0x98, 0x42, 0x4e, 0x86, 0x66, 0x67, 0x85, 0x4e, 0x42, 0xa1, 0x44, + 0x4f, 0x42, 0x83, 0x30, 0x01, 0x30, 0x82, 0x42, 0x52, 0x4a, 0x95, 0x44, 0x50, 0x85, 0x66, 0x01, 0x67, 0x85, 0x4e, + 0x42, 0x98, 0x4a, 0x52, 0x42, 0x83, 0x30, 0x03, 0x85, 0x33, 0x3a, 0x02, 0x23, 0x4e, 0x1f, 0x80, 0xbe, 0x6d, 0x1f, + 0x53, 0x1f, 0x02, 0x44, 0x3c, 0xe5, 0x33, 0x3b, 0x02, 0x23, 0x4d, 0x21, 0x80, 0xbd, 0x6d, 0x1f, 0x4e, 0x23, 0x02, + 0x44, 0x3c, 0x00, 0x00, 0x01, 0x00, 0x98, 0x00, 0x9b, 0x03, 0xda, 0x04, 0xd5, 0x00, 0x13, 0x00, 0x39, 0x00, 0xb0, + 0x13, 0x2f, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0xd0, 0xb0, 0x13, + 0x10, 0xb0, 0x07, 0xd0, 0xb0, 0x13, 0x10, 0xb0, 0x0f, 0xd0, 0xb0, 0x0f, 0x2f, 0xb1, 0x10, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, 0xd0, 0xb0, 0x0f, 0x10, 0xb0, 0x0b, 0xd0, 0x30, 0x31, 0x01, 0x21, + 0x07, 0x27, 0x37, 0x23, 0x35, 0x21, 0x37, 0x21, 0x35, 0x21, 0x13, 0x17, 0x07, 0x33, 0x15, 0x21, 0x07, 0x21, 0x03, + 0xda, 0xfd, 0xed, 0x8e, 0x5f, 0x6c, 0xae, 0x01, 0x0b, 0x95, 0xfe, 0x60, 0x01, 0xfe, 0x99, 0x5f, 0x77, 0xc3, 0xfe, + 0xdf, 0x94, 0x01, 0xb5, 0x01, 0x8f, 0xf4, 0x3b, 0xb9, 0xa0, 0xff, 0xa1, 0x01, 0x06, 0x3b, 0xcb, 0xa1, 0xff, 0x00, + 0xff, 0xff, 0x00, 0x3e, 0x00, 0x02, 0x03, 0x81, 0x04, 0x3d, 0x00, 0x66, 0x00, 0x20, 0x00, 0x61, 0x40, 0x00, 0x39, + 0x9a, 0x01, 0x07, 0x01, 0xaf, 0xff, 0x96, 0xfd, 0x77, 0x00, 0x1d, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, + 0x1b, 0xb1, 0x05, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x12, 0x3e, 0x59, + 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x85, 0x00, 0x01, 0x03, 0xdc, 0x04, 0x50, 0x00, 0x66, 0x00, 0x22, 0x00, 0x73, + 0x40, 0x00, 0x39, 0x9a, 0x01, 0x07, 0x01, 0xaf, 0xff, 0xdd, 0xfd, 0x76, 0x00, 0x1d, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, + 0x12, 0x3e, 0x59, 0x30, 0x31, 0x00, 0x00, 0x02, 0x00, 0x2b, 0x00, 0x00, 0x03, 0xdc, 0x05, 0xb0, 0x00, 0x05, 0x00, + 0x09, 0x00, 0x38, 0xb2, 0x08, 0x0a, 0x0b, 0x11, 0x12, 0x39, 0xb0, 0x08, 0x10, 0xb0, 0x01, 0xd0, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, + 0xb1, 0x03, 0x12, 0x3e, 0x59, 0xb2, 0x06, 0x00, 0x03, 0x11, 0x12, 0x39, 0xb2, 0x08, 0x00, 0x03, 0x11, 0x12, 0x39, + 0x30, 0x31, 0x01, 0x33, 0x01, 0x01, 0x23, 0x09, 0x04, 0x01, 0xbc, 0x8c, 0x01, 0x94, 0xfe, 0x70, 0x8d, 0xfe, 0x6c, + 0x01, 0xd6, 0xfe, 0xe9, 0x01, 0x1c, 0x01, 0x18, 0x05, 0xb0, 0xfd, 0x27, 0xfd, 0x29, 0x02, 0xd7, 0x02, 0x0f, 0xfd, + 0xf1, 0xfd, 0xf2, 0x02, 0x0e, 0x00, 0xff, 0xff, 0x00, 0xb5, 0x00, 0xa7, 0x01, 0x9b, 0x04, 0xf5, 0x00, 0x27, 0x00, + 0x12, 0x00, 0x25, 0x00, 0xb2, 0x00, 0x07, 0x00, 0x12, 0x00, 0x25, 0x04, 0x24, 0x00, 0x02, 0x00, 0x6e, 0x02, 0x79, + 0x02, 0x33, 0x04, 0x3a, 0x00, 0x03, 0x00, 0x07, 0x00, 0x2c, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, + 0xb1, 0x02, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1a, 0x3e, 0x59, 0xb0, + 0x02, 0x10, 0xb0, 0x00, 0xd0, 0xb0, 0x00, 0x2f, 0xb0, 0x04, 0xd0, 0xb0, 0x05, 0xd0, 0x30, 0x31, 0x13, 0x23, 0x11, + 0x33, 0x01, 0x23, 0x11, 0x33, 0xfb, 0x8d, 0x8d, 0x01, 0x38, 0x8d, 0x8d, 0x02, 0x79, 0x01, 0xc1, 0xfe, 0x3f, 0x01, + 0xc1, 0x00, 0x00, 0x01, 0x00, 0x5c, 0xff, 0x5f, 0x01, 0x57, 0x00, 0xef, 0x00, 0x08, 0x00, 0x20, 0xb2, 0x08, 0x09, + 0x0a, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x09, 0x2f, 0xb0, 0x04, 0xd0, 0xb0, 0x04, 0x2f, 0xb4, 0x40, 0x04, 0x50, 0x04, + 0x02, 0x5d, 0xb0, 0x00, 0xd0, 0xb0, 0x00, 0x2f, 0x30, 0x31, 0x17, 0x27, 0x36, 0x37, 0x35, 0x33, 0x15, 0x14, 0x06, + 0xc5, 0x69, 0x48, 0x02, 0xb1, 0x4f, 0xa1, 0x48, 0x6d, 0x7f, 0x5c, 0x4c, 0x5b, 0xb3, 0x00, 0xff, 0xff, 0x00, 0x3c, + 0x00, 0x00, 0x04, 0xf6, 0x06, 0x15, 0x00, 0x26, 0x00, 0x4a, 0x00, 0x00, 0x00, 0x07, 0x00, 0x4a, 0x02, 0x2c, 0x00, + 0x00, 0x00, 0x02, 0x00, 0x1f, 0x00, 0x00, 0x03, 0xcd, 0x06, 0x15, 0x00, 0x15, 0x00, 0x19, 0x00, 0x85, 0xb2, 0x08, + 0x1a, 0x1b, 0x11, 0x12, 0x39, 0xb0, 0x08, 0x10, 0xb0, 0x17, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, + 0x1b, 0xb1, 0x08, 0x20, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1a, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x11, 0x2f, 0x1b, 0xb1, 0x11, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x18, + 0x2f, 0x1b, 0xb1, 0x18, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x16, 0x2f, 0x1b, 0xb1, 0x16, 0x12, 0x3e, 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x01, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, 0x10, 0xb1, 0x0d, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x01, 0x10, 0xb0, 0x13, 0xd0, 0xb0, 0x14, 0xd0, 0x30, 0x31, 0x33, 0x11, + 0x23, 0x35, 0x33, 0x35, 0x34, 0x36, 0x33, 0x32, 0x17, 0x07, 0x26, 0x23, 0x22, 0x06, 0x15, 0x15, 0x33, 0x15, 0x23, + 0x11, 0x21, 0x23, 0x11, 0x33, 0xca, 0xab, 0xab, 0xcf, 0xbd, 0x70, 0xab, 0x1f, 0x7d, 0x71, 0x77, 0x69, 0xdd, 0xdd, + 0x02, 0x49, 0xba, 0xba, 0x03, 0xab, 0x8f, 0x5c, 0xb5, 0xca, 0x3d, 0x9c, 0x32, 0x6b, 0x6b, 0x5e, 0x8f, 0xfc, 0x55, + 0x04, 0x3a, 0x00, 0x01, 0x00, 0x3c, 0x00, 0x00, 0x03, 0xe9, 0x06, 0x15, 0x00, 0x16, 0x00, 0x5e, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x12, 0x2f, 0x1b, 0xb1, 0x12, 0x20, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, + 0xb1, 0x06, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x12, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x16, 0x2f, 0x1b, 0xb1, 0x16, 0x12, 0x3e, 0x59, 0xb0, 0x12, 0x10, 0xb1, 0x02, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x06, 0x10, 0xb1, 0x07, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0b, 0xd0, 0xb0, 0x06, 0x10, 0xb0, 0x0e, 0xd0, 0x30, 0x31, 0x01, 0x26, 0x23, 0x22, + 0x15, 0x15, 0x33, 0x15, 0x23, 0x11, 0x23, 0x11, 0x23, 0x35, 0x33, 0x35, 0x36, 0x36, 0x33, 0x32, 0x05, 0x11, 0x23, + 0x03, 0x30, 0x7c, 0x4c, 0xc8, 0xe7, 0xe7, 0xb9, 0xab, 0xab, 0x01, 0xc0, 0xb1, 0x65, 0x01, 0x2b, 0xb9, 0x05, 0x63, + 0x14, 0xd2, 0x6b, 0x8f, 0xfc, 0x55, 0x03, 0xab, 0x8f, 0x76, 0xad, 0xb8, 0x3d, 0xfa, 0x28, 0x00, 0x00, 0x02, 0x00, + 0x3c, 0x00, 0x00, 0x06, 0x32, 0x06, 0x15, 0x00, 0x27, 0x00, 0x2b, 0x00, 0x9f, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x16, 0x2f, 0x1b, 0xb1, 0x16, 0x20, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x20, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x20, 0x2f, 0x1b, 0xb1, 0x20, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x12, 0x2f, 0x1b, 0xb1, 0x12, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, + 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x2a, 0x2f, 0x1b, 0xb1, 0x2a, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x29, 0x2f, 0x1b, 0xb1, 0x29, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x23, 0x2f, 0x1b, 0xb1, + 0x23, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x27, 0x2f, 0x1b, 0xb1, 0x27, 0x12, 0x3e, 0x59, 0xb0, 0x20, + 0x10, 0xb1, 0x21, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x25, 0xd0, 0xb0, 0x01, 0xd0, + 0xb0, 0x08, 0x10, 0xb1, 0x0d, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x1b, 0xd0, 0x30, + 0x31, 0x33, 0x11, 0x23, 0x35, 0x33, 0x35, 0x34, 0x36, 0x33, 0x32, 0x17, 0x07, 0x26, 0x23, 0x22, 0x06, 0x15, 0x15, + 0x21, 0x35, 0x34, 0x36, 0x33, 0x32, 0x17, 0x07, 0x26, 0x23, 0x22, 0x06, 0x15, 0x15, 0x33, 0x15, 0x23, 0x11, 0x23, + 0x11, 0x21, 0x11, 0x21, 0x23, 0x11, 0x33, 0xe7, 0xab, 0xab, 0xba, 0xaa, 0x40, 0x3f, 0x0a, 0x2f, 0x35, 0x5a, 0x62, + 0x01, 0x90, 0xcf, 0xbd, 0x70, 0xab, 0x1f, 0x7d, 0x72, 0x77, 0x69, 0xde, 0xde, 0xb9, 0xfe, 0x70, 0x04, 0x92, 0xb9, + 0xb9, 0x03, 0xab, 0x8f, 0x6f, 0xae, 0xbe, 0x11, 0x96, 0x09, 0x69, 0x62, 0x72, 0x5c, 0xb5, 0xca, 0x3d, 0x9c, 0x32, + 0x6a, 0x6c, 0x5e, 0x8f, 0xfc, 0x55, 0x03, 0xab, 0xfc, 0x55, 0x04, 0x3a, 0x00, 0x00, 0x01, 0x00, 0x3c, 0x00, 0x00, + 0x06, 0x32, 0x06, 0x15, 0x00, 0x28, 0x00, 0x6c, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, + 0x20, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x21, 0x2f, 0x1b, 0xb1, 0x21, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x28, 0x2f, 0x1b, 0xb1, 0x28, 0x12, 0x3e, 0x59, 0xb0, 0x21, 0x10, 0xb1, 0x22, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x26, 0xd0, 0xb0, 0x01, 0xd0, 0xb0, 0x21, 0x10, 0xb0, 0x12, 0xd0, 0xb0, + 0x04, 0xd0, 0xb0, 0x08, 0x10, 0xb1, 0x0d, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, + 0x10, 0xb0, 0x16, 0xd0, 0xb0, 0x28, 0x10, 0xb0, 0x25, 0xd0, 0xb0, 0x1a, 0xd0, 0xb0, 0x0d, 0x10, 0xb0, 0x1d, 0xd0, + 0x30, 0x31, 0x33, 0x11, 0x23, 0x35, 0x33, 0x35, 0x34, 0x36, 0x33, 0x32, 0x17, 0x07, 0x26, 0x23, 0x22, 0x06, 0x15, + 0x15, 0x21, 0x35, 0x36, 0x36, 0x33, 0x32, 0x05, 0x11, 0x23, 0x11, 0x26, 0x23, 0x22, 0x15, 0x15, 0x33, 0x15, 0x23, + 0x11, 0x23, 0x11, 0x21, 0x11, 0xe7, 0xab, 0xab, 0xba, 0xaa, 0x40, 0x3f, 0x0a, 0x2f, 0x35, 0x5a, 0x62, 0x01, 0x90, + 0x01, 0xc0, 0xb1, 0x65, 0x01, 0x2b, 0xb9, 0x7c, 0x4c, 0xc8, 0xe7, 0xe7, 0xb9, 0xfe, 0x70, 0x03, 0xab, 0x8f, 0x6f, + 0xae, 0xbe, 0x11, 0x96, 0x09, 0x69, 0x62, 0x72, 0x76, 0xad, 0xb8, 0x3d, 0xfa, 0x28, 0x05, 0x63, 0x14, 0xd2, 0x6b, + 0x8f, 0xfc, 0x55, 0x03, 0xab, 0xfc, 0x55, 0x00, 0x01, 0x00, 0x3c, 0xff, 0xec, 0x04, 0x9b, 0x06, 0x15, 0x00, 0x26, + 0x00, 0x76, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x21, 0x2f, 0x1b, 0xb1, 0x21, 0x20, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x1d, 0x2f, 0x1b, 0xb1, 0x1d, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x18, 0x2f, 0x1b, 0xb1, + 0x18, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x12, 0x3e, 0x59, 0xb0, 0x1d, + 0x10, 0xb0, 0x10, 0xd0, 0xb0, 0x25, 0xd0, 0xb1, 0x01, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb0, 0x0a, 0x10, 0xb1, 0x05, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x01, 0x10, 0xb0, + 0x0e, 0xd0, 0xb0, 0x21, 0x10, 0xb1, 0x15, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0e, + 0x10, 0xb0, 0x1a, 0xd0, 0x30, 0x31, 0x01, 0x23, 0x11, 0x14, 0x16, 0x33, 0x32, 0x37, 0x17, 0x06, 0x23, 0x22, 0x26, + 0x35, 0x11, 0x23, 0x35, 0x33, 0x11, 0x26, 0x27, 0x27, 0x22, 0x15, 0x11, 0x23, 0x11, 0x23, 0x35, 0x33, 0x35, 0x34, + 0x36, 0x33, 0x32, 0x16, 0x17, 0x11, 0x33, 0x04, 0x96, 0xca, 0x36, 0x41, 0x23, 0x34, 0x01, 0x49, 0x46, 0x7c, 0x7e, + 0xc5, 0xc5, 0x3d, 0x66, 0x18, 0xb7, 0xb9, 0xab, 0xab, 0xb3, 0xa0, 0x5d, 0xdb, 0x5a, 0xca, 0x03, 0xab, 0xfd, 0x61, + 0x41, 0x41, 0x0c, 0x96, 0x14, 0x96, 0x8a, 0x02, 0x9f, 0x8f, 0x01, 0x1f, 0x1c, 0x07, 0x01, 0xdd, 0xfb, 0x60, 0x03, + 0xab, 0x8f, 0x70, 0xad, 0xbe, 0x39, 0x2c, 0xfe, 0x8a, 0x00, 0x01, 0x00, 0x5f, 0xff, 0xec, 0x06, 0x54, 0x06, 0x11, + 0x00, 0x4c, 0x00, 0xcd, 0xb2, 0x16, 0x4d, 0x4e, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x47, 0x2f, + 0x1b, 0xb1, 0x47, 0x20, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0f, 0x2f, 0x1b, 0xb1, 0x0f, 0x1a, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x4b, 0x2f, 0x1b, 0xb1, 0x4b, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x40, + 0x2f, 0x1b, 0xb1, 0x40, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x12, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x2c, 0x2f, 0x1b, 0xb1, 0x2c, 0x12, 0x3e, 0x59, 0xb0, 0x4b, 0x10, 0xb1, 0x01, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x09, 0x10, 0xb1, 0x04, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x01, 0x10, 0xb0, 0x0d, 0xd0, 0xb0, 0x47, 0x10, 0xb1, 0x14, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x1d, 0x40, 0x2c, 0x11, 0x12, 0x39, 0xb0, 0x40, 0x10, 0xb1, + 0x20, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x3a, 0x2c, 0x40, 0x11, 0x12, 0x39, 0xb0, + 0x3a, 0x10, 0xb1, 0x25, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x31, 0x2c, 0x40, 0x11, + 0x12, 0x39, 0xb0, 0x2c, 0x10, 0xb1, 0x34, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, + 0x01, 0x23, 0x11, 0x14, 0x33, 0x32, 0x37, 0x17, 0x06, 0x23, 0x22, 0x26, 0x35, 0x11, 0x23, 0x35, 0x33, 0x35, 0x34, + 0x26, 0x23, 0x22, 0x06, 0x15, 0x14, 0x1e, 0x02, 0x15, 0x23, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x14, 0x16, 0x04, + 0x16, 0x16, 0x15, 0x14, 0x06, 0x23, 0x22, 0x26, 0x26, 0x35, 0x33, 0x16, 0x16, 0x33, 0x32, 0x36, 0x35, 0x34, 0x26, + 0x24, 0x26, 0x26, 0x35, 0x34, 0x36, 0x33, 0x32, 0x17, 0x26, 0x35, 0x34, 0x36, 0x33, 0x32, 0x16, 0x15, 0x15, 0x33, + 0x06, 0x4f, 0xca, 0x77, 0x23, 0x34, 0x01, 0x4d, 0x42, 0x76, 0x84, 0xbc, 0xbc, 0x66, 0x62, 0x58, 0x5c, 0x1f, 0x25, + 0x1e, 0xba, 0x81, 0x62, 0x65, 0x72, 0x6a, 0x01, 0x15, 0xac, 0x53, 0xe8, 0xb9, 0x82, 0xc8, 0x71, 0xb9, 0x05, 0x8b, + 0x72, 0x69, 0x7f, 0x71, 0xfe, 0xe7, 0xa5, 0x4f, 0xe1, 0xaf, 0x60, 0x56, 0x2c, 0xca, 0x9b, 0xb9, 0xc9, 0xca, 0x03, + 0xab, 0xfd, 0x7e, 0x9f, 0x0c, 0x96, 0x14, 0xa6, 0x97, 0x02, 0x82, 0x8f, 0x55, 0x72, 0x75, 0x58, 0x46, 0x3b, 0x69, + 0x70, 0x7c, 0x4c, 0x4c, 0x6e, 0x58, 0x47, 0x43, 0x44, 0x3e, 0x56, 0x79, 0x57, 0x91, 0xaf, 0x5c, 0xa5, 0x60, 0x5d, + 0x6d, 0x55, 0x47, 0x4b, 0x53, 0x3c, 0x54, 0x74, 0x50, 0x85, 0xb8, 0x1e, 0x6e, 0x52, 0x7c, 0xa5, 0xc7, 0xc3, 0x4d, + 0x00, 0x00, 0x16, 0x00, 0x5b, 0xfe, 0x72, 0x07, 0xee, 0x05, 0xae, 0x00, 0x0d, 0x00, 0x1a, 0x00, 0x28, 0x00, 0x37, + 0x00, 0x3d, 0x00, 0x43, 0x00, 0x49, 0x00, 0x4f, 0x00, 0x56, 0x00, 0x5a, 0x00, 0x5e, 0x00, 0x62, 0x00, 0x66, 0x00, + 0x6a, 0x00, 0x6e, 0x00, 0x76, 0x00, 0x7a, 0x00, 0x7e, 0x00, 0x82, 0x00, 0x86, 0x00, 0x8a, 0x00, 0x8e, 0x01, 0xc6, + 0xb2, 0x10, 0x8f, 0x90, 0x11, 0x12, 0x39, 0xb0, 0x10, 0x10, 0xb0, 0x00, 0xd0, 0xb0, 0x10, 0x10, 0xb0, 0x1b, 0xd0, + 0xb0, 0x10, 0x10, 0xb0, 0x30, 0xd0, 0xb0, 0x10, 0x10, 0xb0, 0x3c, 0xd0, 0xb0, 0x10, 0x10, 0xb0, 0x3e, 0xd0, 0xb0, + 0x10, 0x10, 0xb0, 0x46, 0xd0, 0xb0, 0x10, 0x10, 0xb0, 0x4a, 0xd0, 0xb0, 0x10, 0x10, 0xb0, 0x50, 0xd0, 0xb0, 0x10, + 0x10, 0xb0, 0x57, 0xd0, 0xb0, 0x10, 0x10, 0xb0, 0x5b, 0xd0, 0xb0, 0x10, 0x10, 0xb0, 0x61, 0xd0, 0xb0, 0x10, 0x10, + 0xb0, 0x63, 0xd0, 0xb0, 0x10, 0x10, 0xb0, 0x67, 0xd0, 0xb0, 0x10, 0x10, 0xb0, 0x6d, 0xd0, 0xb0, 0x10, 0x10, 0xb0, + 0x70, 0xd0, 0xb0, 0x10, 0x10, 0xb0, 0x77, 0xd0, 0xb0, 0x10, 0x10, 0xb0, 0x7b, 0xd0, 0xb0, 0x10, 0x10, 0xb0, 0x7f, + 0xd0, 0xb0, 0x10, 0x10, 0xb0, 0x84, 0xd0, 0xb0, 0x10, 0x10, 0xb0, 0x88, 0xd0, 0xb0, 0x10, 0x10, 0xb0, 0x8c, 0xd0, + 0x00, 0xb0, 0x3d, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x46, 0x2f, 0x1b, 0xb1, 0x46, 0x1e, 0x3e, 0x59, 0xb2, 0x7e, + 0x49, 0x03, 0x2b, 0xb2, 0x7a, 0x7b, 0x03, 0x2b, 0xb2, 0x82, 0x77, 0x03, 0x2b, 0xb2, 0x7f, 0x3a, 0x03, 0x2b, 0xb2, + 0x0a, 0x3d, 0x46, 0x11, 0x12, 0x39, 0xb0, 0x0a, 0x2f, 0xb0, 0x03, 0xd0, 0xb0, 0x03, 0x2f, 0xb0, 0x0e, 0xd0, 0xb0, + 0x0e, 0x2f, 0xb0, 0x0a, 0x10, 0xb0, 0x0f, 0xd0, 0xb0, 0x0f, 0x2f, 0xb2, 0x50, 0x0e, 0x0f, 0x11, 0x12, 0x39, 0xb0, + 0x50, 0x2f, 0xb1, 0x6f, 0x07, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x15, 0x50, 0x6f, 0x11, + 0x12, 0x39, 0xb0, 0x0a, 0x10, 0xb1, 0x1e, 0x07, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, + 0x10, 0xb1, 0x25, 0x07, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0f, 0x10, 0xb0, 0x29, 0xd0, + 0xb0, 0x29, 0x2f, 0xb0, 0x0e, 0x10, 0xb0, 0x2e, 0xd0, 0xb0, 0x2e, 0x2f, 0xb1, 0x34, 0x07, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x3d, 0x10, 0xb1, 0x3c, 0x0a, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb0, 0x3d, 0x10, 0xb0, 0x6b, 0xd0, 0xb0, 0x67, 0xd0, 0xb0, 0x63, 0xd0, 0xb0, 0x3e, 0xd0, 0xb0, 0x3c, 0x10, + 0xb0, 0x6c, 0xd0, 0xb0, 0x68, 0xd0, 0xb0, 0x64, 0xd0, 0xb0, 0x3f, 0xd0, 0xb0, 0x3a, 0x10, 0xb0, 0x41, 0xd0, 0xb0, + 0x46, 0x10, 0xb0, 0x60, 0xd0, 0xb0, 0x5c, 0xd0, 0xb0, 0x58, 0xd0, 0xb0, 0x4b, 0xd0, 0xb1, 0x4a, 0x0a, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x5a, 0xd0, 0xb0, 0x5e, 0xd0, 0xb0, 0x62, 0xd0, 0xb0, 0x47, 0xd0, + 0xb0, 0x49, 0x10, 0xb0, 0x4e, 0xd0, 0xb0, 0x0e, 0x10, 0xb1, 0x51, 0x07, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb0, 0x0f, 0x10, 0xb1, 0x76, 0x07, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x77, + 0x10, 0xb0, 0x84, 0xd0, 0xb0, 0x7a, 0x10, 0xb0, 0x85, 0xd0, 0xb0, 0x7b, 0x10, 0xb0, 0x88, 0xd0, 0xb0, 0x7e, 0x10, + 0xb0, 0x89, 0xd0, 0xb0, 0x7f, 0x10, 0xb0, 0x8c, 0xd0, 0xb0, 0x82, 0x10, 0xb0, 0x8d, 0xd0, 0x30, 0x31, 0x01, 0x14, + 0x06, 0x23, 0x22, 0x26, 0x27, 0x35, 0x34, 0x36, 0x33, 0x32, 0x16, 0x17, 0x13, 0x11, 0x33, 0x32, 0x16, 0x15, 0x14, + 0x07, 0x16, 0x16, 0x15, 0x14, 0x23, 0x01, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x32, 0x36, + 0x35, 0x01, 0x33, 0x11, 0x14, 0x06, 0x23, 0x22, 0x26, 0x35, 0x33, 0x14, 0x33, 0x32, 0x36, 0x35, 0x01, 0x11, 0x33, + 0x15, 0x33, 0x15, 0x21, 0x35, 0x33, 0x35, 0x33, 0x11, 0x01, 0x11, 0x21, 0x15, 0x23, 0x15, 0x25, 0x35, 0x21, 0x11, + 0x23, 0x35, 0x01, 0x15, 0x33, 0x32, 0x35, 0x34, 0x27, 0x13, 0x35, 0x21, 0x15, 0x21, 0x35, 0x21, 0x15, 0x21, 0x35, + 0x21, 0x15, 0x01, 0x35, 0x21, 0x15, 0x21, 0x35, 0x21, 0x15, 0x21, 0x35, 0x21, 0x15, 0x13, 0x33, 0x32, 0x35, 0x34, + 0x26, 0x23, 0x23, 0x01, 0x23, 0x35, 0x33, 0x35, 0x23, 0x35, 0x33, 0x11, 0x23, 0x35, 0x33, 0x25, 0x23, 0x35, 0x33, + 0x35, 0x23, 0x35, 0x33, 0x11, 0x23, 0x35, 0x33, 0x03, 0x39, 0x81, 0x64, 0x66, 0x80, 0x02, 0x7e, 0x68, 0x65, 0x80, + 0x02, 0x43, 0xbc, 0x62, 0x72, 0x54, 0x32, 0x34, 0xd0, 0xfe, 0x8f, 0x4a, 0x41, 0x40, 0x4a, 0x4a, 0x42, 0x40, 0x49, + 0x03, 0xba, 0x5c, 0x69, 0x52, 0x58, 0x6d, 0x5d, 0x68, 0x29, 0x36, 0xf9, 0xc4, 0x71, 0xc4, 0x05, 0x28, 0xc7, 0x6f, + 0xf8, 0x6d, 0x01, 0x35, 0xc4, 0x05, 0xec, 0x01, 0x36, 0x6f, 0xfc, 0x5c, 0x7e, 0x67, 0x62, 0xcb, 0x01, 0x16, 0xfd, + 0x5b, 0x01, 0x15, 0xfd, 0x5c, 0x01, 0x14, 0x02, 0x0a, 0x01, 0x16, 0xfd, 0x5b, 0x01, 0x15, 0xfd, 0x5c, 0x01, 0x14, + 0xbc, 0x5d, 0x76, 0x3a, 0x3c, 0x5d, 0xfc, 0xf1, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x07, 0x22, 0x6f, 0x6f, 0x6f, + 0x6f, 0x6f, 0x6f, 0x01, 0xd4, 0x62, 0x79, 0x78, 0x5e, 0x75, 0x5f, 0x7c, 0x78, 0x5e, 0xfe, 0xb3, 0x02, 0x25, 0x49, + 0x4d, 0x54, 0x20, 0x0d, 0x46, 0x2d, 0x9b, 0x01, 0x48, 0x45, 0x4e, 0x4e, 0x45, 0x70, 0x45, 0x4e, 0x4e, 0x45, 0x01, + 0x4f, 0xfe, 0x86, 0x4e, 0x5d, 0x51, 0x53, 0x5b, 0x36, 0x2c, 0xfc, 0xc9, 0x01, 0x3b, 0xca, 0x71, 0x71, 0xca, 0xfe, + 0xc5, 0x06, 0x1f, 0x01, 0x1d, 0x74, 0xa9, 0xa9, 0x74, 0xfe, 0xe3, 0xa9, 0xfc, 0xb6, 0xa9, 0x53, 0x52, 0x04, 0x03, + 0x4a, 0x74, 0x74, 0x74, 0x74, 0x74, 0x74, 0xf9, 0x38, 0x71, 0x71, 0x71, 0x71, 0x71, 0x71, 0x03, 0xc4, 0x50, 0x29, + 0x1e, 0xfe, 0xd3, 0xfc, 0x7e, 0xfa, 0xfc, 0x15, 0xf9, 0x7e, 0xfc, 0x7e, 0xfa, 0xfc, 0x15, 0xf9, 0x00, 0x05, 0x00, + 0x5c, 0xfd, 0xd5, 0x07, 0xd7, 0x08, 0x73, 0x00, 0x03, 0x00, 0x1c, 0x00, 0x20, 0x00, 0x24, 0x00, 0x28, 0x00, 0x52, + 0xb3, 0x11, 0x11, 0x10, 0x04, 0x2b, 0xb3, 0x04, 0x11, 0x1c, 0x04, 0x2b, 0xb3, 0x0a, 0x11, 0x17, 0x04, 0x2b, 0xb0, + 0x04, 0x10, 0xb0, 0x1d, 0xd0, 0xb0, 0x1c, 0x10, 0xb0, 0x1e, 0xd0, 0x00, 0xb0, 0x21, 0x2f, 0xb0, 0x25, 0x2f, 0xb2, + 0x1c, 0x1e, 0x03, 0x2b, 0xb0, 0x25, 0x10, 0xb0, 0x00, 0xd0, 0xb0, 0x00, 0x2f, 0xb0, 0x21, 0x10, 0xb0, 0x02, 0xd0, + 0xb0, 0x02, 0x2f, 0xb2, 0x0d, 0x00, 0x02, 0x11, 0x12, 0x39, 0xb0, 0x0d, 0x2f, 0xb2, 0x1f, 0x1e, 0x02, 0x11, 0x12, + 0x39, 0xb0, 0x1f, 0x2f, 0x30, 0x31, 0x09, 0x03, 0x05, 0x34, 0x36, 0x37, 0x36, 0x36, 0x35, 0x34, 0x26, 0x23, 0x22, + 0x06, 0x07, 0x33, 0x36, 0x36, 0x33, 0x32, 0x16, 0x15, 0x14, 0x07, 0x06, 0x06, 0x15, 0x17, 0x23, 0x15, 0x33, 0x03, + 0x33, 0x15, 0x23, 0x03, 0x33, 0x15, 0x23, 0x04, 0x18, 0x03, 0xbf, 0xfc, 0x41, 0xfc, 0x44, 0x04, 0x0f, 0x1e, 0x24, + 0x4a, 0x5c, 0xa7, 0x95, 0x90, 0xa0, 0x02, 0xcb, 0x02, 0x3a, 0x2b, 0x39, 0x38, 0x5d, 0x5b, 0x2f, 0xca, 0xca, 0xca, + 0x4b, 0x04, 0x04, 0x02, 0x04, 0x04, 0x06, 0x52, 0xfc, 0x31, 0xfc, 0x31, 0x03, 0xcf, 0xf1, 0x3a, 0x3a, 0x18, 0x27, + 0x87, 0x4a, 0x80, 0x97, 0x8b, 0x7f, 0x33, 0x34, 0x40, 0x34, 0x5f, 0x3c, 0x41, 0x5c, 0x4c, 0x5b, 0xaa, 0xfd, 0x4c, + 0x04, 0x0a, 0x9e, 0x04, 0x00, 0x01, 0x00, 0x42, 0x00, 0x00, 0x02, 0xab, 0x03, 0x20, 0x00, 0x16, 0x00, 0x56, 0xb2, + 0x08, 0x17, 0x18, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0e, 0x2f, 0x1b, 0xb1, 0x0e, 0x18, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb1, 0x15, 0x02, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x02, 0xd0, 0xb2, 0x14, 0x15, 0x0e, 0x11, 0x12, 0x39, 0xb2, 0x03, + 0x0e, 0x14, 0x11, 0x12, 0x39, 0xb0, 0x0e, 0x10, 0xb1, 0x08, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb0, 0x0e, 0x10, 0xb0, 0x0b, 0xd0, 0x30, 0x31, 0x21, 0x21, 0x35, 0x01, 0x36, 0x35, 0x34, 0x26, 0x23, 0x22, + 0x06, 0x15, 0x23, 0x34, 0x36, 0x20, 0x16, 0x15, 0x14, 0x0f, 0x02, 0x21, 0x02, 0xab, 0xfd, 0xa9, 0x01, 0x2c, 0x6d, + 0x40, 0x3c, 0x4b, 0x47, 0x9d, 0xa7, 0x01, 0x08, 0x9a, 0x6b, 0x54, 0xb0, 0x01, 0x8f, 0x6c, 0x01, 0x1a, 0x66, 0x45, + 0x31, 0x3d, 0x4c, 0x39, 0x72, 0x94, 0x7f, 0x6e, 0x68, 0x6b, 0x4f, 0x91, 0x00, 0x01, 0x00, 0x7a, 0x00, 0x00, 0x01, + 0xef, 0x03, 0x15, 0x00, 0x06, 0x00, 0x36, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x18, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x12, 0x3e, 0x59, 0xb2, 0x04, 0x05, 0x01, + 0x11, 0x12, 0x39, 0xb0, 0x04, 0x2f, 0xb1, 0x03, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x02, 0xd0, 0x30, 0x31, 0x21, 0x23, 0x11, 0x07, 0x35, 0x25, 0x33, 0x01, 0xef, 0x9d, 0xd8, 0x01, 0x63, 0x12, 0x02, + 0x59, 0x39, 0x80, 0x75, 0x00, 0x00, 0x02, 0x00, 0x50, 0xff, 0xf5, 0x02, 0x9d, 0x03, 0x20, 0x00, 0x0d, 0x00, 0x17, + 0x00, 0x48, 0xb2, 0x03, 0x18, 0x19, 0x11, 0x12, 0x39, 0xb0, 0x03, 0x10, 0xb0, 0x10, 0xd0, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x18, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, + 0x03, 0x12, 0x3e, 0x59, 0xb0, 0x0a, 0x10, 0xb1, 0x10, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb0, 0x03, 0x10, 0xb1, 0x15, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x14, + 0x06, 0x23, 0x22, 0x26, 0x27, 0x35, 0x34, 0x36, 0x33, 0x32, 0x16, 0x17, 0x27, 0x34, 0x23, 0x22, 0x07, 0x15, 0x14, + 0x33, 0x32, 0x37, 0x02, 0x9d, 0x98, 0x8d, 0x8b, 0x9c, 0x01, 0x9b, 0x8b, 0x8d, 0x98, 0x02, 0x9d, 0x8a, 0x85, 0x04, + 0x8b, 0x84, 0x04, 0x01, 0x45, 0xa2, 0xae, 0xac, 0xa0, 0x8e, 0xa3, 0xae, 0xac, 0x9d, 0x07, 0xc0, 0xb4, 0xb3, 0xc2, + 0xb5, 0x00, 0x02, 0x00, 0x55, 0xff, 0xfa, 0x03, 0x9a, 0x04, 0x9d, 0x00, 0x13, 0x00, 0x20, 0x00, 0x54, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, + 0x1b, 0xb1, 0x10, 0x12, 0x3e, 0x59, 0xb2, 0x02, 0x10, 0x08, 0x11, 0x12, 0x39, 0xb0, 0x02, 0x2f, 0xb0, 0x10, 0x10, + 0xb1, 0x11, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x02, 0x10, 0xb1, 0x14, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, 0x10, 0xb1, 0x1b, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x06, 0x23, 0x22, 0x26, 0x35, 0x34, 0x36, 0x33, 0x32, 0x16, 0x15, 0x15, + 0x10, 0x00, 0x05, 0x23, 0x35, 0x33, 0x24, 0x03, 0x32, 0x36, 0x37, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x14, + 0x16, 0x02, 0xdf, 0x65, 0xab, 0xae, 0xcc, 0xe5, 0xba, 0xc6, 0xe0, 0xfe, 0xcc, 0xfe, 0xd4, 0x29, 0x23, 0x01, 0x94, + 0xd7, 0x4f, 0x83, 0x1e, 0x84, 0x69, 0x68, 0x7f, 0x7c, 0x01, 0xec, 0x6e, 0xd7, 0xb0, 0xb4, 0xe4, 0xfe, 0xe2, 0x3f, + 0xfe, 0xc1, 0xfe, 0xc0, 0x05, 0x98, 0x07, 0x01, 0x78, 0x4f, 0x40, 0x42, 0x84, 0x9e, 0x8f, 0x6c, 0x6d, 0x8b, 0x00, + 0x03, 0x00, 0x60, 0xff, 0xf0, 0x03, 0xad, 0x04, 0x9d, 0x00, 0x15, 0x00, 0x21, 0x00, 0x2c, 0x00, 0x65, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x13, 0x2f, 0x1b, 0xb1, 0x13, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, + 0x1b, 0xb1, 0x09, 0x12, 0x3e, 0x59, 0xb0, 0x2a, 0xd0, 0xb0, 0x2a, 0x2f, 0xb2, 0xdf, 0x2a, 0x01, 0x5d, 0xb2, 0x1f, + 0x2a, 0x01, 0x5d, 0xb1, 0x19, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x03, 0x2a, 0x19, + 0x11, 0x12, 0x39, 0xb2, 0x0e, 0x19, 0x2a, 0x11, 0x12, 0x39, 0xb0, 0x09, 0x10, 0xb1, 0x1f, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x13, 0x10, 0xb1, 0x25, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0x30, 0x31, 0x01, 0x14, 0x06, 0x07, 0x16, 0x16, 0x15, 0x14, 0x06, 0x20, 0x26, 0x35, 0x34, 0x36, 0x37, + 0x26, 0x26, 0x35, 0x34, 0x36, 0x20, 0x16, 0x03, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x14, 0x16, 0x33, 0x32, 0x36, + 0x03, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x14, 0x16, 0x32, 0x36, 0x03, 0x90, 0x63, 0x55, 0x62, 0x73, 0xe8, 0xfe, + 0x84, 0xe9, 0x71, 0x62, 0x55, 0x60, 0xd6, 0x01, 0x62, 0xda, 0x9c, 0x83, 0x6c, 0x6b, 0x80, 0x7f, 0x6e, 0x6d, 0x80, + 0x1e, 0x74, 0x5d, 0x5e, 0x6e, 0x6f, 0xbe, 0x70, 0x03, 0x5a, 0x56, 0x87, 0x26, 0x26, 0x93, 0x62, 0x97, 0xb5, 0xb3, + 0x99, 0x63, 0x92, 0x27, 0x26, 0x86, 0x56, 0x94, 0xaf, 0xaf, 0xfd, 0x58, 0x56, 0x6e, 0x6c, 0x58, 0x5b, 0x64, 0x67, + 0x02, 0x65, 0x4e, 0x64, 0x61, 0x51, 0x50, 0x62, 0x63, 0x00, 0x01, 0x00, 0x42, 0x00, 0x00, 0x03, 0xc0, 0x04, 0x8d, + 0x00, 0x06, 0x00, 0x3a, 0xb2, 0x01, 0x07, 0x08, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, + 0x1b, 0xb1, 0x05, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x12, 0x3e, 0x59, + 0xb0, 0x05, 0x10, 0xb1, 0x03, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x00, 0x05, 0x03, + 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x01, 0x23, 0x01, 0x21, 0x35, 0x21, 0x03, 0xc0, 0xfd, 0xe8, 0xc3, 0x02, 0x17, + 0xfd, 0x46, 0x03, 0x7e, 0x04, 0x24, 0xfb, 0xdc, 0x03, 0xf4, 0x99, 0x00, 0x00, 0x02, 0x00, 0x72, 0xff, 0xf0, 0x03, + 0xbb, 0x04, 0x93, 0x00, 0x15, 0x00, 0x20, 0x00, 0x65, 0xb2, 0x07, 0x21, 0x22, 0x11, 0x12, 0x39, 0xb0, 0x07, 0x10, + 0xb0, 0x16, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1c, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x0e, 0x2f, 0x1b, 0xb1, 0x0e, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x10, 0xb1, 0x01, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x08, 0x0e, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x08, 0x2f, 0xb2, 0x05, + 0x08, 0x0e, 0x11, 0x12, 0x39, 0xb1, 0x16, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0e, + 0x10, 0xb1, 0x1c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x15, 0x23, 0x06, + 0x06, 0x07, 0x36, 0x36, 0x33, 0x32, 0x16, 0x15, 0x14, 0x06, 0x23, 0x22, 0x26, 0x35, 0x35, 0x10, 0x00, 0x21, 0x03, + 0x22, 0x06, 0x07, 0x15, 0x14, 0x16, 0x32, 0x36, 0x34, 0x26, 0x03, 0x00, 0x1e, 0xc8, 0xe0, 0x0e, 0x34, 0x96, 0x4e, + 0xae, 0xc9, 0xdf, 0xbe, 0xc2, 0xea, 0x01, 0x40, 0x01, 0x3c, 0xd0, 0x50, 0x83, 0x20, 0x89, 0xd2, 0x7e, 0x7b, 0x04, + 0x93, 0x9c, 0x03, 0xb8, 0xb1, 0x39, 0x3f, 0xd7, 0xae, 0xb0, 0xde, 0xfb, 0xd4, 0x4b, 0x01, 0x3f, 0x01, 0x4a, 0xfd, + 0xd8, 0x4d, 0x40, 0x28, 0x8a, 0xa4, 0x85, 0xd8, 0x86, 0x00, 0x01, 0x00, 0x80, 0xff, 0xf0, 0x03, 0xc5, 0x04, 0x8d, + 0x00, 0x1d, 0x00, 0x6b, 0xb2, 0x1a, 0x1e, 0x1f, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, + 0x1b, 0xb1, 0x01, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x12, 0x3e, 0x59, + 0xb0, 0x01, 0x10, 0xb1, 0x03, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x07, 0x01, 0x0d, + 0x11, 0x12, 0x39, 0xb0, 0x07, 0x2f, 0xb1, 0x1a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, + 0x05, 0x07, 0x1a, 0x11, 0x12, 0x39, 0xb0, 0x0d, 0x10, 0xb0, 0x11, 0xd0, 0xb0, 0x0d, 0x10, 0xb1, 0x14, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x07, 0x10, 0xb0, 0x1d, 0xd0, 0x30, 0x31, 0x13, 0x13, 0x21, + 0x15, 0x21, 0x03, 0x36, 0x33, 0x32, 0x16, 0x15, 0x14, 0x06, 0x23, 0x22, 0x26, 0x27, 0x33, 0x16, 0x16, 0x33, 0x32, + 0x36, 0x35, 0x34, 0x26, 0x23, 0x22, 0x07, 0x07, 0xa4, 0x45, 0x02, 0xa8, 0xfd, 0xf4, 0x25, 0x63, 0x73, 0xb8, 0xd7, + 0xdf, 0xc4, 0xab, 0xea, 0x0d, 0xb2, 0x0e, 0x80, 0x62, 0x70, 0x79, 0x8c, 0x73, 0x69, 0x42, 0x29, 0x02, 0x43, 0x02, + 0x4a, 0xa2, 0xfe, 0xdf, 0x30, 0xd2, 0xb4, 0xb2, 0xd2, 0xb1, 0x97, 0x5b, 0x56, 0x82, 0x71, 0x6a, 0x7f, 0x2a, 0x1b, + 0x00, 0x02, 0x00, 0x30, 0x00, 0x00, 0x03, 0xe4, 0x04, 0x8d, 0x00, 0x0a, 0x00, 0x0e, 0x00, 0x50, 0xb2, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x39, 0xb0, 0x0e, 0x10, 0xb0, 0x09, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, + 0xb1, 0x09, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb2, + 0x01, 0x09, 0x04, 0x11, 0x12, 0x39, 0xb0, 0x01, 0x2f, 0xb1, 0x02, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb0, 0x06, 0xd0, 0xb0, 0x01, 0x10, 0xb0, 0x0b, 0xd0, 0xb2, 0x0d, 0x09, 0x04, 0x11, 0x12, 0x39, 0x30, + 0x31, 0x01, 0x33, 0x15, 0x23, 0x11, 0x23, 0x11, 0x21, 0x27, 0x01, 0x33, 0x01, 0x21, 0x11, 0x07, 0x03, 0x35, 0xaf, + 0xaf, 0xba, 0xfd, 0xb8, 0x03, 0x02, 0x42, 0xc3, 0xfd, 0xc1, 0x01, 0x85, 0x1a, 0x01, 0x9d, 0x97, 0xfe, 0xfa, 0x01, + 0x06, 0x73, 0x03, 0x14, 0xfd, 0x10, 0x01, 0xfc, 0x2f, 0x00, 0x01, 0x00, 0x4e, 0xff, 0xf0, 0x03, 0x9f, 0x04, 0x9d, + 0x00, 0x26, 0x00, 0x8f, 0xb2, 0x20, 0x27, 0x28, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0e, 0x2f, + 0x1b, 0xb1, 0x0e, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x19, 0x2f, 0x1b, 0xb1, 0x19, 0x12, 0x3e, 0x59, + 0xb2, 0x01, 0x0e, 0x19, 0x11, 0x12, 0x39, 0xb0, 0x01, 0x2f, 0xb2, 0xbf, 0x01, 0x01, 0x5d, 0xb4, 0xaf, 0x01, 0xbf, + 0x01, 0x02, 0x71, 0xb4, 0xdf, 0x01, 0xef, 0x01, 0x02, 0x5d, 0xb4, 0x1f, 0x01, 0x2f, 0x01, 0x02, 0x5d, 0xb4, 0x6f, + 0x01, 0x7f, 0x01, 0x02, 0x72, 0xb0, 0x0e, 0x10, 0xb1, 0x07, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb0, 0x0e, 0x10, 0xb0, 0x0a, 0xd0, 0xb0, 0x01, 0x10, 0xb1, 0x25, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb2, 0x14, 0x25, 0x01, 0x11, 0x12, 0x39, 0xb0, 0x19, 0x10, 0xb0, 0x1d, 0xd0, 0xb0, 0x19, 0x10, + 0xb1, 0x20, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x33, 0x32, 0x36, 0x35, + 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x23, 0x34, 0x36, 0x33, 0x32, 0x16, 0x15, 0x14, 0x06, 0x07, 0x16, 0x15, 0x14, + 0x06, 0x23, 0x22, 0x26, 0x35, 0x33, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x34, 0x21, 0x23, 0x01, 0x60, 0x7a, 0x76, + 0x81, 0x6c, 0x70, 0x62, 0x7f, 0xb9, 0xe6, 0xb3, 0xbc, 0xda, 0x65, 0x5b, 0xd5, 0xe9, 0xc1, 0xbd, 0xea, 0xb9, 0x83, + 0x6c, 0x70, 0x7f, 0xfe, 0xec, 0x71, 0x02, 0x9b, 0x63, 0x54, 0x53, 0x60, 0x5b, 0x4d, 0x8c, 0xb4, 0xaf, 0x9c, 0x4f, + 0x89, 0x25, 0x40, 0xd1, 0x9a, 0xba, 0xb3, 0x96, 0x4f, 0x63, 0x62, 0x5b, 0xc3, 0x00, 0x00, 0x01, 0x00, 0x4e, 0x00, + 0x00, 0x03, 0xca, 0x04, 0x9d, 0x00, 0x18, 0x00, 0x56, 0xb2, 0x09, 0x19, 0x1a, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, + 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb1, 0x17, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x02, + 0xd0, 0xb2, 0x03, 0x10, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x10, 0x10, 0xb1, 0x09, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x10, 0x10, 0xb0, 0x0c, 0xd0, 0xb2, 0x16, 0x00, 0x10, 0x11, 0x12, 0x39, 0x30, 0x31, + 0x21, 0x21, 0x35, 0x01, 0x36, 0x36, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x23, 0x34, 0x36, 0x33, 0x32, 0x16, + 0x15, 0x14, 0x06, 0x07, 0x01, 0x21, 0x03, 0xca, 0xfc, 0x9f, 0x01, 0xab, 0x67, 0x5d, 0x74, 0x5e, 0x79, 0x85, 0xba, + 0xf5, 0xc3, 0xb6, 0xd6, 0x63, 0x9b, 0xfe, 0xb8, 0x02, 0x7e, 0x83, 0x01, 0x9d, 0x5e, 0x8b, 0x41, 0x52, 0x69, 0x70, + 0x6b, 0xa5, 0xce, 0xba, 0x95, 0x51, 0xae, 0xa1, 0xfe, 0xe9, 0x00, 0x00, 0x01, 0x00, 0x98, 0x00, 0x00, 0x02, 0x9d, + 0x04, 0x90, 0x00, 0x06, 0x00, 0x41, 0xb2, 0x01, 0x07, 0x08, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, + 0x3e, 0x59, 0xb2, 0x04, 0x00, 0x05, 0x11, 0x12, 0x39, 0xb0, 0x04, 0x2f, 0xb1, 0x03, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x02, 0x03, 0x05, 0x11, 0x12, 0x39, 0x30, 0x31, 0x21, 0x23, 0x11, 0x05, 0x35, + 0x25, 0x33, 0x02, 0x9d, 0xba, 0xfe, 0xb5, 0x01, 0xeb, 0x1a, 0x03, 0xaf, 0x63, 0x9f, 0xa5, 0x00, 0x00, 0x02, 0x00, + 0x63, 0xff, 0xf0, 0x03, 0xab, 0x04, 0x9d, 0x00, 0x0d, 0x00, 0x18, 0x00, 0x48, 0xb2, 0x03, 0x19, 0x1a, 0x11, 0x12, + 0x39, 0xb0, 0x03, 0x10, 0xb0, 0x10, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1c, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x12, 0x3e, 0x59, 0xb0, 0x0a, 0x10, 0xb1, + 0x10, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x16, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x14, 0x02, 0x23, 0x22, 0x02, 0x27, 0x35, 0x34, 0x12, + 0x33, 0x32, 0x12, 0x17, 0x27, 0x10, 0x23, 0x22, 0x11, 0x15, 0x14, 0x16, 0x33, 0x32, 0x11, 0x03, 0xab, 0xd8, 0xcb, + 0xc9, 0xda, 0x02, 0xd9, 0xca, 0xcb, 0xd7, 0x03, 0xba, 0xeb, 0xea, 0x7a, 0x72, 0xe9, 0x01, 0xf1, 0xf8, 0xfe, 0xf7, + 0x01, 0x05, 0xf4, 0xb6, 0xf9, 0x01, 0x05, 0xfe, 0xfe, 0xef, 0x0f, 0x01, 0x49, 0xfe, 0xb3, 0xe1, 0xa7, 0xa8, 0x01, + 0x53, 0x00, 0x01, 0x00, 0x47, 0x00, 0x00, 0x03, 0xe0, 0x04, 0x8d, 0x00, 0x09, 0x00, 0x46, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, + 0x02, 0x12, 0x3e, 0x59, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x04, 0x00, + 0x02, 0x11, 0x12, 0x39, 0xb0, 0x07, 0x10, 0xb1, 0x05, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb2, 0x09, 0x05, 0x07, 0x11, 0x12, 0x39, 0x30, 0x31, 0x25, 0x21, 0x15, 0x21, 0x35, 0x01, 0x21, 0x35, 0x21, 0x15, + 0x01, 0x2f, 0x02, 0xb1, 0xfc, 0x67, 0x02, 0x98, 0xfd, 0x71, 0x03, 0x78, 0x97, 0x97, 0x7c, 0x03, 0x78, 0x99, 0x79, + 0x00, 0x00, 0x01, 0x00, 0x0d, 0x00, 0x00, 0x04, 0x1c, 0x04, 0x8d, 0x00, 0x08, 0x00, 0x31, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, + 0x07, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb2, 0x00, + 0x01, 0x04, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x01, 0x33, 0x01, 0x11, 0x23, 0x11, 0x01, 0x33, 0x02, 0x14, 0x01, + 0x38, 0xd0, 0xfe, 0x52, 0xb9, 0xfe, 0x58, 0xd0, 0x02, 0x4a, 0x02, 0x43, 0xfd, 0x0a, 0xfe, 0x69, 0x01, 0xa2, 0x02, + 0xeb, 0x00, 0x00, 0x01, 0x00, 0x26, 0x00, 0x00, 0x04, 0x31, 0x04, 0x8d, 0x00, 0x0b, 0x00, 0x53, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, + 0xb1, 0x0a, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x12, 0x3e, 0x59, 0xb2, 0x00, 0x01, 0x04, 0x11, 0x12, 0x39, + 0xb2, 0x06, 0x01, 0x04, 0x11, 0x12, 0x39, 0xb2, 0x03, 0x00, 0x06, 0x11, 0x12, 0x39, 0xb2, 0x09, 0x06, 0x00, 0x11, + 0x12, 0x39, 0x30, 0x31, 0x01, 0x01, 0x33, 0x01, 0x01, 0x23, 0x01, 0x01, 0x23, 0x01, 0x01, 0x33, 0x02, 0x28, 0x01, + 0x1f, 0xdc, 0xfe, 0x75, 0x01, 0x99, 0xdc, 0xfe, 0xd5, 0xfe, 0xd8, 0xdc, 0x01, 0x96, 0xfe, 0x73, 0xdb, 0x02, 0xda, + 0x01, 0xb3, 0xfd, 0xbe, 0xfd, 0xb5, 0x01, 0xbb, 0xfe, 0x45, 0x02, 0x4b, 0x02, 0x42, 0x00, 0x00, 0x01, 0x00, 0x31, + 0x00, 0x00, 0x05, 0xf1, 0x04, 0x8d, 0x00, 0x12, 0x00, 0x60, 0xb2, 0x0e, 0x13, 0x14, 0x11, 0x12, 0x39, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, + 0x1b, 0xb1, 0x08, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x11, 0x2f, 0x1b, 0xb1, 0x11, 0x1c, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0f, + 0x2f, 0x1b, 0xb1, 0x0f, 0x12, 0x3e, 0x59, 0xb2, 0x01, 0x03, 0x0a, 0x11, 0x12, 0x39, 0xb2, 0x06, 0x03, 0x0a, 0x11, + 0x12, 0x39, 0xb2, 0x0d, 0x03, 0x0a, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x17, 0x37, 0x13, 0x33, 0x13, 0x17, 0x37, + 0x13, 0x33, 0x01, 0x23, 0x01, 0x27, 0x07, 0x01, 0x23, 0x01, 0x33, 0x01, 0xaf, 0x0b, 0x0f, 0xf8, 0xa5, 0xf4, 0x0d, + 0x0c, 0xc6, 0xb8, 0xfe, 0xd6, 0xae, 0xfe, 0xfc, 0x01, 0x01, 0xfe, 0xf4, 0xad, 0xfe, 0xd7, 0xb7, 0x01, 0x26, 0x50, + 0x40, 0x03, 0x77, 0xfc, 0x86, 0x3b, 0x50, 0x03, 0x65, 0xfb, 0x73, 0x03, 0x95, 0x05, 0x05, 0xfc, 0x6b, 0x04, 0x8d, + 0x00, 0x00, 0x01, 0x00, 0x14, 0x00, 0x00, 0x04, 0x53, 0x04, 0x8d, 0x00, 0x08, 0x00, 0x31, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, + 0x07, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x12, 0x3e, 0x59, 0xb2, 0x01, + 0x03, 0x05, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x17, 0x37, 0x01, 0x33, 0x01, 0x23, 0x01, 0x33, 0x02, 0x1a, 0x19, + 0x1a, 0x01, 0x40, 0xc6, 0xfe, 0x37, 0xad, 0xfe, 0x37, 0xc7, 0x01, 0x24, 0x5e, 0x5c, 0x03, 0x6b, 0xfb, 0x73, 0x04, + 0x8d, 0x00, 0x00, 0x01, 0x00, 0x74, 0xff, 0xf0, 0x04, 0x0a, 0x04, 0x8d, 0x00, 0x11, 0x00, 0x3d, 0xb2, 0x04, 0x12, + 0x13, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1c, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, + 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb1, 0x0d, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, + 0x31, 0x01, 0x11, 0x14, 0x06, 0x23, 0x22, 0x26, 0x27, 0x11, 0x33, 0x11, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x11, + 0x04, 0x0a, 0xfa, 0xd1, 0xd2, 0xf6, 0x03, 0xb7, 0x8f, 0x85, 0x83, 0x8f, 0x04, 0x8d, 0xfc, 0xf4, 0xb6, 0xdb, 0xd3, + 0xb6, 0x03, 0x14, 0xfc, 0xf4, 0x79, 0x81, 0x7f, 0x7b, 0x03, 0x0c, 0x00, 0x00, 0x01, 0x00, 0x28, 0x00, 0x00, 0x03, + 0xfd, 0x04, 0x8d, 0x00, 0x07, 0x00, 0x2f, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1c, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x06, 0x10, 0xb1, + 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0xd0, 0x30, 0x31, 0x01, 0x21, 0x11, + 0x23, 0x11, 0x21, 0x35, 0x21, 0x03, 0xfd, 0xfe, 0x71, 0xb9, 0xfe, 0x73, 0x03, 0xd5, 0x03, 0xf4, 0xfc, 0x0c, 0x03, + 0xf4, 0x99, 0x00, 0x00, 0x01, 0x00, 0x43, 0xff, 0xf0, 0x03, 0xdd, 0x04, 0x9d, 0x00, 0x25, 0x00, 0x5d, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x1c, 0x2f, + 0x1b, 0xb1, 0x1c, 0x12, 0x3e, 0x59, 0xb2, 0x02, 0x1c, 0x09, 0x11, 0x12, 0x39, 0xb0, 0x09, 0x10, 0xb0, 0x0d, 0xd0, + 0xb0, 0x09, 0x10, 0xb1, 0x10, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x02, 0x10, 0xb1, + 0x16, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x1c, 0x10, 0xb0, 0x20, 0xd0, 0xb0, 0x1c, + 0x10, 0xb1, 0x23, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x34, 0x26, 0x24, + 0x27, 0x26, 0x35, 0x34, 0x36, 0x33, 0x32, 0x16, 0x15, 0x23, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x14, 0x16, 0x04, + 0x16, 0x16, 0x15, 0x14, 0x06, 0x23, 0x22, 0x24, 0x35, 0x33, 0x14, 0x16, 0x33, 0x32, 0x36, 0x03, 0x23, 0x79, 0xfe, + 0xda, 0x56, 0xc3, 0xf3, 0xbf, 0xc4, 0xf9, 0xb9, 0x8d, 0x79, 0x71, 0x86, 0x7b, 0x01, 0x38, 0xb0, 0x56, 0xf3, 0xc7, + 0xcf, 0xfe, 0xef, 0xba, 0x9a, 0x8c, 0x7e, 0x82, 0x01, 0x2a, 0x50, 0x58, 0x4a, 0x2b, 0x62, 0xb3, 0x8f, 0xb2, 0xc8, + 0x9c, 0x62, 0x6b, 0x59, 0x50, 0x41, 0x58, 0x50, 0x65, 0x88, 0x5b, 0x93, 0xa9, 0xcb, 0xa2, 0x66, 0x72, 0x5b, 0x00, + 0x00, 0x02, 0x00, 0x8a, 0x00, 0x00, 0x04, 0x25, 0x04, 0x8d, 0x00, 0x0d, 0x00, 0x16, 0x00, 0x63, 0xb2, 0x15, 0x17, + 0x18, 0x11, 0x12, 0x39, 0xb0, 0x15, 0x10, 0xb0, 0x05, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, + 0xb1, 0x04, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x12, 0x3e, 0x59, 0xb2, 0x0f, 0x04, 0x02, 0x11, 0x12, 0x39, + 0xb0, 0x0f, 0x2f, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x0a, 0x00, 0x04, + 0x11, 0x12, 0x39, 0xb0, 0x04, 0x10, 0xb1, 0x15, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, + 0x31, 0x01, 0x21, 0x11, 0x23, 0x11, 0x21, 0x32, 0x16, 0x15, 0x14, 0x07, 0x01, 0x15, 0x23, 0x01, 0x33, 0x32, 0x36, + 0x35, 0x34, 0x26, 0x23, 0x23, 0x02, 0x5a, 0xfe, 0xe9, 0xb9, 0x01, 0xaa, 0xd5, 0xe7, 0xeb, 0x01, 0x20, 0xc6, 0xfd, + 0xe4, 0xf6, 0x75, 0x89, 0x86, 0x7e, 0xf0, 0x01, 0xc1, 0xfe, 0x3f, 0x04, 0x8d, 0xba, 0xaa, 0xe4, 0x59, 0xfe, 0x1e, + 0x0a, 0x02, 0x58, 0x6d, 0x5d, 0x64, 0x6e, 0x00, 0x02, 0x00, 0x59, 0xff, 0x36, 0x04, 0x57, 0x04, 0x9d, 0x00, 0x13, + 0x00, 0x21, 0x00, 0x4f, 0xb2, 0x08, 0x22, 0x23, 0x11, 0x12, 0x39, 0xb0, 0x08, 0x10, 0xb0, 0x1e, 0xd0, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, + 0x1b, 0xb1, 0x08, 0x12, 0x3e, 0x59, 0xb2, 0x03, 0x08, 0x10, 0x11, 0x12, 0x39, 0xb0, 0x10, 0x10, 0xb1, 0x17, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, 0x10, 0xb1, 0x1e, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x14, 0x06, 0x07, 0x17, 0x07, 0x25, 0x06, 0x23, 0x22, 0x00, 0x11, + 0x35, 0x34, 0x12, 0x36, 0x33, 0x32, 0x00, 0x11, 0x27, 0x34, 0x26, 0x23, 0x22, 0x06, 0x07, 0x15, 0x14, 0x16, 0x33, + 0x32, 0x36, 0x35, 0x04, 0x55, 0x70, 0x66, 0xd8, 0x7c, 0xfe, 0xf9, 0x36, 0x46, 0xe4, 0xfe, 0xe5, 0x7f, 0xe8, 0x96, + 0xea, 0x01, 0x15, 0xb7, 0xac, 0x9c, 0x94, 0xac, 0x04, 0xae, 0x98, 0x9c, 0xaa, 0x02, 0x24, 0xa6, 0xf3, 0x46, 0xa0, + 0x6f, 0xc7, 0x0d, 0x01, 0x31, 0x01, 0x08, 0x3e, 0xa9, 0x01, 0x03, 0x8a, 0xfe, 0xcd, 0xfe, 0xf9, 0x06, 0xc6, 0xd2, + 0xcf, 0xb9, 0x55, 0xc2, 0xd8, 0xd3, 0xc7, 0x00, 0x02, 0x00, 0x8a, 0x00, 0x00, 0x04, 0x1b, 0x04, 0x8d, 0x00, 0x0a, + 0x00, 0x13, 0x00, 0x4f, 0xb2, 0x0a, 0x14, 0x15, 0x11, 0x12, 0x39, 0xb0, 0x0a, 0x10, 0xb0, 0x0c, 0xd0, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, + 0x1b, 0xb1, 0x01, 0x12, 0x3e, 0x59, 0xb2, 0x0b, 0x03, 0x01, 0x11, 0x12, 0x39, 0xb0, 0x0b, 0x2f, 0xb1, 0x00, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x12, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x11, 0x23, 0x11, 0x21, 0x32, 0x16, 0x15, 0x14, 0x06, 0x23, 0x25, + 0x21, 0x32, 0x36, 0x35, 0x34, 0x26, 0x27, 0x21, 0x01, 0x43, 0xb9, 0x01, 0xd3, 0xcc, 0xf2, 0xea, 0xd6, 0xfe, 0xe8, + 0x01, 0x1a, 0x7c, 0x88, 0x88, 0x77, 0xfe, 0xe1, 0x01, 0xb6, 0xfe, 0x4a, 0x04, 0x8d, 0xc7, 0xa8, 0xaa, 0xbe, 0x98, + 0x6a, 0x64, 0x60, 0x77, 0x01, 0x00, 0x02, 0x00, 0x60, 0xff, 0xf0, 0x04, 0x5a, 0x04, 0x9d, 0x00, 0x0d, 0x00, 0x1b, + 0x00, 0x48, 0xb2, 0x03, 0x1c, 0x1d, 0x11, 0x12, 0x39, 0xb0, 0x03, 0x10, 0xb0, 0x11, 0xd0, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, + 0x03, 0x12, 0x3e, 0x59, 0xb0, 0x0a, 0x10, 0xb1, 0x11, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb0, 0x03, 0x10, 0xb1, 0x18, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x10, + 0x00, 0x23, 0x22, 0x00, 0x11, 0x35, 0x10, 0x00, 0x33, 0x32, 0x00, 0x17, 0x07, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, + 0x15, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x04, 0x5a, 0xfe, 0xec, 0xe8, 0xe5, 0xfe, 0xe7, 0x01, 0x17, 0xe5, 0xe9, + 0x01, 0x13, 0x02, 0xb7, 0xac, 0x9b, 0x96, 0xaf, 0xb0, 0x97, 0x9c, 0xa9, 0x02, 0x24, 0xfe, 0xfb, 0xfe, 0xd1, 0x01, + 0x32, 0x01, 0x07, 0x3e, 0x01, 0x02, 0x01, 0x34, 0xfe, 0xd0, 0xff, 0x05, 0xc6, 0xd2, 0xd6, 0xc5, 0x42, 0xc3, 0xd7, + 0xd3, 0xc7, 0x00, 0x01, 0x00, 0x8a, 0x00, 0x00, 0x04, 0x58, 0x04, 0x8d, 0x00, 0x09, 0x00, 0x45, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, + 0xb1, 0x08, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x12, 0x3e, 0x59, 0xb2, 0x02, 0x05, 0x00, 0x11, 0x12, 0x39, + 0xb2, 0x07, 0x05, 0x00, 0x11, 0x12, 0x39, 0x30, 0x31, 0x21, 0x23, 0x01, 0x11, 0x23, 0x11, 0x33, 0x01, 0x11, 0x33, + 0x04, 0x58, 0xb8, 0xfd, 0xa3, 0xb9, 0xb9, 0x02, 0x5d, 0xb8, 0x03, 0x6c, 0xfc, 0x94, 0x04, 0x8d, 0xfc, 0x93, 0x03, + 0x6d, 0x00, 0x00, 0x01, 0x00, 0x8a, 0x00, 0x00, 0x05, 0x77, 0x04, 0x8d, 0x00, 0x0e, 0x00, 0x60, 0xb2, 0x01, 0x0f, + 0x10, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1c, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, + 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x12, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x12, 0x3e, 0x59, 0xb2, 0x01, 0x00, 0x04, 0x11, 0x12, + 0x39, 0xb2, 0x07, 0x00, 0x04, 0x11, 0x12, 0x39, 0xb2, 0x0a, 0x00, 0x04, 0x11, 0x12, 0x39, 0x30, 0x31, 0x09, 0x02, + 0x33, 0x11, 0x23, 0x11, 0x13, 0x01, 0x23, 0x01, 0x13, 0x11, 0x23, 0x11, 0x01, 0x7a, 0x01, 0x87, 0x01, 0x85, 0xf1, + 0xb8, 0x13, 0xfe, 0x72, 0x88, 0xfe, 0x73, 0x13, 0xb8, 0x04, 0x8d, 0xfc, 0x71, 0x03, 0x8f, 0xfb, 0x73, 0x01, 0x91, + 0x02, 0x15, 0xfc, 0x5a, 0x03, 0xa2, 0xfd, 0xef, 0xfe, 0x6f, 0x04, 0x8d, 0x00, 0x01, 0x00, 0x8a, 0x00, 0x00, 0x03, + 0x8b, 0x04, 0x8d, 0x00, 0x05, 0x00, 0x29, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1c, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb1, 0x00, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x25, 0x21, 0x15, 0x21, 0x11, 0x33, 0x01, 0x43, 0x02, + 0x48, 0xfc, 0xff, 0xb9, 0x97, 0x97, 0x04, 0x8d, 0x00, 0x01, 0x00, 0x8a, 0x00, 0x00, 0x04, 0x57, 0x04, 0x8d, 0x00, + 0x0c, 0x00, 0x4c, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1c, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, + 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x12, 0x3e, 0x59, 0xb2, + 0x00, 0x02, 0x08, 0x11, 0x12, 0x39, 0xb2, 0x06, 0x02, 0x04, 0x11, 0x12, 0x39, 0xb2, 0x0a, 0x02, 0x08, 0x11, 0x12, + 0x39, 0x30, 0x31, 0x01, 0x07, 0x11, 0x23, 0x11, 0x33, 0x11, 0x37, 0x01, 0x33, 0x01, 0x01, 0x23, 0x01, 0xd6, 0x93, + 0xb9, 0xb9, 0x82, 0x01, 0x8d, 0xe3, 0xfe, 0x21, 0x02, 0x01, 0xe1, 0x02, 0x07, 0x8e, 0xfe, 0x87, 0x04, 0x8d, 0xfd, + 0xd5, 0x90, 0x01, 0x9b, 0xfd, 0xf9, 0xfd, 0x7a, 0x00, 0x00, 0x01, 0x00, 0x2b, 0xff, 0xf0, 0x03, 0x4d, 0x04, 0x8d, + 0x00, 0x0f, 0x00, 0x36, 0xb2, 0x05, 0x10, 0x11, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, + 0x1b, 0xb1, 0x00, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x12, 0x3e, 0x59, + 0xb0, 0x09, 0xd0, 0xb0, 0x05, 0x10, 0xb1, 0x0c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, + 0x31, 0x01, 0x33, 0x11, 0x14, 0x06, 0x23, 0x22, 0x26, 0x35, 0x33, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x02, 0x92, + 0xbb, 0xd4, 0xb1, 0xc2, 0xdb, 0xba, 0x71, 0x72, 0x5c, 0x6e, 0x04, 0x8d, 0xfc, 0xc5, 0x9d, 0xc5, 0xb7, 0xa4, 0x5e, + 0x66, 0x6d, 0x5f, 0x00, 0x01, 0x00, 0x97, 0x00, 0x00, 0x01, 0x51, 0x04, 0x8d, 0x00, 0x03, 0x00, 0x1d, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, + 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0x30, 0x31, 0x21, 0x23, 0x11, 0x33, 0x01, 0x51, 0xba, 0xba, 0x04, 0x8d, 0x00, + 0x00, 0x01, 0x00, 0x8a, 0x00, 0x00, 0x04, 0x58, 0x04, 0x8d, 0x00, 0x0b, 0x00, 0x54, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, + 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb2, 0x09, 0x00, 0x0a, 0x11, 0x12, 0x39, 0x7c, 0xb0, + 0x09, 0x2f, 0x18, 0xb2, 0xa3, 0x09, 0x01, 0x5d, 0xb1, 0x02, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0x30, 0x31, 0x21, 0x23, 0x11, 0x21, 0x11, 0x23, 0x11, 0x33, 0x11, 0x21, 0x11, 0x33, 0x04, 0x58, 0xb9, 0xfd, + 0xa4, 0xb9, 0xb9, 0x02, 0x5c, 0xb9, 0x01, 0xf2, 0xfe, 0x0e, 0x04, 0x8d, 0xfd, 0xfd, 0x02, 0x03, 0x00, 0x01, 0x00, + 0x63, 0xff, 0xf0, 0x04, 0x35, 0x04, 0x9d, 0x00, 0x1d, 0x00, 0x62, 0xb2, 0x0a, 0x1e, 0x1f, 0x11, 0x12, 0x39, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, + 0x2f, 0x1b, 0xb1, 0x03, 0x12, 0x3e, 0x59, 0xb2, 0x1d, 0x0a, 0x03, 0x11, 0x12, 0x39, 0xb0, 0x1d, 0x2f, 0xb2, 0x0d, + 0x1d, 0x0a, 0x11, 0x12, 0x39, 0xb0, 0x0a, 0x10, 0xb1, 0x10, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x17, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x1d, 0x10, + 0xb1, 0x1a, 0x03, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x25, 0x06, 0x06, 0x23, 0x22, + 0x00, 0x27, 0x35, 0x10, 0x00, 0x33, 0x32, 0x16, 0x17, 0x23, 0x26, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, + 0x32, 0x37, 0x35, 0x21, 0x35, 0x21, 0x04, 0x35, 0x42, 0xe9, 0x97, 0xee, 0xfe, 0xe0, 0x02, 0x01, 0x0b, 0xf2, 0xc8, + 0xf2, 0x1b, 0xb8, 0x26, 0xf5, 0x9f, 0xa6, 0xb9, 0xa0, 0xb6, 0x51, 0xfe, 0xe7, 0x01, 0xd1, 0x96, 0x53, 0x53, 0x01, + 0x2a, 0xfc, 0x5a, 0x01, 0x06, 0x01, 0x27, 0xbc, 0xb5, 0xd9, 0xce, 0xc7, 0x54, 0xbe, 0xd7, 0x4a, 0xee, 0x90, 0x00, + 0x01, 0x00, 0x8a, 0x00, 0x00, 0x03, 0x9b, 0x04, 0x8d, 0x00, 0x09, 0x00, 0x43, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, + 0x3e, 0x59, 0xb0, 0x09, 0xd0, 0xb0, 0x09, 0x2f, 0xb2, 0x1f, 0x09, 0x01, 0x5d, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0x10, 0xb1, 0x06, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, 0x11, 0x23, 0x11, 0x21, 0x15, 0x21, 0x11, 0x21, 0x03, 0x4b, 0xfd, 0xf8, 0xb9, + 0x03, 0x11, 0xfd, 0xa8, 0x02, 0x08, 0x01, 0xf3, 0xfe, 0x0d, 0x04, 0x8d, 0x99, 0xfe, 0x98, 0x00, 0x00, 0x01, 0x00, + 0x43, 0xff, 0x13, 0x03, 0xdd, 0x05, 0x73, 0x00, 0x2b, 0x00, 0x69, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, + 0x1b, 0xb1, 0x09, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x22, 0x2f, 0x1b, 0xb1, 0x22, 0x12, 0x3e, 0x59, + 0xb2, 0x02, 0x22, 0x09, 0x11, 0x12, 0x39, 0xb0, 0x09, 0x10, 0xb0, 0x0c, 0xd0, 0xb0, 0x09, 0x10, 0xb0, 0x10, 0xd0, + 0xb0, 0x09, 0x10, 0xb1, 0x13, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x02, 0x10, 0xb1, + 0x19, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x22, 0x10, 0xb0, 0x1f, 0xd0, 0xb0, 0x22, + 0x10, 0xb0, 0x26, 0xd0, 0xb0, 0x22, 0x10, 0xb1, 0x29, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0x30, 0x31, 0x01, 0x34, 0x26, 0x24, 0x27, 0x26, 0x35, 0x34, 0x36, 0x37, 0x35, 0x33, 0x15, 0x16, 0x16, 0x15, 0x23, + 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x14, 0x16, 0x04, 0x16, 0x16, 0x15, 0x14, 0x06, 0x07, 0x15, 0x23, 0x35, 0x26, + 0x26, 0x35, 0x33, 0x14, 0x16, 0x33, 0x32, 0x36, 0x03, 0x23, 0x79, 0xfe, 0xda, 0x56, 0xc3, 0xcb, 0xa6, 0x95, 0xa3, + 0xc6, 0xb9, 0x8d, 0x79, 0x71, 0x86, 0x7b, 0x01, 0x38, 0xb0, 0x56, 0xc3, 0xa9, 0x95, 0xba, 0xdf, 0xba, 0x9a, 0x8c, + 0x7e, 0x82, 0x01, 0x2a, 0x50, 0x58, 0x4a, 0x2b, 0x62, 0xb3, 0x82, 0xac, 0x10, 0xd9, 0xdb, 0x15, 0xc2, 0x88, 0x62, + 0x6b, 0x59, 0x50, 0x41, 0x58, 0x50, 0x65, 0x88, 0x5b, 0x82, 0xa6, 0x10, 0xe1, 0xe1, 0x13, 0xc2, 0x94, 0x66, 0x72, + 0x5b, 0x00, 0x01, 0x00, 0x30, 0x00, 0x00, 0x03, 0xef, 0x04, 0x9d, 0x00, 0x20, 0x00, 0x63, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x14, 0x2f, 0x1b, 0xb1, 0x14, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, + 0x07, 0x12, 0x3e, 0x59, 0xb2, 0x0f, 0x07, 0x14, 0x11, 0x12, 0x39, 0xb0, 0x0f, 0x2f, 0xb1, 0x0e, 0x04, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x01, 0xd0, 0xb0, 0x07, 0x10, 0xb1, 0x04, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, 0xd0, 0xb0, 0x14, 0x10, 0xb0, 0x18, 0xd0, 0xb0, 0x14, 0x10, 0xb1, + 0x1b, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0f, 0x10, 0xb0, 0x1f, 0xd0, 0x30, 0x31, + 0x01, 0x21, 0x17, 0x16, 0x07, 0x21, 0x07, 0x21, 0x35, 0x33, 0x36, 0x37, 0x37, 0x27, 0x23, 0x35, 0x33, 0x27, 0x26, + 0x36, 0x33, 0x32, 0x16, 0x15, 0x23, 0x34, 0x26, 0x23, 0x22, 0x06, 0x17, 0x17, 0x21, 0x03, 0x1d, 0xfe, 0x70, 0x01, + 0x05, 0x38, 0x02, 0x94, 0x01, 0xfc, 0x84, 0x0a, 0x4f, 0x09, 0x01, 0x01, 0xa4, 0xa0, 0x04, 0x06, 0xcb, 0xb5, 0xb7, + 0xca, 0xb9, 0x68, 0x60, 0x5d, 0x68, 0x04, 0x04, 0x01, 0x94, 0x01, 0xf4, 0x22, 0xcb, 0x6f, 0x98, 0x98, 0x17, 0xdd, + 0x46, 0x22, 0x79, 0x7b, 0xc9, 0xec, 0xcc, 0xb7, 0x70, 0x77, 0x8f, 0x8a, 0x7b, 0x00, 0x01, 0x00, 0x0d, 0x00, 0x00, + 0x03, 0x92, 0x04, 0x8d, 0x00, 0x17, 0x00, 0x6d, 0xb2, 0x00, 0x18, 0x19, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, + 0x0c, 0x12, 0x3e, 0x59, 0xb2, 0x00, 0x0c, 0x01, 0x11, 0x12, 0x39, 0xb2, 0x08, 0x01, 0x0c, 0x11, 0x12, 0x39, 0xb0, + 0x08, 0x2f, 0xb0, 0x03, 0xd0, 0xb0, 0x03, 0x2f, 0xb0, 0x05, 0xb0, 0x0a, 0x2b, 0x58, 0xd8, 0x1b, 0xdc, 0x59, 0xb0, + 0x08, 0x10, 0xb0, 0x0a, 0xb0, 0x0a, 0x2b, 0x58, 0xd8, 0x1b, 0xdc, 0x59, 0xb0, 0x0e, 0xd0, 0xb0, 0x08, 0x10, 0xb0, + 0x10, 0xd0, 0xb0, 0x05, 0x10, 0xb0, 0x12, 0xd0, 0xb0, 0x03, 0x10, 0xb0, 0x14, 0xd0, 0xb0, 0x01, 0x10, 0xb0, 0x16, + 0xd0, 0x30, 0x31, 0x01, 0x13, 0x33, 0x01, 0x33, 0x15, 0x21, 0x07, 0x15, 0x21, 0x15, 0x21, 0x15, 0x23, 0x35, 0x21, + 0x35, 0x21, 0x35, 0x21, 0x35, 0x33, 0x01, 0x33, 0x01, 0xd1, 0xfd, 0xc4, 0xfe, 0xd4, 0xd5, 0xfe, 0xf1, 0x03, 0x01, + 0x12, 0xfe, 0xee, 0xb9, 0xfe, 0xee, 0x01, 0x12, 0xfe, 0xee, 0xdb, 0xfe, 0xd4, 0xc7, 0x02, 0x4d, 0x02, 0x40, 0xfd, + 0x8c, 0x79, 0x07, 0x44, 0x78, 0xdd, 0xdd, 0x78, 0x4b, 0x79, 0x02, 0x74, 0x00, 0x00, 0x01, 0x00, 0x8a, 0x00, 0x00, + 0x03, 0x85, 0x04, 0x8d, 0x00, 0x05, 0x00, 0x33, 0xb2, 0x01, 0x06, 0x07, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, + 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x04, 0x10, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0x30, 0x31, 0x01, 0x21, 0x11, 0x23, 0x11, 0x21, 0x03, 0x85, 0xfd, 0xbe, 0xb9, 0x02, 0xfb, 0x03, 0xf4, 0xfc, 0x0c, + 0x04, 0x8d, 0x00, 0x02, 0x00, 0x14, 0x00, 0x00, 0x04, 0x53, 0x04, 0x8d, 0x00, 0x03, 0x00, 0x08, 0x00, 0x3d, 0xb2, + 0x05, 0x09, 0x0a, 0x11, 0x12, 0x39, 0xb0, 0x05, 0x10, 0xb0, 0x02, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, + 0x2f, 0x1b, 0xb1, 0x02, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, + 0x59, 0xb2, 0x05, 0x02, 0x00, 0x11, 0x12, 0x39, 0xb1, 0x07, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0x30, 0x31, 0x21, 0x21, 0x01, 0x33, 0x03, 0x27, 0x07, 0x01, 0x21, 0x04, 0x53, 0xfb, 0xc1, 0x01, 0xc9, 0xad, + 0x3d, 0x1a, 0x19, 0xfe, 0xf8, 0x02, 0x43, 0x04, 0x8d, 0xfe, 0xdd, 0x5c, 0x5e, 0xfd, 0x30, 0x00, 0x03, 0x00, 0x60, + 0xff, 0xf0, 0x04, 0x5a, 0x04, 0x9d, 0x00, 0x03, 0x00, 0x11, 0x00, 0x1f, 0x00, 0x61, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x0e, 0x2f, 0x1b, 0xb1, 0x0e, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, + 0x12, 0x3e, 0x59, 0xb2, 0x02, 0x07, 0x0e, 0x11, 0x12, 0x39, 0x7c, 0xb0, 0x02, 0x2f, 0x18, 0xb4, 0x60, 0x02, 0x70, + 0x02, 0x02, 0x71, 0xb4, 0x60, 0x02, 0x70, 0x02, 0x02, 0x5d, 0xb1, 0x01, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x0e, 0x10, 0xb1, 0x15, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x07, 0x10, 0xb1, 0x1c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, 0x35, + 0x21, 0x05, 0x10, 0x00, 0x23, 0x22, 0x00, 0x11, 0x35, 0x10, 0x00, 0x33, 0x32, 0x00, 0x17, 0x07, 0x34, 0x26, 0x23, + 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x03, 0x55, 0xfe, 0x1f, 0x01, 0xe1, 0x01, 0x05, 0xfe, + 0xec, 0xe8, 0xe5, 0xfe, 0xe7, 0x01, 0x17, 0xe5, 0xe9, 0x01, 0x13, 0x02, 0xb7, 0xac, 0x9b, 0x96, 0xaf, 0xb0, 0x97, + 0x9c, 0xa9, 0x01, 0xf9, 0x99, 0x6e, 0xfe, 0xfb, 0xfe, 0xd1, 0x01, 0x32, 0x01, 0x07, 0x3e, 0x01, 0x02, 0x01, 0x34, + 0xfe, 0xd0, 0xff, 0x05, 0xc6, 0xd2, 0xd6, 0xc5, 0x42, 0xc3, 0xd7, 0xd3, 0xc7, 0x00, 0x00, 0x01, 0x00, 0x14, 0x00, + 0x00, 0x04, 0x53, 0x04, 0x8d, 0x00, 0x08, 0x00, 0x38, 0xb2, 0x07, 0x09, 0x0a, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, + 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb2, + 0x07, 0x02, 0x00, 0x11, 0x12, 0x39, 0x30, 0x31, 0x33, 0x23, 0x01, 0x33, 0x01, 0x23, 0x01, 0x27, 0x07, 0xdb, 0xc7, + 0x01, 0xc9, 0xad, 0x01, 0xc9, 0xc6, 0xfe, 0xc0, 0x1a, 0x19, 0x04, 0x8d, 0xfb, 0x73, 0x03, 0x6a, 0x5c, 0x5e, 0x00, + 0x00, 0x03, 0x00, 0x3e, 0x00, 0x00, 0x03, 0x4b, 0x04, 0x8d, 0x00, 0x03, 0x00, 0x07, 0x00, 0x0b, 0x00, 0x66, 0xb2, + 0x04, 0x0c, 0x0d, 0x11, 0x12, 0x39, 0xb0, 0x04, 0x10, 0xb0, 0x01, 0xd0, 0xb0, 0x04, 0x10, 0xb0, 0x09, 0xd0, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, + 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb1, 0x02, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb2, 0x07, 0x0a, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x07, 0x2f, 0xb2, 0xbf, 0x07, 0x01, 0x5d, 0xb1, 0x04, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0a, 0x10, 0xb1, 0x08, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x21, 0x21, 0x35, 0x21, 0x03, 0x21, 0x35, 0x21, 0x13, 0x21, 0x35, 0x21, 0x03, + 0x4b, 0xfc, 0xf3, 0x03, 0x0d, 0x43, 0xfd, 0x77, 0x02, 0x89, 0x43, 0xfc, 0xf3, 0x03, 0x0d, 0x98, 0x01, 0x7b, 0x98, + 0x01, 0x49, 0x99, 0x00, 0x00, 0x01, 0x00, 0x8a, 0x00, 0x00, 0x04, 0x44, 0x04, 0x8d, 0x00, 0x07, 0x00, 0x40, 0xb2, + 0x01, 0x08, 0x09, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1c, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb0, 0x06, 0x10, 0xb1, 0x02, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x21, 0x23, 0x11, 0x21, 0x11, 0x23, 0x11, 0x21, 0x04, 0x44, 0xba, 0xfd, 0xb9, + 0xb9, 0x03, 0xba, 0x03, 0xf4, 0xfc, 0x0c, 0x04, 0x8d, 0x00, 0x01, 0x00, 0x3f, 0x00, 0x00, 0x03, 0xc8, 0x04, 0x8d, + 0x00, 0x0c, 0x00, 0x45, 0xb2, 0x06, 0x0d, 0x0e, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, + 0x1b, 0xb1, 0x08, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x12, 0x3e, 0x59, + 0xb1, 0x01, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x05, 0xd0, 0xb0, 0x08, 0x10, 0xb1, + 0x0a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x07, 0xd0, 0x30, 0x31, 0x01, 0x01, 0x21, + 0x15, 0x21, 0x35, 0x01, 0x01, 0x35, 0x21, 0x15, 0x21, 0x01, 0x02, 0x6f, 0xfe, 0xb6, 0x02, 0xa3, 0xfc, 0x77, 0x01, + 0x51, 0xfe, 0xaf, 0x03, 0x57, 0xfd, 0x8f, 0x01, 0x4a, 0x02, 0x3a, 0xfe, 0x5f, 0x99, 0x90, 0x01, 0xb7, 0x01, 0xb6, + 0x90, 0x99, 0xfe, 0x5f, 0x00, 0x03, 0x00, 0x60, 0x00, 0x00, 0x05, 0x06, 0x04, 0x8d, 0x00, 0x11, 0x00, 0x17, 0x00, + 0x1e, 0x00, 0x5e, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x1c, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x12, 0x3e, 0x59, 0xb2, 0x0f, 0x10, 0x08, 0x11, 0x12, 0x39, 0xb0, + 0x0f, 0x2f, 0xb0, 0x00, 0xd0, 0xb2, 0x09, 0x08, 0x10, 0x11, 0x12, 0x39, 0xb0, 0x09, 0x2f, 0xb0, 0x06, 0xd0, 0xb0, + 0x09, 0x10, 0xb1, 0x14, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0f, 0x10, 0xb1, 0x15, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x1b, 0xd0, 0xb0, 0x14, 0x10, 0xb0, 0x1c, 0xd0, + 0x30, 0x31, 0x01, 0x16, 0x04, 0x15, 0x14, 0x04, 0x07, 0x15, 0x23, 0x35, 0x26, 0x24, 0x35, 0x34, 0x24, 0x37, 0x35, + 0x33, 0x01, 0x10, 0x05, 0x11, 0x06, 0x06, 0x05, 0x34, 0x26, 0x27, 0x11, 0x36, 0x36, 0x03, 0x10, 0xe6, 0x01, 0x10, + 0xfe, 0xed, 0xe3, 0xb9, 0xea, 0xfe, 0xf3, 0x01, 0x10, 0xe7, 0xb9, 0xfe, 0x08, 0x01, 0x3f, 0x9a, 0xa5, 0x03, 0x36, + 0xa6, 0x98, 0x98, 0xa6, 0x04, 0x16, 0x0d, 0xfa, 0xcb, 0xcd, 0xfc, 0x0d, 0x6e, 0x6e, 0x0d, 0xfd, 0xca, 0xcc, 0xfc, + 0x0d, 0x76, 0xfd, 0xb5, 0xfe, 0xd8, 0x11, 0x02, 0x72, 0x09, 0x96, 0x98, 0x99, 0x95, 0x09, 0xfd, 0x8e, 0x0a, 0x96, + 0x00, 0x00, 0x01, 0x00, 0x60, 0x00, 0x00, 0x04, 0xb6, 0x04, 0x8d, 0x00, 0x15, 0x00, 0x5d, 0xb2, 0x00, 0x16, 0x17, + 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1c, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x0f, 0x2f, 0x1b, 0xb1, 0x0f, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x14, 0x2f, 0x1b, + 0xb1, 0x14, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x12, 0x3e, 0x59, 0xb2, + 0x13, 0x03, 0x09, 0x11, 0x12, 0x39, 0xb0, 0x13, 0x2f, 0xb0, 0x00, 0xd0, 0xb0, 0x13, 0x10, 0xb1, 0x0b, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, 0xd0, 0x30, 0x31, 0x01, 0x24, 0x11, 0x11, 0x33, 0x11, + 0x06, 0x02, 0x07, 0x11, 0x23, 0x11, 0x26, 0x02, 0x27, 0x11, 0x33, 0x11, 0x10, 0x05, 0x11, 0x33, 0x02, 0xe8, 0x01, + 0x15, 0xb9, 0x03, 0xf2, 0xd9, 0xba, 0xd9, 0xf0, 0x05, 0xba, 0x01, 0x14, 0xba, 0x01, 0xbb, 0x33, 0x01, 0x6b, 0x01, + 0x34, 0xfe, 0xbd, 0xf3, 0xfe, 0xe2, 0x18, 0xfe, 0xdf, 0x01, 0x1f, 0x14, 0x01, 0x1d, 0xf2, 0x01, 0x4b, 0xfe, 0xcb, + 0xfe, 0x8e, 0x2d, 0x02, 0xd4, 0x00, 0x00, 0x01, 0x00, 0x75, 0x00, 0x00, 0x04, 0x7e, 0x04, 0x9d, 0x00, 0x21, 0x00, + 0x5e, 0xb2, 0x07, 0x22, 0x23, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x18, 0x2f, 0x1b, 0xb1, 0x18, + 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0f, 0x2f, 0x1b, 0xb1, 0x0f, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x20, 0x2f, 0x1b, 0xb1, 0x20, 0x12, 0x3e, 0x59, 0xb0, 0x0f, 0x10, 0xb1, 0x11, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0e, 0xd0, 0xb0, 0x00, 0xd0, 0xb0, 0x18, 0x10, 0xb1, 0x07, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x11, 0x10, 0xb0, 0x1e, 0xd0, 0xb0, 0x1f, 0xd0, 0x30, 0x31, + 0x25, 0x36, 0x36, 0x35, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x17, 0x15, 0x21, 0x35, 0x33, + 0x26, 0x11, 0x35, 0x34, 0x00, 0x33, 0x32, 0x00, 0x15, 0x15, 0x10, 0x07, 0x33, 0x15, 0x21, 0x02, 0xbb, 0x88, 0x7f, + 0xae, 0x9d, 0x9c, 0xac, 0x8d, 0x7f, 0xfe, 0x3e, 0xaf, 0xb3, 0x01, 0x1b, 0xe7, 0xe8, 0x01, 0x1c, 0xb2, 0xb5, 0xfe, + 0x3d, 0x9d, 0x1f, 0xdf, 0xcd, 0x26, 0xb3, 0xc0, 0xc1, 0xb7, 0x21, 0xcc, 0xdf, 0x20, 0x9d, 0x97, 0x9d, 0x01, 0x3a, + 0x1e, 0xee, 0x01, 0x23, 0xfe, 0xdc, 0xf5, 0x1c, 0xfe, 0xcb, 0x9c, 0x97, 0x00, 0x01, 0x00, 0x26, 0xff, 0xec, 0x05, + 0x2c, 0x04, 0x8d, 0x00, 0x19, 0x00, 0x6e, 0xb2, 0x16, 0x1a, 0x1b, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0e, 0x2f, 0x1b, 0xb1, 0x0e, + 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x18, 0x2f, 0x1b, 0xb1, 0x18, 0x12, 0x3e, 0x59, 0xb0, 0x02, 0x10, + 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0xd0, 0xb0, 0x05, 0xd0, 0xb2, + 0x08, 0x02, 0x0e, 0x11, 0x12, 0x39, 0xb0, 0x08, 0x2f, 0xb0, 0x0e, 0x10, 0xb1, 0x0f, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, 0x10, 0xb1, 0x15, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0x30, 0x31, 0x01, 0x21, 0x35, 0x21, 0x15, 0x21, 0x11, 0x36, 0x33, 0x32, 0x16, 0x15, 0x14, 0x06, 0x23, 0x35, + 0x32, 0x36, 0x35, 0x34, 0x26, 0x23, 0x22, 0x07, 0x11, 0x23, 0x01, 0x8a, 0xfe, 0x9c, 0x03, 0x89, 0xfe, 0x94, 0x97, + 0x9c, 0xd4, 0xe2, 0xe5, 0xe0, 0x8d, 0x7f, 0x7d, 0x80, 0x9d, 0x96, 0xb9, 0x03, 0xf4, 0x99, 0x99, 0xfe, 0xd7, 0x31, + 0xd0, 0xc4, 0xbe, 0xbe, 0x97, 0x6d, 0x78, 0x83, 0x79, 0x32, 0xfd, 0xce, 0x00, 0x01, 0x00, 0x60, 0xff, 0xf0, 0x04, + 0x30, 0x04, 0x9d, 0x00, 0x1e, 0x00, 0x80, 0xb2, 0x03, 0x1f, 0x20, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, + 0x12, 0x3e, 0x59, 0xb2, 0x0f, 0x0b, 0x03, 0x11, 0x12, 0x39, 0xb0, 0x0b, 0x10, 0xb1, 0x12, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x16, 0x0b, 0x03, 0x11, 0x12, 0x39, 0x7c, 0xb0, 0x16, 0x2f, 0x18, 0xb2, + 0xa0, 0x16, 0x01, 0x5d, 0xb4, 0x60, 0x16, 0x70, 0x16, 0x02, 0x5d, 0xb2, 0x30, 0x16, 0x01, 0x71, 0xb4, 0x60, 0x16, + 0x70, 0x16, 0x02, 0x71, 0xb1, 0x17, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, + 0xb1, 0x1b, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x1e, 0x03, 0x0b, 0x11, 0x12, 0x39, + 0x30, 0x31, 0x01, 0x06, 0x06, 0x23, 0x22, 0x00, 0x11, 0x35, 0x34, 0x36, 0x36, 0x33, 0x32, 0x16, 0x17, 0x23, 0x26, + 0x26, 0x23, 0x22, 0x06, 0x07, 0x21, 0x15, 0x21, 0x16, 0x16, 0x33, 0x32, 0x36, 0x37, 0x04, 0x30, 0x14, 0xfc, 0xd1, + 0xe0, 0xfe, 0xf1, 0x7b, 0xe7, 0x98, 0xcc, 0xf7, 0x13, 0xb9, 0x12, 0x8d, 0x7e, 0x99, 0xa2, 0x06, 0x01, 0xbf, 0xfe, + 0x41, 0x04, 0xa1, 0x91, 0x87, 0x8d, 0x14, 0x01, 0x79, 0xbb, 0xce, 0x01, 0x27, 0x01, 0x03, 0x5e, 0xa4, 0xf9, 0x88, + 0xd3, 0xbb, 0x82, 0x74, 0xc3, 0xaf, 0x98, 0xb2, 0xc2, 0x6f, 0x83, 0x00, 0x00, 0x02, 0x00, 0x27, 0x00, 0x00, 0x06, + 0xfb, 0x04, 0x8d, 0x00, 0x17, 0x00, 0x20, 0x00, 0x7a, 0xb2, 0x04, 0x21, 0x22, 0x11, 0x12, 0x39, 0xb0, 0x04, 0x10, + 0xb0, 0x18, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x12, 0x2f, 0x1b, 0xb1, 0x12, 0x1c, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, + 0xb1, 0x0b, 0x12, 0x3e, 0x59, 0xb0, 0x12, 0x10, 0xb1, 0x05, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb0, 0x0b, 0x10, 0xb1, 0x0e, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x14, 0x12, + 0x03, 0x11, 0x12, 0x39, 0xb0, 0x14, 0x2f, 0xb1, 0x18, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb0, 0x03, 0x10, 0xb1, 0x19, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x14, + 0x06, 0x07, 0x21, 0x11, 0x21, 0x03, 0x0e, 0x02, 0x07, 0x23, 0x37, 0x37, 0x36, 0x36, 0x13, 0x13, 0x21, 0x11, 0x21, + 0x16, 0x16, 0x25, 0x11, 0x21, 0x32, 0x36, 0x35, 0x34, 0x26, 0x23, 0x06, 0xfb, 0xe6, 0xc3, 0xfe, 0x2b, 0xfe, 0x5e, + 0x0f, 0x0b, 0x4d, 0x97, 0x7b, 0x3b, 0x04, 0x2e, 0x60, 0x51, 0x0a, 0x14, 0x03, 0x0e, 0x01, 0x24, 0xc1, 0xe0, 0xfd, + 0x3b, 0x01, 0x15, 0x72, 0x84, 0x83, 0x73, 0x01, 0x6e, 0xa5, 0xc7, 0x02, 0x03, 0xf4, 0xfe, 0x65, 0xed, 0xf6, 0x75, + 0x01, 0xa5, 0x01, 0x04, 0xbe, 0x01, 0x09, 0x02, 0x1c, 0xfe, 0x4a, 0x04, 0xc1, 0x2d, 0xfe, 0x59, 0x75, 0x63, 0x5f, + 0x70, 0x00, 0x02, 0x00, 0x8a, 0x00, 0x00, 0x07, 0x09, 0x04, 0x8d, 0x00, 0x12, 0x00, 0x1b, 0x00, 0x8c, 0xb2, 0x01, + 0x1c, 0x1d, 0x11, 0x12, 0x39, 0xb0, 0x01, 0x10, 0xb0, 0x13, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, + 0x1b, 0xb1, 0x02, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x11, 0x2f, 0x1b, 0xb1, 0x11, 0x1c, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0f, + 0x2f, 0x1b, 0xb1, 0x0f, 0x12, 0x3e, 0x59, 0xb2, 0x01, 0x02, 0x0b, 0x11, 0x12, 0x39, 0x7c, 0xb0, 0x01, 0x2f, 0x18, + 0xb2, 0xa0, 0x01, 0x01, 0x5d, 0xb2, 0x04, 0x02, 0x0b, 0x11, 0x12, 0x39, 0xb0, 0x04, 0x2f, 0xb0, 0x01, 0x10, 0xb1, + 0x0d, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0x10, 0xb1, 0x13, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0b, 0x10, 0xb1, 0x14, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, 0x11, 0x33, 0x11, 0x21, 0x16, 0x16, 0x15, 0x14, 0x06, 0x07, 0x21, 0x11, + 0x21, 0x11, 0x23, 0x11, 0x33, 0x01, 0x11, 0x21, 0x32, 0x36, 0x35, 0x34, 0x26, 0x27, 0x01, 0x43, 0x02, 0x48, 0xb9, + 0x01, 0x24, 0xc1, 0xe0, 0xe6, 0xc3, 0xfe, 0x2b, 0xfd, 0xb8, 0xb9, 0xb9, 0x03, 0x01, 0x01, 0x15, 0x73, 0x84, 0x7d, + 0x6e, 0x02, 0x8a, 0x02, 0x03, 0xfe, 0x4a, 0x04, 0xc1, 0xa4, 0xa5, 0xc7, 0x02, 0x01, 0xf2, 0xfe, 0x0e, 0x04, 0x8d, + 0xfd, 0xb2, 0xfe, 0x59, 0x77, 0x61, 0x5b, 0x71, 0x03, 0x00, 0x01, 0x00, 0x28, 0x00, 0x00, 0x05, 0x2e, 0x04, 0x8d, + 0x00, 0x15, 0x00, 0x5c, 0xb2, 0x07, 0x16, 0x17, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, + 0x1b, 0xb1, 0x02, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x12, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x14, 0x2f, 0x1b, 0xb1, 0x14, 0x12, 0x3e, 0x59, 0xb0, 0x02, 0x10, 0xb1, 0x00, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0xd0, 0xb0, 0x05, 0xd0, 0xb2, 0x08, 0x02, 0x0c, + 0x11, 0x12, 0x39, 0xb0, 0x08, 0x2f, 0xb1, 0x11, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, + 0x31, 0x01, 0x21, 0x35, 0x21, 0x15, 0x21, 0x11, 0x36, 0x33, 0x32, 0x16, 0x17, 0x11, 0x23, 0x11, 0x34, 0x26, 0x23, + 0x22, 0x07, 0x11, 0x23, 0x01, 0x8b, 0xfe, 0x9d, 0x03, 0x89, 0xfe, 0x94, 0x93, 0xa0, 0xd4, 0xde, 0x04, 0xba, 0x7d, + 0x7f, 0x9d, 0x96, 0xba, 0x03, 0xf4, 0x99, 0x99, 0xfe, 0xd7, 0x31, 0xca, 0xc1, 0xfe, 0x8f, 0x01, 0x64, 0x87, 0x79, + 0x32, 0xfd, 0xce, 0x00, 0x00, 0x01, 0x00, 0x8a, 0xfe, 0x9b, 0x04, 0x43, 0x04, 0x8d, 0x00, 0x0b, 0x00, 0x50, 0xb2, + 0x03, 0x0c, 0x0d, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x02, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, + 0x06, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1c, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, + 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb1, 0x08, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x09, + 0xd0, 0x30, 0x31, 0x21, 0x21, 0x11, 0x23, 0x11, 0x21, 0x11, 0x33, 0x11, 0x21, 0x11, 0x33, 0x04, 0x43, 0xfe, 0x81, + 0xb9, 0xfe, 0x7f, 0xb9, 0x02, 0x47, 0xb9, 0xfe, 0x9b, 0x01, 0x65, 0x04, 0x8d, 0xfc, 0x0b, 0x03, 0xf5, 0x00, 0x00, + 0x02, 0x00, 0x8a, 0x00, 0x00, 0x04, 0x08, 0x04, 0x8d, 0x00, 0x0c, 0x00, 0x15, 0x00, 0x61, 0xb2, 0x03, 0x16, 0x17, + 0x11, 0x12, 0x39, 0xb0, 0x03, 0x10, 0xb0, 0x0d, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, + 0x0b, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x12, 0x3e, 0x59, 0xb0, 0x0b, + 0x10, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x03, 0x0b, 0x09, 0x11, 0x12, + 0x39, 0xb0, 0x03, 0x2f, 0xb0, 0x09, 0x10, 0xb1, 0x0d, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb0, 0x03, 0x10, 0xb1, 0x13, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, + 0x11, 0x21, 0x32, 0x16, 0x15, 0x14, 0x06, 0x07, 0x21, 0x11, 0x21, 0x01, 0x32, 0x36, 0x35, 0x34, 0x26, 0x27, 0x21, + 0x11, 0x03, 0x95, 0xfd, 0xae, 0x01, 0x11, 0xce, 0xe6, 0xe4, 0xc5, 0xfe, 0x2b, 0x03, 0x0b, 0xfe, 0xc3, 0x73, 0x84, + 0x7d, 0x6e, 0xfe, 0xdf, 0x03, 0xf7, 0xfe, 0xe0, 0xc4, 0xa5, 0xa4, 0xc8, 0x02, 0x04, 0x8d, 0xfc, 0x0b, 0x77, 0x61, + 0x5b, 0x71, 0x03, 0xfe, 0x59, 0x00, 0x00, 0x02, 0x00, 0x2e, 0xfe, 0xac, 0x04, 0xe7, 0x04, 0x8d, 0x00, 0x0f, 0x00, + 0x15, 0x00, 0x5d, 0xb2, 0x13, 0x16, 0x17, 0x11, 0x12, 0x39, 0xb0, 0x13, 0x10, 0xb0, 0x05, 0xd0, 0x00, 0xb0, 0x09, + 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x12, 0x3e, 0x59, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb0, 0x07, 0xd0, 0xb0, 0x08, 0xd0, 0xb0, 0x09, 0x10, 0xb0, 0x0d, 0xd0, 0xb0, 0x08, 0x10, 0xb0, 0x10, 0xd0, + 0xb0, 0x11, 0xd0, 0xb0, 0x05, 0x10, 0xb1, 0x12, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, + 0x31, 0x37, 0x37, 0x36, 0x36, 0x37, 0x13, 0x21, 0x11, 0x33, 0x11, 0x23, 0x11, 0x21, 0x11, 0x23, 0x13, 0x21, 0x21, + 0x11, 0x21, 0x03, 0x02, 0x85, 0x29, 0x47, 0x47, 0x07, 0x0e, 0x03, 0x07, 0x8f, 0xb9, 0xfc, 0xba, 0xba, 0x01, 0x01, + 0x2e, 0x02, 0x42, 0xfe, 0x64, 0x0c, 0x11, 0x98, 0x31, 0x56, 0xfd, 0xd8, 0x01, 0x99, 0xfc, 0x0b, 0xfe, 0x14, 0x01, + 0x54, 0xfe, 0xad, 0x01, 0xeb, 0x03, 0x5c, 0xfe, 0xc8, 0xfe, 0x99, 0x00, 0x01, 0x00, 0x1f, 0x00, 0x00, 0x05, 0xeb, + 0x04, 0x8d, 0x00, 0x15, 0x00, 0x92, 0xb2, 0x01, 0x16, 0x17, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1c, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x11, 0x2f, 0x1b, 0xb1, 0x11, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, + 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x14, 0x2f, 0x1b, 0xb1, 0x14, 0x12, 0x3e, 0x59, 0xb2, 0x10, 0x09, + 0x02, 0x11, 0x12, 0x39, 0x7c, 0xb0, 0x10, 0x2f, 0x18, 0xb2, 0xa0, 0x10, 0x01, 0x5d, 0xb4, 0x60, 0x10, 0x70, 0x10, + 0x02, 0x5d, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0xd0, 0xb2, 0x13, + 0x10, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x13, 0x10, 0xb0, 0x08, 0xd0, 0xb0, 0x10, 0x10, 0xb0, 0x0b, 0xd0, 0x30, 0x31, + 0x01, 0x23, 0x11, 0x23, 0x11, 0x23, 0x01, 0x23, 0x01, 0x01, 0x33, 0x01, 0x33, 0x11, 0x33, 0x11, 0x33, 0x01, 0x33, + 0x01, 0x01, 0x23, 0x03, 0xc5, 0x63, 0xba, 0x64, 0xfe, 0xc5, 0xea, 0x01, 0x86, 0xfe, 0x9e, 0xe0, 0x01, 0x2c, 0x59, + 0xba, 0x59, 0x01, 0x2c, 0xe0, 0xfe, 0x9c, 0x01, 0x88, 0xea, 0x01, 0xf6, 0xfe, 0x0a, 0x01, 0xf6, 0xfe, 0x0a, 0x02, + 0x51, 0x02, 0x3c, 0xfe, 0x03, 0x01, 0xfd, 0xfe, 0x03, 0x01, 0xfd, 0xfd, 0xcd, 0xfd, 0xa6, 0x00, 0x01, 0x00, 0x47, + 0xff, 0xf0, 0x03, 0xd4, 0x04, 0x9d, 0x00, 0x28, 0x00, 0x80, 0xb2, 0x24, 0x29, 0x2a, 0x11, 0x12, 0x39, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x16, 0x2f, + 0x1b, 0xb1, 0x16, 0x12, 0x3e, 0x59, 0xb0, 0x0a, 0x10, 0xb1, 0x03, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb2, 0x06, 0x0a, 0x16, 0x11, 0x12, 0x39, 0xb2, 0x27, 0x0a, 0x16, 0x11, 0x12, 0x39, 0xb0, 0x27, 0x2f, + 0xb4, 0x1f, 0x27, 0x2f, 0x27, 0x02, 0x5d, 0xb2, 0xbf, 0x27, 0x01, 0x5d, 0xb4, 0xdf, 0x27, 0xef, 0x27, 0x02, 0x5d, + 0xb1, 0x24, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x10, 0x24, 0x27, 0x11, 0x12, 0x39, + 0xb2, 0x1c, 0x16, 0x0a, 0x11, 0x12, 0x39, 0xb0, 0x16, 0x10, 0xb1, 0x1f, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x23, 0x34, 0x36, 0x33, 0x32, 0x16, 0x15, + 0x14, 0x06, 0x07, 0x16, 0x16, 0x15, 0x14, 0x06, 0x23, 0x22, 0x26, 0x27, 0x26, 0x35, 0x33, 0x16, 0x16, 0x33, 0x32, + 0x36, 0x35, 0x34, 0x25, 0x23, 0x35, 0x33, 0x36, 0x03, 0x08, 0x8a, 0x7d, 0x6e, 0x81, 0xba, 0xed, 0xbc, 0xd3, 0xee, + 0x6e, 0x67, 0x76, 0x71, 0xfe, 0xd5, 0x5b, 0xa9, 0x3d, 0x79, 0xb9, 0x05, 0x83, 0x79, 0x88, 0x92, 0xfe, 0xff, 0x9d, + 0x9c, 0xef, 0x03, 0x50, 0x54, 0x5d, 0x58, 0x4f, 0x8e, 0xb5, 0xa8, 0x96, 0x56, 0x8d, 0x29, 0x24, 0x92, 0x5b, 0x9e, + 0xb4, 0x2c, 0x2e, 0x59, 0x9d, 0x56, 0x60, 0x60, 0x58, 0xc1, 0x05, 0x98, 0x05, 0x00, 0x00, 0x01, 0x00, 0x8a, 0x00, + 0x00, 0x04, 0x61, 0x04, 0x8d, 0x00, 0x09, 0x00, 0x4c, 0xb2, 0x00, 0x0a, 0x0b, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, + 0xb1, 0x07, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x12, 0x3e, 0x59, 0xb2, 0x04, 0x00, 0x02, 0x11, 0x12, 0x39, + 0xb2, 0x09, 0x00, 0x02, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x33, 0x11, 0x23, 0x11, 0x01, 0x23, 0x11, 0x33, 0x11, + 0x03, 0xa8, 0xb9, 0xb9, 0xfd, 0x9b, 0xb9, 0xb9, 0x04, 0x8d, 0xfb, 0x73, 0x03, 0x74, 0xfc, 0x8c, 0x04, 0x8d, 0xfc, + 0x8c, 0x00, 0x01, 0x00, 0x8b, 0x00, 0x00, 0x04, 0x2c, 0x04, 0x8d, 0x00, 0x0c, 0x00, 0x69, 0xb2, 0x0a, 0x0d, 0x0e, + 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1c, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, + 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x12, 0x3e, 0x59, 0xb2, + 0x06, 0x02, 0x04, 0x11, 0x12, 0x39, 0x7c, 0xb0, 0x06, 0x2f, 0x18, 0xb2, 0xa0, 0x06, 0x01, 0x5d, 0xb4, 0x60, 0x06, + 0x70, 0x06, 0x02, 0x5d, 0xb1, 0x01, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x0a, 0x01, + 0x06, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x23, 0x11, 0x23, 0x11, 0x33, 0x11, 0x33, 0x01, 0x33, 0x01, 0x01, 0x23, + 0x01, 0xae, 0x6a, 0xb9, 0xb9, 0x64, 0x01, 0x85, 0xdf, 0xfe, 0x35, 0x01, 0xeb, 0xef, 0x01, 0xf6, 0xfe, 0x0a, 0x04, + 0x8d, 0xfe, 0x03, 0x01, 0xfd, 0xfd, 0xc5, 0xfd, 0xae, 0x00, 0x01, 0x00, 0x27, 0x00, 0x00, 0x04, 0x36, 0x04, 0x8d, + 0x00, 0x0f, 0x00, 0x4f, 0xb2, 0x04, 0x10, 0x11, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, + 0x1b, 0xb1, 0x00, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x12, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x10, 0xb1, 0x03, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, 0x10, 0xb1, 0x0a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x11, 0x23, 0x11, 0x21, 0x03, 0x02, 0x02, 0x07, 0x23, 0x37, 0x37, + 0x36, 0x36, 0x37, 0x13, 0x04, 0x36, 0xb9, 0xfe, 0x5e, 0x0f, 0x0d, 0xa4, 0xb0, 0x44, 0x04, 0x29, 0x5e, 0x50, 0x0d, + 0x19, 0x04, 0x8d, 0xfb, 0x73, 0x03, 0xf4, 0xfe, 0x82, 0xfe, 0xaa, 0xfe, 0xe5, 0x05, 0xa5, 0x03, 0x07, 0x9e, 0xe2, + 0x02, 0x5e, 0x00, 0x00, 0x01, 0x00, 0x22, 0xff, 0xec, 0x04, 0x0b, 0x04, 0x8d, 0x00, 0x11, 0x00, 0x44, 0xb2, 0x01, + 0x12, 0x13, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1c, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, + 0x2f, 0x1b, 0xb1, 0x08, 0x12, 0x3e, 0x59, 0xb2, 0x01, 0x08, 0x02, 0x11, 0x12, 0x39, 0xb1, 0x0c, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x17, 0x01, 0x33, 0x01, 0x07, 0x06, 0x07, 0x07, 0x22, + 0x27, 0x37, 0x17, 0x32, 0x36, 0x37, 0x01, 0x33, 0x01, 0xf5, 0x2d, 0x01, 0x14, 0xd5, 0xfe, 0x5e, 0x25, 0x50, 0xaa, + 0x26, 0x50, 0x14, 0x06, 0x5c, 0x31, 0x49, 0x20, 0xfe, 0x66, 0xd6, 0x02, 0x30, 0x78, 0x02, 0xd5, 0xfc, 0x45, 0x49, + 0x91, 0x0b, 0x01, 0x08, 0x93, 0x05, 0x31, 0x3b, 0x03, 0x9f, 0x00, 0x01, 0x00, 0x8a, 0xfe, 0xac, 0x04, 0xf1, 0x04, + 0x8d, 0x00, 0x0b, 0x00, 0x46, 0xb2, 0x09, 0x0c, 0x0d, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x02, 0x2f, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, + 0x0a, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb1, 0x00, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, 0xd0, 0xb0, 0x09, 0xd0, 0x30, 0x31, 0x25, + 0x33, 0x03, 0x23, 0x11, 0x21, 0x11, 0x33, 0x11, 0x21, 0x11, 0x33, 0x04, 0x44, 0xad, 0x12, 0xa5, 0xfc, 0x50, 0xb9, + 0x02, 0x47, 0xba, 0x98, 0xfe, 0x14, 0x01, 0x54, 0x04, 0x8d, 0xfc, 0x0b, 0x03, 0xf5, 0x00, 0x01, 0x00, 0x3d, 0x00, + 0x00, 0x03, 0xdf, 0x04, 0x8d, 0x00, 0x11, 0x00, 0x47, 0xb2, 0x04, 0x12, 0x13, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, + 0xb1, 0x10, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb2, + 0x0d, 0x08, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x0d, 0x2f, 0xb1, 0x04, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0x30, 0x31, 0x21, 0x23, 0x11, 0x06, 0x23, 0x22, 0x26, 0x27, 0x11, 0x33, 0x11, 0x14, 0x16, 0x33, 0x32, + 0x37, 0x11, 0x33, 0x03, 0xdf, 0xb9, 0x90, 0xa3, 0xd4, 0xde, 0x04, 0xb9, 0x7e, 0x7f, 0x9d, 0x96, 0xb9, 0x01, 0xc2, + 0x30, 0xca, 0xc1, 0x01, 0x70, 0xfe, 0x9d, 0x87, 0x79, 0x32, 0x02, 0x31, 0x00, 0x00, 0x01, 0x00, 0x8a, 0x00, 0x00, + 0x05, 0xc6, 0x04, 0x8d, 0x00, 0x0b, 0x00, 0x50, 0xb2, 0x05, 0x0c, 0x0d, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, + 0x06, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1c, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb1, 0x04, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, 0xd0, 0xb0, 0x09, 0xd0, 0x30, 0x31, 0x21, 0x21, 0x11, 0x33, 0x11, 0x21, 0x11, + 0x33, 0x11, 0x21, 0x11, 0x33, 0x05, 0xc6, 0xfa, 0xc4, 0xb9, 0x01, 0x88, 0xba, 0x01, 0x88, 0xb9, 0x04, 0x8d, 0xfc, + 0x0b, 0x03, 0xf5, 0xfc, 0x0b, 0x03, 0xf5, 0x00, 0x00, 0x01, 0x00, 0x8a, 0xfe, 0xac, 0x06, 0x75, 0x04, 0x8d, 0x00, + 0x0f, 0x00, 0x59, 0xb2, 0x0b, 0x10, 0x11, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x02, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1c, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0e, 0x2f, 0x1b, 0xb1, 0x0e, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb0, 0x08, 0xd0, 0xb0, 0x09, 0xd0, 0xb0, 0x0c, 0xd0, 0xb0, 0x0d, 0xd0, 0x30, 0x31, 0x25, 0x33, 0x03, + 0x23, 0x11, 0x21, 0x11, 0x33, 0x11, 0x21, 0x11, 0x33, 0x11, 0x21, 0x11, 0x33, 0x05, 0xc7, 0xae, 0x12, 0xa6, 0xfa, + 0xcd, 0xb9, 0x01, 0x88, 0xba, 0x01, 0x88, 0xba, 0x98, 0xfe, 0x14, 0x01, 0x54, 0x04, 0x8d, 0xfc, 0x0b, 0x03, 0xf5, + 0xfc, 0x0b, 0x03, 0xf5, 0x00, 0x02, 0x00, 0x08, 0x00, 0x00, 0x04, 0xd6, 0x04, 0x8d, 0x00, 0x0d, 0x00, 0x16, 0x00, + 0x61, 0xb2, 0x08, 0x17, 0x18, 0x11, 0x12, 0x39, 0xb0, 0x08, 0x10, 0xb0, 0x15, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, + 0x12, 0x3e, 0x59, 0xb0, 0x07, 0x10, 0xb1, 0x05, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, + 0x0a, 0x07, 0x03, 0x11, 0x12, 0x39, 0xb0, 0x0a, 0x2f, 0xb0, 0x03, 0x10, 0xb1, 0x0e, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0a, 0x10, 0xb1, 0x14, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0x30, 0x31, 0x01, 0x14, 0x06, 0x07, 0x21, 0x11, 0x21, 0x35, 0x21, 0x11, 0x21, 0x32, 0x16, 0x16, 0x01, 0x32, + 0x36, 0x35, 0x34, 0x26, 0x23, 0x21, 0x11, 0x04, 0xd6, 0xe4, 0xc4, 0xfe, 0x2a, 0xfe, 0xb0, 0x02, 0x0a, 0x01, 0x16, + 0x84, 0xc2, 0x68, 0xfe, 0x51, 0x72, 0x84, 0x83, 0x73, 0xfe, 0xeb, 0x01, 0x6e, 0xa4, 0xc8, 0x02, 0x03, 0xf4, 0x99, + 0xfe, 0x4a, 0x58, 0xa3, 0xfe, 0xbc, 0x75, 0x63, 0x5f, 0x70, 0xfe, 0x59, 0x00, 0xff, 0xff, 0x00, 0x8a, 0x00, 0x00, + 0x05, 0x67, 0x04, 0x8d, 0x00, 0x26, 0x02, 0x08, 0x00, 0x00, 0x00, 0x07, 0x01, 0xe3, 0x04, 0x16, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x8a, 0x00, 0x00, 0x04, 0x08, 0x04, 0x8d, 0x00, 0x0a, 0x00, 0x13, 0x00, 0x52, 0xb2, 0x08, 0x14, 0x15, + 0x11, 0x12, 0x39, 0xb0, 0x08, 0x10, 0xb0, 0x0b, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, + 0x05, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x12, 0x3e, 0x59, 0xb2, 0x08, + 0x05, 0x03, 0x11, 0x12, 0x39, 0xb0, 0x08, 0x2f, 0xb0, 0x03, 0x10, 0xb1, 0x0b, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, 0x10, 0xb1, 0x11, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0x30, 0x31, 0x01, 0x14, 0x06, 0x07, 0x21, 0x11, 0x33, 0x11, 0x21, 0x32, 0x16, 0x01, 0x32, 0x36, 0x35, 0x34, 0x26, + 0x27, 0x21, 0x11, 0x04, 0x08, 0xe4, 0xc5, 0xfe, 0x2b, 0xb9, 0x01, 0x11, 0xce, 0xe6, 0xfe, 0x50, 0x73, 0x84, 0x7d, + 0x6e, 0xfe, 0xdf, 0x01, 0x6e, 0xa4, 0xc8, 0x02, 0x04, 0x8d, 0xfe, 0x4a, 0xc4, 0xfe, 0x85, 0x77, 0x61, 0x5b, 0x71, + 0x03, 0xfe, 0x59, 0x00, 0x01, 0x00, 0x4b, 0xff, 0xf0, 0x04, 0x1b, 0x04, 0x9d, 0x00, 0x1e, 0x00, 0x7d, 0xb2, 0x03, + 0x1f, 0x20, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x13, 0x2f, 0x1b, 0xb1, 0x13, 0x1c, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x1b, 0x2f, 0x1b, 0xb1, 0x1b, 0x12, 0x3e, 0x59, 0xb2, 0x00, 0x1b, 0x13, 0x11, 0x12, + 0x39, 0xb1, 0x03, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x09, 0x13, 0x1b, 0x11, 0x12, + 0x39, 0x7c, 0xb0, 0x09, 0x2f, 0x18, 0xb2, 0xa0, 0x09, 0x01, 0x5d, 0xb4, 0x60, 0x09, 0x70, 0x09, 0x02, 0x5d, 0xb2, + 0x30, 0x09, 0x01, 0x71, 0xb4, 0x60, 0x09, 0x70, 0x09, 0x02, 0x71, 0xb1, 0x06, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x13, 0x10, 0xb1, 0x0c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb2, 0x0f, 0x13, 0x1b, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x16, 0x16, 0x33, 0x32, 0x36, 0x37, 0x21, 0x35, 0x21, + 0x26, 0x26, 0x23, 0x22, 0x06, 0x07, 0x23, 0x36, 0x36, 0x33, 0x32, 0x00, 0x17, 0x15, 0x14, 0x06, 0x06, 0x23, 0x22, + 0x26, 0x27, 0x01, 0x04, 0x14, 0x8d, 0x87, 0x8d, 0xa2, 0x07, 0xfe, 0x41, 0x01, 0xbe, 0x05, 0xa3, 0x98, 0x7e, 0x8d, + 0x12, 0xb9, 0x13, 0xf7, 0xcc, 0xe4, 0x01, 0x11, 0x05, 0x78, 0xe2, 0x95, 0xcf, 0xfe, 0x14, 0x01, 0x79, 0x83, 0x6f, + 0xbb, 0xb9, 0x98, 0xaf, 0xc3, 0x74, 0x82, 0xbb, 0xd3, 0xfe, 0xdf, 0xf4, 0x75, 0xa3, 0xf9, 0x87, 0xce, 0xbb, 0x00, + 0x02, 0x00, 0x8a, 0xff, 0xf0, 0x06, 0x15, 0x04, 0x9d, 0x00, 0x13, 0x00, 0x21, 0x00, 0x8d, 0xb2, 0x04, 0x22, 0x23, + 0x11, 0x12, 0x39, 0xb0, 0x04, 0x10, 0xb0, 0x18, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, + 0x10, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1c, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, + 0xb1, 0x08, 0x12, 0x3e, 0x59, 0xb2, 0x0d, 0x08, 0x0b, 0x11, 0x12, 0x39, 0x7c, 0xb0, 0x0d, 0x2f, 0x18, 0xb4, 0x60, + 0x0d, 0x70, 0x0d, 0x02, 0x71, 0xb2, 0xa0, 0x0d, 0x01, 0x5d, 0xb4, 0x60, 0x0d, 0x70, 0x0d, 0x02, 0x5d, 0xb1, 0x06, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x10, 0x10, 0xb1, 0x17, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x1e, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0x30, 0x31, 0x01, 0x10, 0x00, 0x23, 0x22, 0x00, 0x27, 0x23, 0x11, 0x23, 0x11, 0x33, 0x11, 0x33, 0x36, + 0x00, 0x33, 0x32, 0x00, 0x17, 0x07, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, + 0x06, 0x15, 0xfe, 0xec, 0xe8, 0xdd, 0xfe, 0xeb, 0x0c, 0xd8, 0xb9, 0xb9, 0xd8, 0x0e, 0x01, 0x14, 0xda, 0xe9, 0x01, + 0x13, 0x02, 0xb7, 0xac, 0x9b, 0x96, 0xaf, 0xb0, 0x97, 0x9c, 0xa9, 0x02, 0x24, 0xfe, 0xfb, 0xfe, 0xd1, 0x01, 0x1c, + 0xf2, 0xfe, 0x02, 0x04, 0x8d, 0xfe, 0x09, 0xf1, 0x01, 0x16, 0xfe, 0xd0, 0xff, 0x05, 0xc6, 0xd2, 0xd6, 0xc5, 0x42, + 0xc3, 0xd7, 0xd3, 0xc7, 0x00, 0x02, 0x00, 0x50, 0x00, 0x00, 0x03, 0xfc, 0x04, 0x8d, 0x00, 0x0d, 0x00, 0x14, 0x00, + 0x63, 0xb2, 0x13, 0x15, 0x16, 0x11, 0x12, 0x39, 0xb0, 0x13, 0x10, 0xb0, 0x07, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, + 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x12, 0x3e, 0x59, 0xb2, 0x11, 0x07, + 0x00, 0x11, 0x12, 0x39, 0xb0, 0x11, 0x2f, 0xb1, 0x0b, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb2, 0x01, 0x0b, 0x07, 0x11, 0x12, 0x39, 0xb0, 0x07, 0x10, 0xb1, 0x12, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x33, 0x01, 0x26, 0x26, 0x35, 0x34, 0x36, 0x37, 0x21, 0x11, 0x23, 0x11, 0x21, 0x03, + 0x13, 0x14, 0x17, 0x21, 0x11, 0x21, 0x22, 0x50, 0x01, 0x22, 0x7a, 0x71, 0xdc, 0xc8, 0x01, 0xd1, 0xb9, 0xfe, 0xd0, + 0xff, 0x2e, 0xe6, 0x01, 0x1b, 0xfe, 0xef, 0xf0, 0x02, 0x0d, 0x26, 0x9d, 0x68, 0xa1, 0xb2, 0x02, 0xfb, 0x73, 0x01, + 0xdf, 0xfe, 0x21, 0x03, 0x30, 0xb4, 0x04, 0x01, 0x7c, 0x00, 0x01, 0x00, 0x0b, 0x00, 0x00, 0x03, 0xe7, 0x04, 0x8d, + 0x00, 0x0d, 0x00, 0x52, 0xb2, 0x01, 0x0e, 0x0f, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, + 0x1b, 0xb1, 0x08, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, + 0xb2, 0x0d, 0x08, 0x02, 0x11, 0x12, 0x39, 0xb0, 0x0d, 0x2f, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0xd0, 0xb0, 0x0d, 0x10, 0xb0, 0x06, 0xd0, 0xb0, 0x08, 0x10, 0xb1, 0x0a, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x23, 0x11, 0x23, 0x11, 0x23, 0x35, 0x33, 0x11, + 0x21, 0x15, 0x21, 0x11, 0x33, 0x02, 0x87, 0xe2, 0xb9, 0xe1, 0xe1, 0x02, 0xfb, 0xfd, 0xbe, 0xe2, 0x01, 0xfd, 0xfe, + 0x03, 0x01, 0xfd, 0x97, 0x01, 0xf9, 0x99, 0xfe, 0xa0, 0x00, 0x00, 0x01, 0x00, 0x1f, 0xfe, 0xac, 0x06, 0x22, 0x04, + 0x8d, 0x00, 0x19, 0x00, 0xac, 0xb2, 0x08, 0x1a, 0x1b, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, + 0x2f, 0x1b, 0xb1, 0x10, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x14, 0x2f, 0x1b, 0xb1, 0x14, 0x1c, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x18, 0x2f, 0x1b, 0xb1, 0x18, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x12, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x12, 0x3e, 0x59, 0xb2, 0x17, 0x0a, 0x18, + 0x11, 0x12, 0x39, 0x7c, 0xb0, 0x17, 0x2f, 0x18, 0xb2, 0xa0, 0x17, 0x01, 0x5d, 0xb4, 0x60, 0x17, 0x70, 0x17, 0x02, + 0x5d, 0xb4, 0x60, 0x17, 0x70, 0x17, 0x02, 0x71, 0xb1, 0x07, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb2, 0x00, 0x07, 0x17, 0x11, 0x12, 0x39, 0xb0, 0x05, 0x10, 0xb1, 0x01, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x07, 0x10, 0xb0, 0x0b, 0xd0, 0xb2, 0x0f, 0x17, 0x07, 0x11, 0x12, 0x39, 0xb0, 0x17, + 0x10, 0xb0, 0x12, 0xd0, 0x30, 0x31, 0x01, 0x01, 0x33, 0x11, 0x23, 0x11, 0x23, 0x01, 0x23, 0x11, 0x23, 0x11, 0x23, + 0x01, 0x23, 0x01, 0x01, 0x33, 0x01, 0x33, 0x11, 0x33, 0x11, 0x33, 0x01, 0x33, 0x04, 0x63, 0x01, 0x26, 0x99, 0xa7, + 0x7a, 0xfe, 0xc4, 0x63, 0xba, 0x64, 0xfe, 0xc5, 0xea, 0x01, 0x86, 0xfe, 0x9e, 0xe0, 0x01, 0x2c, 0x59, 0xba, 0x59, + 0x01, 0x2c, 0xe0, 0x02, 0x5a, 0xfe, 0x3c, 0xfe, 0x16, 0x01, 0x54, 0x01, 0xf6, 0xfe, 0x0a, 0x01, 0xf6, 0xfe, 0x0a, + 0x02, 0x51, 0x02, 0x3c, 0xfe, 0x03, 0x01, 0xfd, 0xfe, 0x03, 0x01, 0xfd, 0x00, 0x01, 0x00, 0x8b, 0xfe, 0xac, 0x04, + 0x4e, 0x04, 0x8d, 0x00, 0x10, 0x00, 0x82, 0xb2, 0x00, 0x11, 0x12, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x03, 0x2f, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0f, 0x2f, + 0x1b, 0xb1, 0x0f, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x12, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x12, 0x3e, 0x59, 0xb2, 0x0d, 0x09, 0x0b, 0x11, 0x12, + 0x39, 0x7c, 0xb0, 0x0d, 0x2f, 0x18, 0xb4, 0x60, 0x0d, 0x70, 0x0d, 0x02, 0x71, 0xb2, 0xa0, 0x0d, 0x01, 0x5d, 0xb4, + 0x60, 0x0d, 0x70, 0x0d, 0x02, 0x5d, 0xb1, 0x08, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, + 0x00, 0x08, 0x0d, 0x11, 0x12, 0x39, 0xb0, 0x05, 0x10, 0xb1, 0x01, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0x30, 0x31, 0x01, 0x01, 0x33, 0x11, 0x23, 0x11, 0x23, 0x01, 0x23, 0x11, 0x23, 0x11, 0x33, 0x11, 0x33, + 0x01, 0x33, 0x02, 0x41, 0x01, 0x6f, 0x9e, 0xa8, 0x69, 0xfe, 0x71, 0x6a, 0xb9, 0xb9, 0x64, 0x01, 0x85, 0xdf, 0x02, + 0x52, 0xfe, 0x44, 0xfe, 0x16, 0x01, 0x54, 0x01, 0xf6, 0xfe, 0x0a, 0x04, 0x8d, 0xfe, 0x03, 0x01, 0xfd, 0x00, 0x00, + 0x01, 0x00, 0x8b, 0x00, 0x00, 0x04, 0xe7, 0x04, 0x8d, 0x00, 0x14, 0x00, 0x79, 0xb2, 0x0b, 0x15, 0x16, 0x11, 0x12, + 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x13, 0x2f, 0x1b, 0xb1, 0x13, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, + 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x11, 0x2f, 0x1b, 0xb1, 0x11, 0x12, 0x3e, 0x59, 0xb2, 0x00, 0x11, + 0x13, 0x11, 0x12, 0x39, 0x7c, 0xb0, 0x00, 0x2f, 0x18, 0xb2, 0xa0, 0x00, 0x01, 0x5d, 0xb4, 0x60, 0x00, 0x70, 0x00, + 0x02, 0x5d, 0xb4, 0x60, 0x00, 0x70, 0x00, 0x02, 0x71, 0xb0, 0x04, 0xd0, 0xb0, 0x00, 0x10, 0xb1, 0x10, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x08, 0x10, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x0c, 0xd0, 0x30, + 0x31, 0x01, 0x33, 0x35, 0x33, 0x15, 0x33, 0x01, 0x33, 0x01, 0x01, 0x23, 0x01, 0x23, 0x15, 0x23, 0x35, 0x23, 0x11, + 0x23, 0x11, 0x33, 0x01, 0x44, 0x50, 0x94, 0x3c, 0x01, 0x84, 0xe0, 0xfe, 0x34, 0x01, 0xeb, 0xef, 0xfe, 0x71, 0x41, + 0x94, 0x50, 0xb9, 0xb9, 0x02, 0x90, 0xe4, 0xe4, 0x01, 0xfd, 0xfd, 0xc5, 0xfd, 0xae, 0x01, 0xf6, 0xce, 0xce, 0xfe, + 0x0a, 0x04, 0x8d, 0x00, 0x01, 0x00, 0x23, 0x00, 0x00, 0x05, 0x15, 0x04, 0x8d, 0x00, 0x0e, 0x00, 0x7f, 0xb2, 0x00, + 0x0f, 0x10, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1c, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, + 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x12, 0x3e, + 0x59, 0xb2, 0x08, 0x02, 0x06, 0x11, 0x12, 0x39, 0x7c, 0xb0, 0x08, 0x2f, 0x18, 0xb2, 0xa0, 0x08, 0x01, 0x5d, 0xb4, + 0x60, 0x08, 0x70, 0x08, 0x02, 0x5d, 0xb4, 0x60, 0x08, 0x70, 0x08, 0x02, 0x71, 0xb1, 0x01, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x06, 0x10, 0xb1, 0x04, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb2, 0x0c, 0x01, 0x08, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x23, 0x11, 0x23, 0x11, 0x21, 0x35, 0x21, + 0x11, 0x33, 0x01, 0x33, 0x01, 0x01, 0x23, 0x02, 0x97, 0x69, 0xba, 0xfe, 0xaf, 0x02, 0x0b, 0x63, 0x01, 0x85, 0xe0, + 0xfe, 0x34, 0x01, 0xeb, 0xef, 0x01, 0xf6, 0xfe, 0x0a, 0x03, 0xf5, 0x98, 0xfe, 0x03, 0x01, 0xfd, 0xfd, 0xc5, 0xfd, + 0xae, 0x00, 0x02, 0x00, 0x60, 0xff, 0xeb, 0x05, 0x5b, 0x04, 0x9f, 0x00, 0x23, 0x00, 0x2e, 0x00, 0x98, 0xb2, 0x14, + 0x2f, 0x30, 0x11, 0x12, 0x39, 0xb0, 0x14, 0x10, 0xb0, 0x24, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, + 0x1b, 0xb1, 0x0b, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x1b, 0x2f, 0x1b, 0xb1, 0x1b, 0x1c, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, + 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb2, 0x02, 0x04, 0x1b, 0x11, 0x12, 0x39, 0xb0, 0x02, 0x2f, 0xb0, 0x0b, + 0x10, 0xb1, 0x0c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0x10, 0xb1, 0x13, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x02, 0x10, 0xb1, 0x26, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x15, 0x13, 0x26, 0x11, 0x12, 0x39, 0xb2, 0x21, 0x02, 0x26, 0x11, 0x12, 0x39, + 0xb0, 0x1b, 0x10, 0xb1, 0x2c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x05, 0x22, + 0x27, 0x06, 0x23, 0x20, 0x00, 0x11, 0x35, 0x10, 0x12, 0x33, 0x17, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x33, 0x32, + 0x37, 0x26, 0x03, 0x35, 0x34, 0x12, 0x33, 0x32, 0x12, 0x15, 0x15, 0x10, 0x07, 0x16, 0x33, 0x01, 0x10, 0x17, 0x36, + 0x11, 0x35, 0x34, 0x26, 0x23, 0x22, 0x03, 0x05, 0x5b, 0xd9, 0xa6, 0x89, 0xa3, 0xfe, 0xea, 0xfe, 0xc6, 0xf4, 0xd2, + 0x01, 0x7e, 0x90, 0xd0, 0xc7, 0x36, 0x32, 0xe3, 0x01, 0xcf, 0xb5, 0xb8, 0xcd, 0xb6, 0x5e, 0x76, 0xfd, 0x92, 0xe1, + 0xb6, 0x62, 0x6a, 0xc6, 0x05, 0x14, 0x3b, 0x3c, 0x01, 0x45, 0x01, 0x2a, 0x1a, 0x01, 0x03, 0x01, 0x28, 0x9e, 0xc3, + 0xc8, 0x21, 0xe8, 0xe5, 0x08, 0xb2, 0x01, 0x45, 0x27, 0xeb, 0x01, 0x04, 0xfe, 0xff, 0xf1, 0x38, 0xfe, 0xda, 0xb2, + 0x12, 0x01, 0xfd, 0xfe, 0xcc, 0x79, 0x81, 0x01, 0x1e, 0x38, 0xac, 0xa3, 0xfe, 0xc3, 0xff, 0xff, 0x00, 0x0d, 0x00, + 0x00, 0x04, 0x1c, 0x04, 0x8d, 0x00, 0x26, 0x01, 0xd3, 0x00, 0x00, 0x01, 0x07, 0x02, 0x26, 0x00, 0x44, 0xfe, 0xde, + 0x00, 0x08, 0x00, 0xb2, 0x00, 0x0a, 0x01, 0x5d, 0x30, 0x31, 0x00, 0x01, 0x00, 0x26, 0xfe, 0xac, 0x04, 0x71, 0x04, + 0x8d, 0x00, 0x10, 0x00, 0x6c, 0xb2, 0x0b, 0x11, 0x12, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x07, 0x2f, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0f, 0x2f, 0x1b, 0xb1, + 0x0f, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x12, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x12, 0x3e, 0x59, 0xb2, 0x00, 0x01, 0x0c, 0x11, 0x12, 0x39, 0xb2, + 0x0b, 0x0c, 0x01, 0x11, 0x12, 0x39, 0xb2, 0x03, 0x0b, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x09, 0x10, 0xb1, 0x04, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x0e, 0x00, 0x0b, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, + 0x01, 0x33, 0x01, 0x01, 0x35, 0x33, 0x11, 0x23, 0x11, 0x23, 0x01, 0x01, 0x23, 0x01, 0x01, 0x33, 0x02, 0x28, 0x01, + 0x1f, 0xdc, 0xfe, 0x75, 0x01, 0x31, 0xa8, 0xa8, 0x74, 0xfe, 0xd5, 0xfe, 0xd8, 0xdc, 0x01, 0x96, 0xfe, 0x73, 0xdb, + 0x02, 0xda, 0x01, 0xb3, 0xfd, 0xbe, 0xfe, 0x4a, 0x01, 0xfe, 0x16, 0x01, 0x54, 0x01, 0xbb, 0xfe, 0x45, 0x02, 0x4b, + 0x02, 0x42, 0x00, 0x01, 0x00, 0x26, 0xfe, 0xac, 0x05, 0xf2, 0x04, 0x8d, 0x00, 0x0f, 0x00, 0x5e, 0xb2, 0x09, 0x10, + 0x11, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x02, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1c, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0e, 0x2f, 0x1b, 0xb1, 0x0e, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb0, 0x08, 0x10, 0xb1, 0x06, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0a, + 0xd0, 0xb0, 0x0b, 0xd0, 0xb0, 0x00, 0x10, 0xb0, 0x0c, 0xd0, 0xb0, 0x0d, 0xd0, 0x30, 0x31, 0x25, 0x33, 0x03, 0x23, + 0x11, 0x21, 0x11, 0x21, 0x35, 0x21, 0x15, 0x21, 0x11, 0x21, 0x11, 0x33, 0x05, 0x44, 0xae, 0x12, 0xa5, 0xfc, 0x50, + 0xfe, 0x9b, 0x03, 0x89, 0xfe, 0x95, 0x02, 0x46, 0xba, 0x98, 0xfe, 0x14, 0x01, 0x54, 0x03, 0xf4, 0x99, 0x99, 0xfc, + 0xa4, 0x03, 0xf5, 0x00, 0x00, 0x01, 0x00, 0x3d, 0x00, 0x00, 0x03, 0xdf, 0x04, 0x8d, 0x00, 0x17, 0x00, 0x50, 0xb2, + 0x04, 0x18, 0x19, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1c, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x16, 0x2f, 0x1b, 0xb1, 0x16, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb2, 0x10, 0x0b, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x10, 0x2f, 0xb1, + 0x07, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0xd0, 0xb0, 0x10, 0x10, 0xb0, 0x13, + 0xd0, 0x30, 0x31, 0x21, 0x23, 0x11, 0x06, 0x07, 0x15, 0x23, 0x35, 0x26, 0x26, 0x27, 0x11, 0x33, 0x11, 0x14, 0x16, + 0x17, 0x35, 0x33, 0x15, 0x36, 0x37, 0x11, 0x33, 0x03, 0xdf, 0xb9, 0x63, 0x69, 0x95, 0xbc, 0xc9, 0x03, 0xb9, 0x67, + 0x68, 0x95, 0x67, 0x65, 0xb9, 0x01, 0xc2, 0x21, 0x0b, 0xc6, 0xc3, 0x0a, 0xc9, 0xba, 0x01, 0x6d, 0xfe, 0x9d, 0x7b, + 0x78, 0x0b, 0xf0, 0xed, 0x0b, 0x22, 0x02, 0x31, 0x00, 0x01, 0x00, 0x8a, 0x00, 0x00, 0x04, 0x2c, 0x04, 0x8d, 0x00, + 0x11, 0x00, 0x47, 0xb2, 0x04, 0x12, 0x13, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, + 0xb1, 0x00, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x12, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x12, 0x3e, 0x59, 0xb2, 0x04, 0x00, 0x08, 0x11, 0x12, 0x39, + 0xb0, 0x04, 0x2f, 0xb1, 0x0d, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x13, 0x33, + 0x11, 0x36, 0x33, 0x32, 0x16, 0x17, 0x11, 0x23, 0x11, 0x34, 0x26, 0x23, 0x22, 0x07, 0x11, 0x23, 0x8a, 0xb9, 0x9a, + 0x99, 0xd4, 0xde, 0x04, 0xb9, 0x7e, 0x7f, 0x98, 0x9b, 0xb9, 0x04, 0x8d, 0xfe, 0x3e, 0x31, 0xca, 0xc1, 0xfe, 0x8f, + 0x01, 0x64, 0x87, 0x79, 0x33, 0xfd, 0xcf, 0x00, 0x02, 0x00, 0x02, 0xff, 0xf0, 0x05, 0x6b, 0x04, 0x9d, 0x00, 0x1c, + 0x00, 0x24, 0x00, 0x6c, 0xb2, 0x15, 0x25, 0x26, 0x11, 0x12, 0x39, 0xb0, 0x15, 0x10, 0xb0, 0x1e, 0xd0, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x0e, 0x2f, 0x1b, 0xb1, 0x0e, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, + 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb2, 0x21, 0x0e, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x21, 0x2f, 0xb2, 0xbf, 0x21, + 0x01, 0x5d, 0xb1, 0x12, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0xd0, 0xb0, 0x21, + 0x10, 0xb0, 0x0a, 0xd0, 0xb0, 0x00, 0x10, 0xb1, 0x16, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb0, 0x0e, 0x10, 0xb1, 0x1d, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x05, 0x22, + 0x00, 0x35, 0x26, 0x26, 0x35, 0x33, 0x14, 0x16, 0x17, 0x3e, 0x02, 0x33, 0x32, 0x00, 0x11, 0x15, 0x21, 0x14, 0x16, + 0x33, 0x32, 0x36, 0x37, 0x17, 0x06, 0x06, 0x03, 0x22, 0x06, 0x07, 0x21, 0x35, 0x34, 0x26, 0x03, 0x91, 0xff, 0xfe, + 0xce, 0xa6, 0xb8, 0x99, 0x5f, 0x66, 0x05, 0x87, 0xe9, 0x8e, 0xf8, 0x01, 0x10, 0xfc, 0xae, 0xc1, 0xb7, 0x4c, 0x87, + 0x50, 0x39, 0x3c, 0xb8, 0x96, 0x8f, 0xb5, 0x06, 0x02, 0x99, 0xae, 0x10, 0x01, 0x22, 0xf3, 0x0b, 0xc6, 0xa8, 0x5e, + 0x77, 0x0c, 0x93, 0xec, 0x81, 0xfe, 0xeb, 0xfe, 0xfd, 0x82, 0xb1, 0xc0, 0x1f, 0x28, 0x92, 0x28, 0x2f, 0x04, 0x11, + 0xc2, 0xa4, 0x1b, 0xa1, 0xaa, 0x00, 0x02, 0x00, 0x5e, 0xff, 0xf0, 0x04, 0x69, 0x04, 0x9d, 0x00, 0x16, 0x00, 0x1e, + 0x00, 0x61, 0xb2, 0x08, 0x1f, 0x20, 0x11, 0x12, 0x39, 0xb0, 0x08, 0x10, 0xb0, 0x17, 0xd0, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, + 0x08, 0x12, 0x3e, 0x59, 0xb2, 0x0d, 0x00, 0x08, 0x11, 0x12, 0x39, 0xb0, 0x0d, 0x2f, 0xb0, 0x00, 0x10, 0xb1, 0x11, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, 0x10, 0xb1, 0x17, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0d, 0x10, 0xb1, 0x1a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0x30, 0x31, 0x01, 0x32, 0x00, 0x17, 0x15, 0x14, 0x06, 0x06, 0x23, 0x22, 0x00, 0x11, 0x35, 0x21, 0x35, + 0x34, 0x26, 0x23, 0x22, 0x07, 0x27, 0x36, 0x36, 0x13, 0x32, 0x36, 0x37, 0x21, 0x15, 0x14, 0x16, 0x02, 0x47, 0xf7, + 0x01, 0x29, 0x02, 0x84, 0xec, 0x93, 0xf8, 0xfe, 0xf0, 0x03, 0x52, 0xc1, 0xb7, 0x93, 0x90, 0x39, 0x41, 0xc0, 0x89, + 0x91, 0xb3, 0x06, 0xfd, 0x67, 0xad, 0x04, 0x9d, 0xfe, 0xe0, 0xef, 0x88, 0x99, 0xf4, 0x89, 0x01, 0x15, 0x01, 0x01, + 0x82, 0x01, 0xb1, 0xc1, 0x48, 0x92, 0x29, 0x2f, 0xfb, 0xed, 0xc6, 0xa1, 0x1b, 0xa0, 0xac, 0x00, 0x01, 0x00, 0x47, + 0xff, 0xed, 0x03, 0xd4, 0x04, 0x8d, 0x00, 0x1c, 0x00, 0x70, 0xb2, 0x1a, 0x1d, 0x1e, 0x11, 0x12, 0x39, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, + 0x1b, 0xb1, 0x0b, 0x12, 0x3e, 0x59, 0xb0, 0x02, 0x10, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb2, 0x04, 0x00, 0x02, 0x11, 0x12, 0x39, 0xb2, 0x05, 0x0b, 0x02, 0x11, 0x12, 0x39, 0xb0, 0x05, 0x2f, + 0xb2, 0x11, 0x0b, 0x02, 0x11, 0x12, 0x39, 0xb0, 0x0b, 0x10, 0xb1, 0x14, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x05, 0x10, 0xb1, 0x1a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, + 0x1c, 0x05, 0x1a, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x21, 0x35, 0x21, 0x17, 0x01, 0x16, 0x16, 0x15, 0x14, 0x06, + 0x23, 0x22, 0x26, 0x27, 0x26, 0x35, 0x33, 0x16, 0x16, 0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x23, 0x23, 0x35, 0x02, + 0xb3, 0xfd, 0xbc, 0x03, 0x38, 0x02, 0xfe, 0xa9, 0xb1, 0xd1, 0xfc, 0xd7, 0x59, 0xab, 0x3c, 0x7a, 0xb9, 0x05, 0x89, + 0x73, 0x88, 0x92, 0x8a, 0x86, 0x80, 0x03, 0xf4, 0x99, 0x76, 0xfe, 0x9b, 0x10, 0xc5, 0x8b, 0xa7, 0xbe, 0x2d, 0x2e, + 0x5a, 0x9e, 0x59, 0x64, 0x68, 0x6a, 0x5f, 0x6a, 0xa5, 0x00, 0x00, 0x03, 0x00, 0x60, 0xff, 0xf0, 0x04, 0x5a, 0x04, + 0x9d, 0x00, 0x0d, 0x00, 0x14, 0x00, 0x1b, 0x00, 0x76, 0xb2, 0x03, 0x1c, 0x1d, 0x11, 0x12, 0x39, 0xb0, 0x03, 0x10, + 0xb0, 0x0e, 0xd0, 0xb0, 0x03, 0x10, 0xb0, 0x15, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, + 0x0a, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x12, 0x3e, 0x59, 0xb1, 0x0e, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x19, 0x0a, 0x03, 0x11, 0x12, 0x39, 0x7c, 0xb0, + 0x19, 0x2f, 0x18, 0xb2, 0xa0, 0x19, 0x01, 0x5d, 0xb4, 0x60, 0x19, 0x70, 0x19, 0x02, 0x5d, 0xb4, 0x60, 0x19, 0x70, + 0x19, 0x02, 0x71, 0xb1, 0x11, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0a, 0x10, 0xb1, + 0x15, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x10, 0x00, 0x23, 0x22, 0x00, + 0x11, 0x35, 0x10, 0x00, 0x33, 0x32, 0x00, 0x17, 0x01, 0x32, 0x36, 0x37, 0x21, 0x16, 0x16, 0x13, 0x22, 0x06, 0x07, + 0x21, 0x26, 0x26, 0x04, 0x5a, 0xfe, 0xec, 0xe8, 0xe5, 0xfe, 0xe7, 0x01, 0x17, 0xe5, 0xe9, 0x01, 0x13, 0x02, 0xfe, + 0x04, 0x93, 0xa8, 0x09, 0xfd, 0x76, 0x0a, 0xad, 0x8d, 0x91, 0xab, 0x08, 0x02, 0x8a, 0x09, 0xaa, 0x02, 0x24, 0xfe, + 0xfb, 0xfe, 0xd1, 0x01, 0x32, 0x01, 0x07, 0x3e, 0x01, 0x02, 0x01, 0x34, 0xfe, 0xd0, 0xff, 0xfe, 0x1c, 0xbc, 0xb4, + 0xb0, 0xc0, 0x03, 0x77, 0xc3, 0xac, 0xb3, 0xbc, 0x00, 0x01, 0x00, 0x30, 0x00, 0x00, 0x03, 0xef, 0x04, 0x9d, 0x00, + 0x27, 0x00, 0xb2, 0xb2, 0x1d, 0x28, 0x29, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x1d, 0x2f, 0x1b, + 0xb1, 0x1d, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x12, 0x3e, 0x59, 0xb2, + 0x06, 0x1d, 0x0c, 0x11, 0x12, 0x39, 0xb0, 0x06, 0x2f, 0xb2, 0x0f, 0x06, 0x01, 0x71, 0xb2, 0x0f, 0x06, 0x01, 0x5d, + 0xb2, 0x4f, 0x06, 0x01, 0x71, 0xb0, 0x01, 0xd0, 0xb0, 0x01, 0x2f, 0x40, 0x09, 0x1f, 0x01, 0x2f, 0x01, 0x3f, 0x01, + 0x4f, 0x01, 0x04, 0x5d, 0xb2, 0x00, 0x01, 0x01, 0x5d, 0xb1, 0x02, 0x04, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb0, 0x06, 0x10, 0xb1, 0x07, 0x04, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0c, + 0x10, 0xb1, 0x0a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0e, 0xd0, 0xb0, 0x0f, 0xd0, + 0xb0, 0x07, 0x10, 0xb0, 0x11, 0xd0, 0xb0, 0x06, 0x10, 0xb0, 0x13, 0xd0, 0xb0, 0x02, 0x10, 0xb0, 0x16, 0xd0, 0xb0, + 0x01, 0x10, 0xb0, 0x18, 0xd0, 0xb2, 0x21, 0x01, 0x1d, 0x11, 0x12, 0x39, 0xb0, 0x1d, 0x10, 0xb1, 0x24, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, 0x15, 0x21, 0x17, 0x15, 0x21, 0x15, 0x21, + 0x06, 0x07, 0x21, 0x07, 0x21, 0x35, 0x33, 0x36, 0x37, 0x23, 0x35, 0x33, 0x35, 0x27, 0x23, 0x35, 0x33, 0x27, 0x26, + 0x36, 0x33, 0x32, 0x16, 0x15, 0x23, 0x34, 0x26, 0x23, 0x22, 0x06, 0x17, 0x01, 0x87, 0x01, 0x96, 0xfe, 0x6e, 0x03, + 0x01, 0x8f, 0xfe, 0x6c, 0x0a, 0x24, 0x02, 0x94, 0x01, 0xfc, 0x84, 0x0a, 0x3f, 0x14, 0x9f, 0xa5, 0x03, 0xa2, 0x9e, + 0x02, 0x06, 0xcb, 0xb5, 0xb7, 0xca, 0xb9, 0x68, 0x60, 0x5d, 0x68, 0x04, 0x02, 0xa8, 0x79, 0x5d, 0x10, 0x79, 0x6a, + 0x47, 0x98, 0x98, 0x12, 0x9f, 0x79, 0x10, 0x5d, 0x79, 0x40, 0xc9, 0xec, 0xcc, 0xb7, 0x70, 0x77, 0x8f, 0x8a, 0x00, + 0x00, 0x01, 0x00, 0x42, 0xff, 0xf0, 0x03, 0x9e, 0x04, 0x9d, 0x00, 0x21, 0x00, 0xa2, 0xb2, 0x14, 0x22, 0x23, 0x11, + 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x15, 0x2f, 0x1b, 0xb1, 0x15, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x12, 0x3e, 0x59, 0xb2, 0x21, 0x15, 0x08, 0x11, 0x12, 0x39, 0xb0, 0x21, + 0x2f, 0xb2, 0x0f, 0x21, 0x01, 0x5d, 0xb4, 0x10, 0x21, 0x20, 0x21, 0x02, 0x5d, 0xb1, 0x00, 0x04, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, 0x10, 0xb1, 0x03, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb0, 0x00, 0x10, 0xb0, 0x0b, 0xd0, 0xb0, 0x21, 0x10, 0xb0, 0x0d, 0xd0, 0xb0, 0x21, 0x10, 0xb0, 0x12, + 0xd0, 0xb0, 0x12, 0x2f, 0x40, 0x09, 0x1f, 0x12, 0x2f, 0x12, 0x3f, 0x12, 0x4f, 0x12, 0x04, 0x5d, 0xb2, 0x00, 0x12, + 0x01, 0x5d, 0xb1, 0x0f, 0x04, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x15, 0x10, 0xb1, 0x1a, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x12, 0x10, 0xb0, 0x1c, 0xd0, 0xb0, 0x0f, 0x10, + 0xb0, 0x1e, 0xd0, 0x30, 0x31, 0x01, 0x21, 0x12, 0x21, 0x32, 0x37, 0x17, 0x06, 0x23, 0x22, 0x26, 0x27, 0x23, 0x35, + 0x33, 0x35, 0x23, 0x35, 0x33, 0x36, 0x36, 0x33, 0x32, 0x17, 0x07, 0x26, 0x23, 0x20, 0x03, 0x21, 0x15, 0x21, 0x15, + 0x21, 0x03, 0x2f, 0xfe, 0x68, 0x20, 0x01, 0x02, 0x62, 0x68, 0x1b, 0x76, 0x6f, 0xd3, 0xf5, 0x14, 0x9b, 0x97, 0x97, + 0x9b, 0x16, 0xf5, 0xcf, 0x60, 0x87, 0x15, 0x59, 0x79, 0xff, 0x00, 0x20, 0x01, 0x98, 0xfe, 0x64, 0x01, 0x9c, 0x01, + 0x96, 0xfe, 0xf1, 0x1c, 0x95, 0x1e, 0xda, 0xcc, 0x79, 0x6d, 0x79, 0xcc, 0xdc, 0x1f, 0x95, 0x1c, 0xfe, 0xf0, 0x79, + 0x6d, 0x00, 0x00, 0x04, 0x00, 0x8a, 0x00, 0x00, 0x07, 0xad, 0x04, 0x9d, 0x00, 0x03, 0x00, 0x10, 0x00, 0x1e, 0x00, + 0x28, 0x00, 0xab, 0xb2, 0x1f, 0x29, 0x2a, 0x11, 0x12, 0x39, 0xb0, 0x1f, 0x10, 0xb0, 0x01, 0xd0, 0xb0, 0x1f, 0x10, + 0xb0, 0x04, 0xd0, 0xb0, 0x1f, 0x10, 0xb0, 0x11, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x27, 0x2f, 0x1b, 0xb1, + 0x27, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x25, 0x2f, 0x1b, 0xb1, 0x25, 0x1c, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x22, 0x2f, 0x1b, + 0xb1, 0x22, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x20, 0x2f, 0x1b, 0xb1, 0x20, 0x12, 0x3e, 0x59, 0xb0, + 0x07, 0x10, 0xb0, 0x0d, 0xd0, 0xb0, 0x0d, 0x2f, 0xb0, 0x02, 0xd0, 0xb0, 0x02, 0x2f, 0xb4, 0x00, 0x02, 0x10, 0x02, + 0x02, 0x5d, 0xb1, 0x01, 0x03, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0d, 0x10, 0xb1, 0x14, + 0x03, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x07, 0x10, 0xb1, 0x1b, 0x03, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x21, 0x27, 0x20, 0x11, 0x12, 0x39, 0xb2, 0x26, 0x20, 0x27, 0x11, 0x12, + 0x39, 0x30, 0x31, 0x25, 0x21, 0x35, 0x21, 0x01, 0x34, 0x36, 0x20, 0x16, 0x15, 0x15, 0x14, 0x06, 0x23, 0x22, 0x26, + 0x35, 0x17, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x01, 0x23, 0x01, 0x11, + 0x23, 0x11, 0x33, 0x01, 0x11, 0x33, 0x07, 0x6e, 0xfd, 0xd3, 0x02, 0x2d, 0xfd, 0x92, 0xbc, 0x01, 0x34, 0xbd, 0xbe, + 0x97, 0x99, 0xbf, 0xa3, 0x5e, 0x57, 0x54, 0x5e, 0x61, 0x53, 0x52, 0x61, 0xfe, 0xb5, 0xb8, 0xfd, 0xa3, 0xb9, 0xb9, + 0x02, 0x5d, 0xb8, 0xbd, 0x8e, 0x02, 0x03, 0x95, 0xba, 0xb8, 0x9b, 0x50, 0x98, 0xb6, 0xb7, 0x9c, 0x05, 0x59, 0x6a, + 0x69, 0x5c, 0x52, 0x5a, 0x68, 0x67, 0x5e, 0xfc, 0xb5, 0x03, 0x6c, 0xfc, 0x94, 0x04, 0x8d, 0xfc, 0x93, 0x03, 0x6d, + 0x00, 0x02, 0x00, 0x28, 0x00, 0x00, 0x04, 0x66, 0x04, 0x8d, 0x00, 0x16, 0x00, 0x1f, 0x00, 0x86, 0xb2, 0x00, 0x20, + 0x21, 0x11, 0x12, 0x39, 0xb0, 0x18, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x1c, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb2, 0x16, 0x0c, 0x02, + 0x11, 0x12, 0x39, 0xb0, 0x16, 0x2f, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x04, 0xd0, 0xb0, 0x16, 0x10, 0xb0, 0x06, 0xd0, 0xb0, 0x16, 0x10, 0xb0, 0x0b, 0xd0, 0xb0, 0x0b, 0x2f, 0x40, 0x09, + 0x0f, 0x0b, 0x1f, 0x0b, 0x2f, 0x0b, 0x3f, 0x0b, 0x04, 0x5d, 0xb4, 0xbf, 0x0b, 0xcf, 0x0b, 0x02, 0x5d, 0xb1, 0x08, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x13, 0xd0, 0xb0, 0x0b, 0x10, 0xb0, 0x17, 0xd0, + 0xb0, 0x0c, 0x10, 0xb1, 0x1e, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x25, 0x21, + 0x15, 0x23, 0x35, 0x23, 0x35, 0x33, 0x35, 0x23, 0x35, 0x33, 0x11, 0x21, 0x32, 0x16, 0x15, 0x14, 0x06, 0x07, 0x21, + 0x15, 0x21, 0x25, 0x21, 0x32, 0x36, 0x35, 0x34, 0x26, 0x23, 0x21, 0x02, 0xa4, 0xfe, 0xfe, 0xba, 0xc0, 0xc0, 0xc0, + 0xc0, 0x01, 0xcf, 0xc5, 0xea, 0xe3, 0xbe, 0xfe, 0xdd, 0x01, 0x02, 0xfe, 0xfe, 0x01, 0x15, 0x72, 0x83, 0x84, 0x70, + 0xfe, 0xea, 0xb4, 0xb4, 0xb4, 0x98, 0x59, 0x98, 0x02, 0x50, 0xcc, 0xa8, 0xa5, 0xcb, 0x04, 0x59, 0xf1, 0x78, 0x62, + 0x64, 0x7a, 0x00, 0x01, 0x00, 0x3e, 0xff, 0xf5, 0x02, 0x9a, 0x03, 0x20, 0x00, 0x26, 0x00, 0x74, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x0e, 0x2f, 0x1b, 0xb1, 0x0e, 0x18, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x19, 0x2f, 0x1b, + 0xb1, 0x19, 0x12, 0x3e, 0x59, 0xb2, 0x00, 0x19, 0x0e, 0x11, 0x12, 0x39, 0x7c, 0xb0, 0x00, 0x2f, 0x18, 0xb6, 0x80, + 0x00, 0x90, 0x00, 0xa0, 0x00, 0x03, 0x5d, 0xb0, 0x0e, 0x10, 0xb1, 0x07, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb2, 0x0a, 0x00, 0x07, 0x11, 0x12, 0x39, 0xb0, 0x00, 0x10, 0xb1, 0x26, 0x02, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x14, 0x26, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x19, 0x10, 0xb1, 0x20, 0x02, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x1d, 0x26, 0x20, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, + 0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x23, 0x34, 0x36, 0x33, 0x32, 0x16, 0x15, 0x14, 0x06, + 0x07, 0x16, 0x15, 0x14, 0x06, 0x23, 0x22, 0x26, 0x35, 0x33, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x34, 0x27, 0x23, + 0x01, 0x09, 0x54, 0x4a, 0x48, 0x3f, 0x46, 0x39, 0x4b, 0x9d, 0xa3, 0x7c, 0x89, 0x9c, 0x46, 0x42, 0x95, 0xaa, 0x88, + 0x84, 0xa6, 0x9e, 0x4f, 0x43, 0x46, 0x49, 0x9c, 0x58, 0x01, 0xcb, 0x3d, 0x30, 0x2d, 0x3a, 0x33, 0x29, 0x62, 0x7b, + 0x79, 0x68, 0x37, 0x5b, 0x19, 0x29, 0x8f, 0x6a, 0x7d, 0x7e, 0x6b, 0x2d, 0x3c, 0x3c, 0x33, 0x71, 0x02, 0x00, 0x02, + 0x00, 0x36, 0x00, 0x00, 0x02, 0xbb, 0x03, 0x15, 0x00, 0x0a, 0x00, 0x0e, 0x00, 0x4a, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x18, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, + 0x12, 0x3e, 0x59, 0xb2, 0x01, 0x09, 0x04, 0x11, 0x12, 0x39, 0xb0, 0x01, 0x2f, 0xb1, 0x02, 0x02, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x06, 0xd0, 0xb0, 0x01, 0x10, 0xb0, 0x0b, 0xd0, 0xb2, 0x08, 0x0b, 0x06, + 0x11, 0x12, 0x39, 0xb2, 0x0d, 0x09, 0x04, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x33, 0x15, 0x23, 0x15, 0x23, 0x35, + 0x21, 0x27, 0x01, 0x33, 0x01, 0x33, 0x11, 0x07, 0x02, 0x50, 0x6b, 0x6b, 0x9d, 0xfe, 0x89, 0x06, 0x01, 0x79, 0xa1, + 0xfe, 0x84, 0xdf, 0x11, 0x01, 0x2b, 0x82, 0xa9, 0xa9, 0x66, 0x02, 0x06, 0xfe, 0x16, 0x01, 0x21, 0x1c, 0x00, 0x00, + 0x01, 0x00, 0x5b, 0xff, 0xf5, 0x02, 0xa7, 0x03, 0x15, 0x00, 0x1b, 0x00, 0x64, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x18, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x12, + 0x3e, 0x59, 0xb0, 0x01, 0x10, 0xb1, 0x04, 0x09, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x07, + 0x0d, 0x01, 0x11, 0x12, 0x39, 0xb0, 0x07, 0x2f, 0xb1, 0x19, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb2, 0x05, 0x07, 0x19, 0x11, 0x12, 0x39, 0xb0, 0x0d, 0x10, 0xb0, 0x11, 0xd0, 0xb0, 0x0d, 0x10, 0xb1, 0x13, + 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x07, 0x10, 0xb0, 0x1b, 0xd0, 0x30, 0x31, 0x13, + 0x13, 0x21, 0x15, 0x21, 0x07, 0x36, 0x33, 0x32, 0x16, 0x15, 0x14, 0x06, 0x23, 0x22, 0x26, 0x27, 0x33, 0x16, 0x33, + 0x32, 0x36, 0x35, 0x34, 0x26, 0x23, 0x22, 0x07, 0x70, 0x32, 0x01, 0xde, 0xfe, 0xa3, 0x16, 0x41, 0x4a, 0x80, 0x8f, + 0xa0, 0x86, 0x79, 0xa7, 0x06, 0x9b, 0x0a, 0x81, 0x41, 0x48, 0x4e, 0x4a, 0x49, 0x3b, 0x01, 0x83, 0x01, 0x92, 0x84, + 0xaa, 0x1d, 0x89, 0x79, 0x7c, 0x91, 0x7e, 0x65, 0x63, 0x4b, 0x44, 0x3e, 0x4d, 0x2b, 0x00, 0x02, 0x00, 0x56, 0xff, + 0xf5, 0x02, 0xab, 0x03, 0x1e, 0x00, 0x13, 0x00, 0x1f, 0x00, 0x51, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, + 0x1b, 0xb1, 0x00, 0x18, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x12, 0x3e, 0x59, + 0xb0, 0x00, 0x10, 0xb1, 0x01, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x06, 0x0c, 0x00, + 0x11, 0x12, 0x39, 0xb0, 0x06, 0x2f, 0xb1, 0x14, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x0c, 0x10, 0xb1, 0x1b, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x15, 0x23, + 0x04, 0x07, 0x36, 0x33, 0x32, 0x16, 0x15, 0x14, 0x06, 0x23, 0x22, 0x26, 0x35, 0x35, 0x34, 0x36, 0x37, 0x03, 0x22, + 0x06, 0x07, 0x15, 0x14, 0x16, 0x33, 0x32, 0x36, 0x34, 0x26, 0x02, 0x28, 0x11, 0xfe, 0xf4, 0x17, 0x48, 0x72, 0x76, + 0x87, 0x9f, 0x84, 0x8b, 0xa7, 0xde, 0xcd, 0x7e, 0x33, 0x4d, 0x11, 0x53, 0x3f, 0x3d, 0x4e, 0x47, 0x03, 0x1e, 0x83, + 0x02, 0xdb, 0x4d, 0x91, 0x77, 0x74, 0x9a, 0xa6, 0x97, 0x33, 0xd0, 0xe4, 0x05, 0xfe, 0x6e, 0x2c, 0x20, 0x22, 0x54, + 0x55, 0x4f, 0x7c, 0x4c, 0x00, 0x01, 0x00, 0x3a, 0x00, 0x00, 0x02, 0xa5, 0x03, 0x15, 0x00, 0x06, 0x00, 0x33, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x18, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, + 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x05, 0x10, 0xb1, 0x04, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb2, 0x00, 0x05, 0x04, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x01, 0x23, 0x01, 0x21, 0x35, 0x21, + 0x02, 0xa5, 0xfe, 0xa3, 0xa6, 0x01, 0x5d, 0xfe, 0x3b, 0x02, 0x6b, 0x02, 0xbb, 0xfd, 0x45, 0x02, 0x93, 0x82, 0x00, + 0x03, 0x00, 0x4f, 0xff, 0xf5, 0x02, 0x9f, 0x03, 0x20, 0x00, 0x13, 0x00, 0x1e, 0x00, 0x28, 0x00, 0x7d, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x11, 0x2f, 0x1b, 0xb1, 0x11, 0x18, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, + 0x1b, 0xb1, 0x06, 0x12, 0x3e, 0x59, 0xb2, 0x24, 0x06, 0x11, 0x11, 0x12, 0x39, 0xb0, 0x24, 0x2f, 0xb6, 0xdf, 0x24, + 0xef, 0x24, 0xff, 0x24, 0x03, 0x5d, 0xb6, 0x0f, 0x24, 0x1f, 0x24, 0x2f, 0x24, 0x03, 0x5d, 0xb2, 0xff, 0x24, 0x01, + 0x71, 0xb4, 0x0f, 0x24, 0x1f, 0x24, 0x02, 0x72, 0xb1, 0x17, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb2, 0x02, 0x24, 0x17, 0x11, 0x12, 0x39, 0xb2, 0x0c, 0x17, 0x24, 0x11, 0x12, 0x39, 0xb0, 0x06, 0x10, 0xb1, + 0x1d, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x11, 0x10, 0xb1, 0x1f, 0x02, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x14, 0x07, 0x16, 0x15, 0x14, 0x06, 0x20, 0x26, 0x35, + 0x34, 0x36, 0x37, 0x26, 0x35, 0x34, 0x36, 0x33, 0x32, 0x16, 0x03, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x14, 0x16, + 0x32, 0x36, 0x03, 0x22, 0x06, 0x15, 0x14, 0x16, 0x32, 0x36, 0x34, 0x26, 0x02, 0x8b, 0x77, 0x8b, 0xa0, 0xfe, 0xf0, + 0xa0, 0x4a, 0x40, 0x77, 0x97, 0x7d, 0x7e, 0x97, 0x89, 0x4e, 0x3e, 0x3f, 0x4b, 0x4c, 0x7e, 0x4c, 0x8c, 0x37, 0x3f, + 0x3f, 0x70, 0x3f, 0x40, 0x02, 0x43, 0x76, 0x37, 0x3b, 0x83, 0x6a, 0x79, 0x79, 0x6a, 0x42, 0x61, 0x1b, 0x37, 0x76, + 0x67, 0x76, 0x76, 0xfe, 0x3a, 0x34, 0x3a, 0x3a, 0x34, 0x35, 0x3a, 0x3a, 0x01, 0xf0, 0x35, 0x30, 0x2e, 0x38, 0x38, + 0x5c, 0x37, 0x00, 0x02, 0x00, 0x49, 0xff, 0xf9, 0x02, 0x95, 0x03, 0x20, 0x00, 0x12, 0x00, 0x1e, 0x00, 0x5d, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x18, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0f, + 0x2f, 0x1b, 0xb1, 0x0f, 0x12, 0x3e, 0x59, 0xb2, 0x02, 0x0f, 0x08, 0x11, 0x12, 0x39, 0xb0, 0x02, 0x2f, 0xb6, 0x0f, + 0x02, 0x1f, 0x02, 0x2f, 0x02, 0x03, 0x5d, 0xb0, 0x0f, 0x10, 0xb1, 0x10, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x02, 0x10, 0xb1, 0x13, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x08, 0x10, 0xb1, 0x19, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x06, 0x23, + 0x22, 0x26, 0x35, 0x34, 0x36, 0x33, 0x32, 0x16, 0x17, 0x15, 0x10, 0x05, 0x07, 0x35, 0x32, 0x36, 0x27, 0x32, 0x37, + 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x14, 0x16, 0x01, 0xf6, 0x45, 0x65, 0x76, 0x8d, 0xa3, 0x81, 0x89, 0x9c, + 0x03, 0xfe, 0x73, 0x37, 0x96, 0x84, 0x7b, 0x5e, 0x2a, 0x4f, 0x3c, 0x3b, 0x4c, 0x4a, 0x01, 0x40, 0x41, 0x8a, 0x7e, + 0x79, 0xa0, 0xa5, 0x94, 0x3d, 0xfe, 0x64, 0x14, 0x01, 0x7f, 0x62, 0x9e, 0x47, 0x3c, 0x53, 0x50, 0x54, 0x43, 0x41, + 0x4e, 0x00, 0x00, 0x01, 0x00, 0x8f, 0x02, 0x8b, 0x03, 0x0b, 0x03, 0x22, 0x00, 0x03, 0x00, 0x12, 0x00, 0xb0, 0x02, + 0x2f, 0xb1, 0x01, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, 0x35, 0x21, + 0x03, 0x0b, 0xfd, 0x84, 0x02, 0x7c, 0x02, 0x8b, 0x97, 0x00, 0x00, 0x03, 0x00, 0x9e, 0x04, 0x40, 0x02, 0x6e, 0x06, + 0x72, 0x00, 0x03, 0x00, 0x0f, 0x00, 0x1b, 0x00, 0x74, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, + 0x0d, 0x1a, 0x3e, 0x59, 0xb0, 0x07, 0xd0, 0xb0, 0x07, 0x2f, 0x40, 0x09, 0x3f, 0x07, 0x4f, 0x07, 0x5f, 0x07, 0x6f, + 0x07, 0x04, 0x5d, 0xb0, 0x02, 0xd0, 0xb0, 0x02, 0x2f, 0xb6, 0x3f, 0x02, 0x4f, 0x02, 0x5f, 0x02, 0x03, 0x5d, 0xb0, + 0x00, 0xd0, 0xb0, 0x00, 0x2f, 0x40, 0x11, 0x0f, 0x00, 0x1f, 0x00, 0x2f, 0x00, 0x3f, 0x00, 0x4f, 0x00, 0x5f, 0x00, + 0x6f, 0x00, 0x7f, 0x00, 0x08, 0x5d, 0xb0, 0x02, 0x10, 0xb0, 0x03, 0xd0, 0x19, 0xb0, 0x03, 0x2f, 0x18, 0xb0, 0x0d, + 0x10, 0xb1, 0x13, 0x07, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x07, 0x10, 0xb1, 0x19, 0x07, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x33, 0x07, 0x23, 0x07, 0x34, 0x36, 0x33, + 0x32, 0x16, 0x15, 0x14, 0x06, 0x23, 0x22, 0x26, 0x37, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x23, 0x22, + 0x06, 0x01, 0xb1, 0xbd, 0xdc, 0x72, 0x82, 0x64, 0x48, 0x44, 0x63, 0x61, 0x46, 0x48, 0x64, 0x55, 0x33, 0x24, 0x23, + 0x30, 0x30, 0x23, 0x25, 0x32, 0x06, 0x72, 0xb8, 0xd7, 0x46, 0x61, 0x5e, 0x49, 0x47, 0x5c, 0x5e, 0x45, 0x23, 0x32, + 0x31, 0x24, 0x26, 0x32, 0x34, 0x00, 0x01, 0x00, 0x8a, 0x00, 0x00, 0x03, 0xae, 0x04, 0x8d, 0x00, 0x0b, 0x00, 0x57, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb0, 0x0b, 0xd0, 0xb0, 0x0b, 0x2f, 0xb2, 0xdf, 0x0b, 0x01, 0x5d, + 0xb2, 0x1f, 0x0b, 0x01, 0x5d, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, + 0x10, 0xb1, 0x02, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x06, 0x10, 0xb1, 0x08, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, 0x11, 0x21, 0x15, 0x21, 0x11, 0x21, + 0x15, 0x21, 0x11, 0x21, 0x03, 0x57, 0xfd, 0xec, 0x02, 0x6b, 0xfc, 0xdc, 0x03, 0x1e, 0xfd, 0x9b, 0x02, 0x14, 0x02, + 0x0e, 0xfe, 0x89, 0x97, 0x04, 0x8d, 0x99, 0xfe, 0xb2, 0x00, 0x00, 0x03, 0x00, 0x1e, 0xfe, 0x4a, 0x04, 0x11, 0x04, + 0x4e, 0x00, 0x29, 0x00, 0x37, 0x00, 0x44, 0x00, 0x94, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x26, 0x2f, 0x1b, 0xb1, + 0x26, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x16, 0x2f, 0x1b, 0xb1, 0x16, 0x14, 0x3e, 0x59, 0xb0, 0x26, + 0x10, 0xb0, 0x29, 0xd0, 0xb0, 0x29, 0x2f, 0xb1, 0x00, 0x03, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb2, 0x08, 0x16, 0x26, 0x11, 0x12, 0x39, 0xb0, 0x08, 0x2f, 0xb2, 0x0e, 0x08, 0x16, 0x11, 0x12, 0x39, 0xb0, 0x0e, + 0x2f, 0xb4, 0x90, 0x0e, 0xa0, 0x0e, 0x02, 0x5d, 0xb1, 0x37, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb2, 0x1c, 0x37, 0x0e, 0x11, 0x12, 0x39, 0xb2, 0x20, 0x08, 0x26, 0x11, 0x12, 0x39, 0xb0, 0x16, 0x10, 0xb1, + 0x30, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, 0x10, 0xb1, 0x3b, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x26, 0x10, 0xb1, 0x42, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x23, 0x16, 0x17, 0x15, 0x14, 0x06, 0x06, 0x23, 0x22, 0x27, 0x06, 0x15, 0x14, + 0x17, 0x33, 0x16, 0x16, 0x15, 0x14, 0x06, 0x06, 0x23, 0x22, 0x26, 0x35, 0x34, 0x36, 0x37, 0x26, 0x35, 0x34, 0x37, + 0x26, 0x35, 0x35, 0x34, 0x36, 0x33, 0x32, 0x17, 0x21, 0x01, 0x06, 0x06, 0x15, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, + 0x34, 0x26, 0x27, 0x23, 0x03, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x35, 0x34, 0x26, 0x22, 0x06, 0x15, 0x04, 0x11, + 0x97, 0x3a, 0x01, 0x6f, 0xc3, 0x78, 0x4f, 0x49, 0x34, 0x7a, 0xb7, 0xc8, 0xce, 0x8d, 0xf4, 0x97, 0xd1, 0xff, 0x5e, + 0x54, 0x38, 0x73, 0xae, 0xf1, 0xbb, 0x50, 0x47, 0x01, 0x6f, 0xfd, 0x3c, 0x38, 0x3c, 0x94, 0x83, 0x92, 0xcd, 0x68, + 0x6c, 0xef, 0x74, 0x8c, 0x69, 0x67, 0x8a, 0x8a, 0xd2, 0x8a, 0x03, 0xa7, 0x54, 0x69, 0x19, 0x62, 0xa6, 0x5e, 0x15, + 0x2a, 0x40, 0x50, 0x02, 0x01, 0x95, 0x8f, 0x54, 0xa1, 0x60, 0x9b, 0x7a, 0x53, 0x8a, 0x2a, 0x2f, 0x4a, 0x7c, 0x52, + 0x6a, 0xc5, 0x0b, 0x9d, 0xca, 0x14, 0xfb, 0xf8, 0x1a, 0x5d, 0x37, 0x4a, 0x59, 0x72, 0x4c, 0x4a, 0x41, 0x02, 0x02, + 0xa5, 0x53, 0x7b, 0x7a, 0x58, 0x12, 0x57, 0x78, 0x78, 0x5a, 0x00, 0x02, 0x00, 0x64, 0xff, 0xeb, 0x04, 0x58, 0x04, + 0x4e, 0x00, 0x10, 0x00, 0x1c, 0x00, 0x63, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x1a, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, + 0x12, 0x3e, 0x59, 0xb2, 0x00, 0x02, 0x09, 0x11, 0x12, 0x39, 0xb2, 0x0b, 0x09, 0x02, 0x11, 0x12, 0x39, 0xb0, 0x02, + 0x10, 0xb1, 0x14, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x09, 0x10, 0xb1, 0x1a, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x25, 0x02, 0x21, 0x22, 0x02, 0x35, 0x35, 0x10, + 0x12, 0x33, 0x20, 0x13, 0x37, 0x33, 0x03, 0x13, 0x23, 0x01, 0x14, 0x16, 0x33, 0x32, 0x13, 0x35, 0x26, 0x26, 0x23, + 0x22, 0x06, 0x03, 0x82, 0x6c, 0xfe, 0xf2, 0xc0, 0xe4, 0xe2, 0xc4, 0x01, 0x09, 0x6c, 0x22, 0xb0, 0x6a, 0x71, 0xb0, + 0xfd, 0x75, 0x92, 0x87, 0xd3, 0x48, 0x1c, 0x92, 0x6b, 0x86, 0x95, 0xf1, 0xfe, 0xfa, 0x01, 0x1b, 0xf4, 0x0f, 0x01, + 0x08, 0x01, 0x3d, 0xfe, 0xff, 0xed, 0xfd, 0xe2, 0xfd, 0xe4, 0x01, 0xf4, 0xaf, 0xc3, 0x01, 0x87, 0x24, 0xbe, 0xcb, + 0xe3, 0x00, 0x02, 0x00, 0xb1, 0x00, 0x00, 0x04, 0xe3, 0x05, 0xaf, 0x00, 0x16, 0x00, 0x1e, 0x00, 0x63, 0xb2, 0x18, + 0x1f, 0x20, 0x11, 0x12, 0x39, 0xb0, 0x18, 0x10, 0xb0, 0x04, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, + 0x1b, 0xb1, 0x03, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x12, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0f, 0x2f, 0x1b, 0xb1, 0x0f, 0x12, 0x3e, 0x59, 0xb2, 0x17, 0x03, 0x01, 0x11, 0x12, + 0x39, 0xb0, 0x17, 0x2f, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x09, 0x17, + 0x00, 0x11, 0x12, 0x39, 0xb0, 0x03, 0x10, 0xb1, 0x1d, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0x30, 0x31, 0x01, 0x11, 0x23, 0x11, 0x21, 0x32, 0x16, 0x15, 0x14, 0x07, 0x16, 0x13, 0x15, 0x16, 0x17, 0x15, 0x23, + 0x26, 0x27, 0x35, 0x34, 0x26, 0x23, 0x25, 0x21, 0x32, 0x36, 0x35, 0x10, 0x21, 0x21, 0x01, 0x72, 0xc1, 0x02, 0x0e, + 0xf0, 0xfb, 0xed, 0xde, 0x05, 0x02, 0x41, 0xc6, 0x3b, 0x03, 0x8c, 0x7f, 0xfe, 0x9e, 0x01, 0x39, 0xa2, 0x9d, 0xfe, + 0xcf, 0xfe, 0xb9, 0x02, 0x74, 0xfd, 0x8c, 0x05, 0xaf, 0xd2, 0xcc, 0xe5, 0x63, 0x45, 0xfe, 0xfa, 0x9c, 0x8d, 0x3d, + 0x18, 0x36, 0xac, 0x8b, 0x78, 0x8f, 0x9d, 0x7c, 0x84, 0x01, 0x00, 0x00, 0x01, 0x00, 0xb2, 0x00, 0x00, 0x05, 0x1d, + 0x05, 0xb0, 0x00, 0x0c, 0x00, 0x69, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1e, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x12, + 0x3e, 0x59, 0xb2, 0x06, 0x02, 0x04, 0x11, 0x12, 0x39, 0x7c, 0xb0, 0x06, 0x2f, 0x18, 0xb4, 0x63, 0x06, 0x73, 0x06, + 0x02, 0x5d, 0xb4, 0x33, 0x06, 0x43, 0x06, 0x02, 0x5d, 0xb2, 0x93, 0x06, 0x01, 0x5d, 0xb1, 0x01, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x0a, 0x01, 0x06, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x23, 0x11, + 0x23, 0x11, 0x33, 0x11, 0x33, 0x01, 0x33, 0x01, 0x01, 0x23, 0x02, 0x23, 0xb1, 0xc0, 0xc0, 0x96, 0x01, 0xfd, 0xef, + 0xfd, 0xd4, 0x02, 0x55, 0xeb, 0x02, 0x8e, 0xfd, 0x72, 0x05, 0xb0, 0xfd, 0x7e, 0x02, 0x82, 0xfd, 0x3e, 0xfd, 0x12, + 0x00, 0x01, 0x00, 0x92, 0x00, 0x00, 0x04, 0x14, 0x06, 0x00, 0x00, 0x0c, 0x00, 0x54, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x20, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, + 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x12, 0x3e, 0x59, 0xb2, 0x07, 0x08, 0x02, 0x11, 0x12, 0x39, 0xb0, 0x07, + 0x2f, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x0a, 0x00, 0x07, 0x11, 0x12, + 0x39, 0x30, 0x31, 0x01, 0x23, 0x11, 0x23, 0x11, 0x33, 0x11, 0x33, 0x01, 0x33, 0x01, 0x01, 0x23, 0x01, 0xcc, 0x80, + 0xba, 0xba, 0x7e, 0x01, 0x3b, 0xdb, 0xfe, 0x86, 0x01, 0xae, 0xdb, 0x01, 0xf5, 0xfe, 0x0b, 0x06, 0x00, 0xfc, 0x8e, + 0x01, 0xac, 0xfe, 0x13, 0xfd, 0xb3, 0x00, 0x00, 0x01, 0x00, 0xb2, 0x00, 0x00, 0x04, 0xfa, 0x05, 0xb0, 0x00, 0x0b, + 0x00, 0x4c, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, + 0x01, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x12, 0x3e, 0x59, 0xb2, 0x00, + 0x03, 0x01, 0x11, 0x12, 0x39, 0xb2, 0x05, 0x03, 0x01, 0x11, 0x12, 0x39, 0xb2, 0x09, 0x00, 0x05, 0x11, 0x12, 0x39, + 0x30, 0x31, 0x01, 0x11, 0x23, 0x11, 0x33, 0x11, 0x33, 0x01, 0x33, 0x01, 0x01, 0x23, 0x01, 0x72, 0xc0, 0xc0, 0x0c, + 0x02, 0x63, 0xf1, 0xfd, 0x6b, 0x02, 0xbd, 0xed, 0x02, 0xb5, 0xfd, 0x4b, 0x05, 0xb0, 0xfd, 0x79, 0x02, 0x87, 0xfd, + 0x3b, 0xfd, 0x15, 0x00, 0x00, 0x01, 0x00, 0x92, 0x00, 0x00, 0x03, 0xf1, 0x06, 0x18, 0x00, 0x0c, 0x00, 0x4c, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x20, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, + 0x2f, 0x1b, 0xb1, 0x08, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x12, 0x3e, 0x59, 0xb2, 0x00, 0x08, 0x02, 0x11, + 0x12, 0x39, 0xb2, 0x06, 0x08, 0x02, 0x11, 0x12, 0x39, 0xb2, 0x0a, 0x06, 0x00, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, + 0x23, 0x11, 0x23, 0x11, 0x33, 0x11, 0x33, 0x01, 0x33, 0x01, 0x01, 0x23, 0x01, 0x50, 0x04, 0xba, 0xba, 0x01, 0x01, + 0x8a, 0xf0, 0xfe, 0x2b, 0x01, 0xff, 0xe4, 0x01, 0xf3, 0xfe, 0x0d, 0x06, 0x18, 0xfc, 0x75, 0x01, 0xad, 0xfe, 0x0d, + 0xfd, 0xb9, 0x00, 0x00, 0x02, 0x00, 0x8a, 0x00, 0x00, 0x04, 0x1f, 0x04, 0x8d, 0x00, 0x0a, 0x00, 0x14, 0x00, 0x48, + 0xb2, 0x02, 0x15, 0x16, 0x11, 0x12, 0x39, 0xb0, 0x02, 0x10, 0xb0, 0x14, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, + 0x3e, 0x59, 0xb0, 0x01, 0x10, 0xb1, 0x0b, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x00, + 0x10, 0xb1, 0x0c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x33, 0x11, 0x21, 0x32, + 0x16, 0x16, 0x17, 0x15, 0x14, 0x00, 0x21, 0x03, 0x11, 0x33, 0x32, 0x36, 0x35, 0x35, 0x34, 0x26, 0x23, 0x8a, 0x01, + 0x69, 0xa2, 0xfb, 0x8c, 0x03, 0xfe, 0xc9, 0xfe, 0xf9, 0x9e, 0xa4, 0xba, 0xc6, 0xbd, 0xb7, 0x04, 0x8d, 0x85, 0xf6, + 0x9f, 0x4d, 0xfc, 0xfe, 0xd6, 0x03, 0xf4, 0xfc, 0xa3, 0xd0, 0xc0, 0x40, 0xc0, 0xcd, 0x00, 0x01, 0x00, 0x60, 0xff, + 0xf0, 0x04, 0x30, 0x04, 0x9d, 0x00, 0x1c, 0x00, 0x4e, 0xb2, 0x03, 0x1d, 0x1e, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, + 0xb1, 0x03, 0x12, 0x3e, 0x59, 0xb0, 0x0b, 0x10, 0xb0, 0x0f, 0xd0, 0xb0, 0x0b, 0x10, 0xb1, 0x12, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x19, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb0, 0x1c, 0xd0, 0x30, 0x31, 0x01, 0x06, 0x06, 0x23, 0x22, 0x00, 0x11, 0x35, + 0x34, 0x36, 0x36, 0x33, 0x32, 0x16, 0x17, 0x23, 0x26, 0x26, 0x23, 0x22, 0x06, 0x07, 0x15, 0x14, 0x16, 0x33, 0x32, + 0x36, 0x37, 0x04, 0x30, 0x14, 0xfc, 0xd1, 0xe0, 0xfe, 0xf1, 0x7b, 0xe7, 0x98, 0xcc, 0xf7, 0x13, 0xb9, 0x12, 0x8d, + 0x7e, 0x99, 0xa7, 0x01, 0x9f, 0x97, 0x87, 0x8d, 0x14, 0x01, 0x79, 0xbb, 0xce, 0x01, 0x27, 0x01, 0x03, 0x5e, 0xa4, + 0xf9, 0x88, 0xd3, 0xbb, 0x82, 0x74, 0xcb, 0xbd, 0x6a, 0xbd, 0xcf, 0x6f, 0x83, 0x00, 0x03, 0x00, 0x8a, 0x00, 0x00, + 0x03, 0xef, 0x04, 0x8d, 0x00, 0x0e, 0x00, 0x16, 0x00, 0x1e, 0x00, 0x6b, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, + 0x2f, 0x1b, 0xb1, 0x01, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, + 0x59, 0xb2, 0x17, 0x00, 0x01, 0x11, 0x12, 0x39, 0xb0, 0x17, 0x2f, 0xb2, 0xbf, 0x17, 0x01, 0x5d, 0xb4, 0x1f, 0x17, + 0x2f, 0x17, 0x02, 0x5d, 0xb4, 0xdf, 0x17, 0xef, 0x17, 0x02, 0x5d, 0xb1, 0x0f, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x08, 0x0f, 0x17, 0x11, 0x12, 0x39, 0xb0, 0x00, 0x10, 0xb1, 0x10, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x01, 0x10, 0xb1, 0x1e, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x33, 0x11, 0x21, 0x32, 0x16, 0x15, 0x14, 0x06, 0x07, 0x16, 0x16, 0x15, 0x14, 0x06, + 0x07, 0x01, 0x11, 0x21, 0x32, 0x36, 0x35, 0x34, 0x23, 0x25, 0x33, 0x32, 0x36, 0x35, 0x34, 0x27, 0x23, 0x8a, 0x01, + 0x96, 0xd1, 0xde, 0x5f, 0x58, 0x63, 0x74, 0xda, 0xc9, 0xfe, 0xf7, 0x01, 0x06, 0x73, 0x7a, 0xeb, 0xfe, 0xf8, 0xea, + 0x6c, 0x7c, 0xe5, 0xed, 0x04, 0x8d, 0xa3, 0x9b, 0x51, 0x7e, 0x21, 0x18, 0x95, 0x65, 0x9e, 0xae, 0x01, 0x02, 0x12, + 0xfe, 0x85, 0x62, 0x55, 0xc4, 0x8d, 0x55, 0x53, 0xa8, 0x05, 0x00, 0x02, 0x00, 0x13, 0x00, 0x00, 0x04, 0x70, 0x04, + 0x8d, 0x00, 0x07, 0x00, 0x0a, 0x00, 0x47, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1c, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x12, 0x3e, 0x59, 0xb2, 0x09, 0x04, 0x02, 0x11, 0x12, 0x39, 0xb0, 0x09, 0x2f, + 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x0a, 0x04, 0x02, 0x11, 0x12, 0x39, + 0x30, 0x31, 0x01, 0x21, 0x03, 0x23, 0x01, 0x33, 0x01, 0x23, 0x01, 0x21, 0x03, 0x03, 0x46, 0xfd, 0xf8, 0x6e, 0xbd, + 0x01, 0xdf, 0xa6, 0x01, 0xd8, 0xbc, 0xfd, 0xc6, 0x01, 0x91, 0xc7, 0x01, 0x17, 0xfe, 0xe9, 0x04, 0x8d, 0xfb, 0x73, + 0x01, 0xae, 0x01, 0xfd, 0x00, 0x00, 0x01, 0x00, 0x9f, 0x04, 0x8e, 0x01, 0x96, 0x06, 0x3b, 0x00, 0x08, 0x00, 0x0c, + 0x00, 0xb0, 0x00, 0x2f, 0xb0, 0x04, 0xd0, 0xb0, 0x04, 0x2f, 0x30, 0x31, 0x01, 0x17, 0x06, 0x07, 0x15, 0x23, 0x35, + 0x34, 0x36, 0x01, 0x2b, 0x6b, 0x3b, 0x03, 0xb9, 0x54, 0x06, 0x3b, 0x53, 0x63, 0x6f, 0x88, 0x82, 0x4d, 0xad, 0x00, + 0x00, 0x02, 0x00, 0x81, 0x04, 0xdf, 0x02, 0xe0, 0x06, 0x8a, 0x00, 0x0d, 0x00, 0x11, 0x00, 0x60, 0x00, 0xb0, 0x03, + 0x2f, 0xb0, 0x07, 0xd0, 0xb0, 0x07, 0x2f, 0x40, 0x0d, 0x0f, 0x07, 0x1f, 0x07, 0x2f, 0x07, 0x3f, 0x07, 0x4f, 0x07, + 0x5f, 0x07, 0x06, 0x5d, 0xb0, 0x03, 0x10, 0xb1, 0x0a, 0x04, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb0, 0x07, 0x10, 0xb0, 0x0d, 0xd0, 0xb0, 0x0d, 0x2f, 0xb0, 0x07, 0x10, 0xb0, 0x11, 0xd0, 0xb0, 0x11, 0x2f, 0xb0, + 0x0f, 0xd0, 0xb0, 0x0f, 0x2f, 0x40, 0x0f, 0x0f, 0x0f, 0x1f, 0x0f, 0x2f, 0x0f, 0x3f, 0x0f, 0x4f, 0x0f, 0x5f, 0x0f, + 0x6f, 0x0f, 0x07, 0x5d, 0xb0, 0x11, 0x10, 0xb0, 0x10, 0xd0, 0x19, 0xb0, 0x10, 0x2f, 0x18, 0x30, 0x31, 0x01, 0x14, + 0x06, 0x23, 0x22, 0x26, 0x35, 0x33, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x25, 0x33, 0x17, 0x23, 0x02, 0xe0, 0xa8, + 0x87, 0x88, 0xa8, 0x98, 0x4f, 0x49, 0x47, 0x4f, 0xfe, 0xa6, 0x9a, 0x70, 0x65, 0x05, 0xb0, 0x5f, 0x72, 0x72, 0x5f, + 0x37, 0x3d, 0x3f, 0x35, 0xda, 0xc6, 0x00, 0x02, 0xfc, 0xa4, 0x04, 0xbc, 0xfe, 0xcc, 0x06, 0x93, 0x00, 0x14, 0x00, + 0x18, 0x00, 0x9a, 0x00, 0xb0, 0x03, 0x2f, 0xb2, 0x0f, 0x03, 0x01, 0x5d, 0xb2, 0xff, 0x03, 0x01, 0x5d, 0xb2, 0x70, + 0x03, 0x01, 0x5d, 0xb0, 0x07, 0xd0, 0xb0, 0x07, 0x2f, 0x40, 0x0b, 0x0f, 0x07, 0x1f, 0x07, 0x2f, 0x07, 0x3f, 0x07, + 0x4f, 0x07, 0x05, 0x5d, 0xb0, 0x03, 0x10, 0xb0, 0x0a, 0xd0, 0xb0, 0x0a, 0x2f, 0xb0, 0x07, 0x10, 0xb1, 0x0e, 0x03, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x11, 0x03, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0e, 0x10, 0xb0, 0x14, 0xd0, 0xb0, 0x0e, 0x10, 0xb0, 0x17, 0xd0, 0xb0, 0x17, + 0x2f, 0x40, 0x19, 0x3f, 0x17, 0x4f, 0x17, 0x5f, 0x17, 0x6f, 0x17, 0x7f, 0x17, 0x8f, 0x17, 0x9f, 0x17, 0xaf, 0x17, + 0xbf, 0x17, 0xcf, 0x17, 0xdf, 0x17, 0xef, 0x17, 0x0c, 0x5d, 0xb0, 0x15, 0xd0, 0xb0, 0x15, 0x2f, 0x40, 0x0b, 0x0f, + 0x15, 0x1f, 0x15, 0x2f, 0x15, 0x3f, 0x15, 0x4f, 0x15, 0x05, 0x5d, 0xb0, 0x17, 0x10, 0xb0, 0x18, 0xd0, 0x19, 0xb0, + 0x18, 0x2f, 0x18, 0x30, 0x31, 0x01, 0x14, 0x06, 0x23, 0x22, 0x26, 0x26, 0x23, 0x22, 0x06, 0x15, 0x27, 0x34, 0x36, + 0x33, 0x32, 0x16, 0x33, 0x32, 0x36, 0x35, 0x27, 0x33, 0x07, 0x23, 0xfe, 0xcc, 0x60, 0x46, 0x35, 0x71, 0x22, 0x14, + 0x23, 0x2f, 0x54, 0x60, 0x46, 0x2f, 0x81, 0x2c, 0x23, 0x30, 0x8d, 0xab, 0xb6, 0x78, 0x05, 0x7d, 0x4a, 0x69, 0x42, + 0x09, 0x33, 0x26, 0x15, 0x4b, 0x6b, 0x4b, 0x33, 0x26, 0xfe, 0xe1, 0x00, 0x00, 0x02, 0x00, 0x6e, 0x04, 0xe1, 0x04, + 0x58, 0x06, 0x95, 0x00, 0x06, 0x00, 0x0a, 0x00, 0x5d, 0x00, 0xb0, 0x03, 0x2f, 0xb2, 0x0f, 0x03, 0x01, 0x5d, 0xb0, + 0x05, 0xd0, 0xb0, 0x05, 0x2f, 0xb0, 0x00, 0xd0, 0xb0, 0x00, 0x2f, 0xb6, 0x0f, 0x00, 0x1f, 0x00, 0x2f, 0x00, 0x03, + 0x5d, 0xb0, 0x03, 0x10, 0xb0, 0x02, 0xd0, 0x19, 0xb0, 0x02, 0x2f, 0x18, 0xb2, 0x04, 0x03, 0x00, 0x11, 0x12, 0x39, + 0xb0, 0x06, 0xd0, 0x19, 0xb0, 0x06, 0x2f, 0x18, 0xb0, 0x03, 0x10, 0xb0, 0x09, 0xd0, 0xb0, 0x09, 0x2f, 0xb0, 0x07, + 0xd0, 0xb0, 0x07, 0x2f, 0xb6, 0x0f, 0x07, 0x1f, 0x07, 0x2f, 0x07, 0x03, 0x5d, 0xb0, 0x09, 0x10, 0xb0, 0x0a, 0xd0, + 0x19, 0xb0, 0x0a, 0x2f, 0x18, 0x30, 0x31, 0x01, 0x33, 0x01, 0x23, 0x27, 0x07, 0x23, 0x01, 0x33, 0x03, 0x23, 0x01, + 0x92, 0x98, 0x01, 0x22, 0xc5, 0xa9, 0xaa, 0xc6, 0x03, 0x22, 0xc8, 0xc9, 0x8d, 0x05, 0xe8, 0xfe, 0xf9, 0x9f, 0x9f, + 0x01, 0xb4, 0xfe, 0xfd, 0x00, 0x02, 0xff, 0x5e, 0x04, 0xcf, 0x03, 0x46, 0x06, 0x82, 0x00, 0x06, 0x00, 0x0a, 0x00, + 0x5d, 0x00, 0xb0, 0x03, 0x2f, 0xb2, 0x0f, 0x03, 0x01, 0x5d, 0xb0, 0x04, 0xd0, 0x19, 0xb0, 0x04, 0x2f, 0x18, 0xb0, + 0x00, 0xd0, 0x19, 0xb0, 0x00, 0x2f, 0x18, 0xb0, 0x03, 0x10, 0xb0, 0x01, 0xd0, 0xb0, 0x01, 0x2f, 0xb0, 0x06, 0xd0, + 0xb0, 0x06, 0x2f, 0xb6, 0x0f, 0x06, 0x1f, 0x06, 0x2f, 0x06, 0x03, 0x5d, 0xb2, 0x02, 0x03, 0x06, 0x11, 0x12, 0x39, + 0xb0, 0x03, 0x10, 0xb0, 0x08, 0xd0, 0xb0, 0x08, 0x2f, 0xb0, 0x07, 0xd0, 0x19, 0xb0, 0x07, 0x2f, 0x18, 0xb0, 0x08, + 0x10, 0xb0, 0x0a, 0xd0, 0xb0, 0x0a, 0x2f, 0xb6, 0x0f, 0x0a, 0x1f, 0x0a, 0x2f, 0x0a, 0x03, 0x5d, 0x30, 0x31, 0x01, + 0x23, 0x27, 0x07, 0x23, 0x01, 0x33, 0x05, 0x23, 0x03, 0x33, 0x03, 0x46, 0xc5, 0xaa, 0xaa, 0xc4, 0x01, 0x22, 0x98, + 0xfe, 0x8f, 0x8c, 0xc8, 0xc7, 0x04, 0xcf, 0x9e, 0x9e, 0x01, 0x06, 0x55, 0x01, 0x02, 0x00, 0x00, 0x02, 0x00, 0x69, + 0x04, 0xe4, 0x03, 0xec, 0x06, 0xcf, 0x00, 0x06, 0x00, 0x15, 0x00, 0x73, 0x00, 0xb0, 0x03, 0x2f, 0xb0, 0x05, 0xd0, + 0xb0, 0x05, 0x2f, 0xb6, 0x0f, 0x05, 0x1f, 0x05, 0x2f, 0x05, 0x03, 0x5d, 0xb2, 0x04, 0x03, 0x05, 0x11, 0x12, 0x39, + 0x19, 0xb0, 0x04, 0x2f, 0x18, 0xb0, 0x00, 0xd0, 0xb0, 0x03, 0x10, 0xb0, 0x01, 0xd0, 0xb0, 0x01, 0x2f, 0xb2, 0x02, + 0x05, 0x03, 0x11, 0x12, 0x39, 0xb0, 0x07, 0xd0, 0x7c, 0xb0, 0x07, 0x2f, 0x18, 0x40, 0x0d, 0x0f, 0x07, 0x1f, 0x07, + 0x2f, 0x07, 0x3f, 0x07, 0x4f, 0x07, 0x5f, 0x07, 0x06, 0x5d, 0xb0, 0x0e, 0xd0, 0xb0, 0x0e, 0x2f, 0x40, 0x0d, 0x0f, + 0x0e, 0x1f, 0x0e, 0x2f, 0x0e, 0x3f, 0x0e, 0x4f, 0x0e, 0x5f, 0x0e, 0x06, 0x5d, 0xb0, 0x0d, 0xd0, 0xb2, 0x08, 0x07, + 0x0d, 0x11, 0x12, 0x39, 0xb2, 0x14, 0x0e, 0x07, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x23, 0x27, 0x07, 0x23, 0x01, + 0x33, 0x17, 0x27, 0x36, 0x36, 0x35, 0x34, 0x23, 0x37, 0x32, 0x16, 0x15, 0x14, 0x06, 0x07, 0x07, 0x03, 0x46, 0xaa, + 0xc5, 0xc5, 0xa9, 0x01, 0x10, 0xbc, 0xbe, 0x01, 0x41, 0x3b, 0x8d, 0x05, 0x80, 0x86, 0x4a, 0x3c, 0x01, 0x04, 0xe4, + 0xba, 0xba, 0x01, 0x06, 0x7c, 0x83, 0x04, 0x1a, 0x21, 0x43, 0x5c, 0x58, 0x49, 0x3b, 0x42, 0x07, 0x3c, 0x00, 0x02, + 0x00, 0x69, 0x04, 0xe4, 0x03, 0x46, 0x06, 0xd4, 0x00, 0x06, 0x00, 0x1a, 0x00, 0x87, 0x00, 0xb0, 0x03, 0x2f, 0xb0, + 0x01, 0xd0, 0xb0, 0x01, 0x2f, 0xb0, 0x06, 0xd0, 0xb0, 0x06, 0x2f, 0x40, 0x09, 0x0f, 0x06, 0x1f, 0x06, 0x2f, 0x06, + 0x3f, 0x06, 0x04, 0x5d, 0xb2, 0x04, 0x03, 0x06, 0x11, 0x12, 0x39, 0x19, 0xb0, 0x04, 0x2f, 0x18, 0xb0, 0x00, 0xd0, + 0xb2, 0x02, 0x06, 0x01, 0x11, 0x12, 0x39, 0xb0, 0x06, 0x10, 0xb0, 0x0a, 0xd0, 0xb0, 0x0a, 0x2f, 0xb4, 0x3f, 0x0a, + 0x4f, 0x0a, 0x02, 0x5d, 0xb0, 0x0d, 0xd0, 0xb0, 0x0d, 0x2f, 0x40, 0x0d, 0x0f, 0x0d, 0x1f, 0x0d, 0x2f, 0x0d, 0x3f, + 0x0d, 0x4f, 0x0d, 0x5f, 0x0d, 0x06, 0x5d, 0xb0, 0x0a, 0x10, 0xb0, 0x10, 0xd0, 0xb0, 0x10, 0x2f, 0xb0, 0x0d, 0x10, + 0xb1, 0x14, 0x04, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0a, 0x10, 0xb1, 0x17, 0x04, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x14, 0x10, 0xb0, 0x1a, 0xd0, 0x30, 0x31, 0x01, 0x23, 0x27, + 0x07, 0x23, 0x25, 0x33, 0x37, 0x14, 0x06, 0x23, 0x22, 0x26, 0x23, 0x22, 0x06, 0x15, 0x27, 0x34, 0x36, 0x33, 0x32, + 0x16, 0x33, 0x32, 0x36, 0x35, 0x03, 0x46, 0xaa, 0xc5, 0xc5, 0xa9, 0x01, 0x2d, 0x83, 0xc3, 0x60, 0x41, 0x36, 0x6e, + 0x28, 0x1d, 0x36, 0x4d, 0x60, 0x40, 0x2a, 0x7c, 0x26, 0x1f, 0x34, 0x04, 0xe4, 0x9e, 0x9e, 0xf4, 0xe5, 0x3e, 0x5e, + 0x47, 0x2e, 0x1d, 0x13, 0x3f, 0x62, 0x46, 0x2d, 0x1c, 0x00, 0x01, 0x00, 0x8a, 0x00, 0x00, 0x03, 0x85, 0x05, 0xc4, + 0x00, 0x07, 0x00, 0x33, 0xb2, 0x03, 0x08, 0x09, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, + 0x1b, 0xb1, 0x06, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, + 0xb0, 0x06, 0x10, 0xb1, 0x02, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x33, + 0x11, 0x21, 0x11, 0x23, 0x11, 0x21, 0x02, 0xcc, 0xb9, 0xfd, 0xbe, 0xb9, 0x02, 0x42, 0x05, 0xc4, 0xfe, 0x30, 0xfc, + 0x0c, 0x04, 0x8d, 0x00, 0x00, 0x02, 0x00, 0x81, 0x04, 0xdf, 0x02, 0xe0, 0x06, 0x8a, 0x00, 0x0d, 0x00, 0x11, 0x00, + 0x60, 0x00, 0xb0, 0x03, 0x2f, 0xb0, 0x07, 0xd0, 0xb0, 0x07, 0x2f, 0x40, 0x0d, 0x0f, 0x07, 0x1f, 0x07, 0x2f, 0x07, + 0x3f, 0x07, 0x4f, 0x07, 0x5f, 0x07, 0x06, 0x5d, 0xb0, 0x03, 0x10, 0xb1, 0x0a, 0x04, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x07, 0x10, 0xb0, 0x0d, 0xd0, 0xb0, 0x0d, 0x2f, 0xb0, 0x07, 0x10, 0xb0, 0x10, 0xd0, + 0xb0, 0x10, 0x2f, 0xb0, 0x0f, 0xd0, 0xb0, 0x0f, 0x2f, 0x40, 0x0f, 0x0f, 0x0f, 0x1f, 0x0f, 0x2f, 0x0f, 0x3f, 0x0f, + 0x4f, 0x0f, 0x5f, 0x0f, 0x6f, 0x0f, 0x07, 0x5d, 0xb0, 0x10, 0x10, 0xb0, 0x11, 0xd0, 0x19, 0xb0, 0x11, 0x2f, 0x18, + 0x30, 0x31, 0x01, 0x14, 0x06, 0x23, 0x22, 0x26, 0x35, 0x33, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x27, 0x33, 0x07, + 0x23, 0x02, 0xe0, 0xa8, 0x87, 0x88, 0xa8, 0x98, 0x4f, 0x49, 0x47, 0x4f, 0x60, 0x99, 0xa4, 0x66, 0x05, 0xb0, 0x5f, + 0x72, 0x72, 0x5f, 0x37, 0x3d, 0x3f, 0x35, 0xda, 0xc6, 0x00, 0x00, 0x02, 0x00, 0x81, 0x04, 0xe0, 0x02, 0xca, 0x07, + 0x03, 0x00, 0x0d, 0x00, 0x1c, 0x00, 0x66, 0x00, 0xb0, 0x03, 0x2f, 0xb0, 0x07, 0xd0, 0xb0, 0x07, 0x2f, 0x40, 0x0d, + 0x0f, 0x07, 0x1f, 0x07, 0x2f, 0x07, 0x3f, 0x07, 0x4f, 0x07, 0x5f, 0x07, 0x06, 0x5d, 0xb0, 0x03, 0x10, 0xb1, 0x0a, + 0x04, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x07, 0x10, 0xb0, 0x0d, 0xd0, 0xb0, 0x0d, 0x2f, + 0xb0, 0x07, 0x10, 0xb0, 0x0e, 0xd0, 0xb0, 0x0e, 0x2f, 0xb0, 0x15, 0xd0, 0xb0, 0x15, 0x2f, 0x40, 0x0f, 0x0f, 0x15, + 0x1f, 0x15, 0x2f, 0x15, 0x3f, 0x15, 0x4f, 0x15, 0x5f, 0x15, 0x6f, 0x15, 0x07, 0x5d, 0xb0, 0x14, 0xd0, 0xb2, 0x0f, + 0x14, 0x0e, 0x11, 0x12, 0x39, 0xb2, 0x1b, 0x0e, 0x15, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x14, 0x06, 0x23, 0x22, + 0x26, 0x35, 0x33, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x27, 0x27, 0x36, 0x36, 0x35, 0x34, 0x23, 0x37, 0x32, 0x16, + 0x15, 0x14, 0x06, 0x07, 0x07, 0x02, 0xca, 0xa1, 0x83, 0x84, 0xa1, 0x92, 0x4a, 0x49, 0x45, 0x4c, 0xc9, 0x01, 0x4a, + 0x42, 0xa0, 0x07, 0x90, 0x94, 0x51, 0x44, 0x01, 0x05, 0xb0, 0x5e, 0x72, 0x73, 0x5d, 0x35, 0x3e, 0x3d, 0x36, 0x11, + 0x7c, 0x04, 0x18, 0x1d, 0x3b, 0x52, 0x4e, 0x42, 0x32, 0x3b, 0x07, 0x3e, 0xff, 0xff, 0x00, 0x50, 0x02, 0x8d, 0x02, + 0x9d, 0x05, 0xb8, 0x03, 0x07, 0x01, 0xc7, 0x00, 0x00, 0x02, 0x98, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1e, 0x3e, 0x59, 0xb0, 0x10, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x36, 0x02, + 0x98, 0x02, 0xbb, 0x05, 0xad, 0x03, 0x07, 0x02, 0x20, 0x00, 0x00, 0x02, 0x98, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x1e, 0x3e, 0x59, 0xb0, 0x0d, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, + 0x5b, 0x02, 0x8d, 0x02, 0xa7, 0x05, 0xad, 0x03, 0x07, 0x02, 0x21, 0x00, 0x00, 0x02, 0x98, 0x00, 0x10, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x1e, 0x3e, 0x59, 0x30, 0x31, 0xff, 0xff, 0x00, 0x56, 0x02, + 0x8d, 0x02, 0xab, 0x05, 0xb6, 0x03, 0x07, 0x02, 0x22, 0x00, 0x00, 0x02, 0x98, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1e, 0x3e, 0x59, 0xb0, 0x14, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, + 0x3a, 0x02, 0x98, 0x02, 0xa5, 0x05, 0xad, 0x03, 0x07, 0x02, 0x23, 0x00, 0x00, 0x02, 0x98, 0x00, 0x10, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x1e, 0x3e, 0x59, 0x30, 0x31, 0xff, 0xff, 0x00, 0x4f, 0x02, + 0x8d, 0x02, 0x9f, 0x05, 0xb8, 0x03, 0x07, 0x02, 0x24, 0x00, 0x00, 0x02, 0x98, 0x00, 0x19, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x11, 0x2f, 0x1b, 0xb1, 0x11, 0x1e, 0x3e, 0x59, 0xb0, 0x17, 0xd0, 0xb0, 0x11, 0x10, 0xb0, 0x1f, 0xd0, + 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x49, 0x02, 0x91, 0x02, 0x95, 0x05, 0xb8, 0x03, 0x07, 0x02, 0x25, 0x00, 0x00, + 0x02, 0x98, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1e, 0x3e, 0x59, 0xb0, + 0x19, 0xd0, 0x30, 0x31, 0x00, 0x00, 0x01, 0x00, 0x7e, 0xff, 0xeb, 0x05, 0x1d, 0x05, 0xc5, 0x00, 0x1e, 0x00, 0x4e, + 0xb2, 0x0c, 0x1f, 0x20, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x1e, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x12, 0x3e, 0x59, 0xb0, 0x0c, 0x10, 0xb0, + 0x10, 0xd0, 0xb0, 0x0c, 0x10, 0xb1, 0x13, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, + 0x10, 0xb1, 0x1b, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb0, 0x1e, 0xd0, + 0x30, 0x31, 0x01, 0x06, 0x00, 0x23, 0x22, 0x24, 0x02, 0x27, 0x35, 0x34, 0x12, 0x24, 0x33, 0x32, 0x00, 0x17, 0x23, + 0x26, 0x26, 0x23, 0x22, 0x02, 0x11, 0x15, 0x14, 0x12, 0x16, 0x33, 0x32, 0x36, 0x37, 0x05, 0x1c, 0x18, 0xfe, 0xdb, + 0xee, 0xb1, 0xfe, 0xe1, 0xa2, 0x01, 0x9d, 0x01, 0x1b, 0xb2, 0xed, 0x01, 0x2f, 0x19, 0xc1, 0x18, 0xbf, 0x9d, 0xc0, + 0xea, 0x6e, 0xc8, 0x7d, 0xa1, 0xb0, 0x1a, 0x01, 0xce, 0xdf, 0xfe, 0xfc, 0xb4, 0x01, 0x47, 0xcb, 0x44, 0xd3, 0x01, + 0x4a, 0xb3, 0xfe, 0xfa, 0xe3, 0xa3, 0xa8, 0xfe, 0xcb, 0xfe, 0xfe, 0x37, 0xa1, 0xff, 0x00, 0x90, 0x9d, 0xa9, 0x00, + 0x01, 0x00, 0x7e, 0xff, 0xeb, 0x05, 0x1e, 0x05, 0xc4, 0x00, 0x22, 0x00, 0x70, 0xb2, 0x0c, 0x23, 0x24, 0x11, 0x12, + 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x12, 0x3e, 0x59, 0xb2, 0x10, 0x03, 0x0c, 0x11, 0x12, 0x39, 0xb0, 0x10, 0x2f, + 0xb0, 0x0c, 0x10, 0xb1, 0x13, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb1, + 0x1b, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x22, 0x0c, 0x03, 0x11, 0x12, 0x39, 0xb0, + 0x22, 0x2f, 0xb4, 0x3f, 0x22, 0x4f, 0x22, 0x02, 0x5d, 0xb4, 0x0f, 0x22, 0x1f, 0x22, 0x02, 0x5d, 0xb1, 0x1f, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x25, 0x06, 0x04, 0x23, 0x22, 0x24, 0x02, 0x27, + 0x35, 0x34, 0x12, 0x24, 0x33, 0x32, 0x04, 0x17, 0x23, 0x26, 0x26, 0x23, 0x22, 0x02, 0x07, 0x07, 0x14, 0x12, 0x16, + 0x33, 0x32, 0x36, 0x37, 0x11, 0x21, 0x35, 0x21, 0x05, 0x1e, 0x43, 0xfe, 0xe3, 0xb0, 0xbb, 0xfe, 0xd6, 0xa8, 0x03, + 0x9b, 0x01, 0x1c, 0xb5, 0xf1, 0x01, 0x21, 0x22, 0xc0, 0x1e, 0xba, 0x9c, 0xb5, 0xec, 0x0a, 0x01, 0x78, 0xd3, 0x85, + 0x72, 0xb5, 0x2a, 0xfe, 0xb0, 0x02, 0x0f, 0xbe, 0x61, 0x72, 0xb4, 0x01, 0x47, 0xd2, 0x2d, 0xdb, 0x01, 0x4e, 0xb6, + 0xe5, 0xda, 0x95, 0x8c, 0xfe, 0xdc, 0xf2, 0x46, 0xac, 0xfe, 0xf6, 0x8c, 0x3a, 0x30, 0x01, 0x46, 0x9b, 0x00, 0x00, + 0x02, 0x00, 0xb2, 0x00, 0x00, 0x05, 0x11, 0x05, 0xb0, 0x00, 0x0b, 0x00, 0x15, 0x00, 0x48, 0xb2, 0x03, 0x16, 0x17, + 0x11, 0x12, 0x39, 0xb0, 0x03, 0x10, 0xb0, 0x15, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, + 0x01, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb0, 0x01, + 0x10, 0xb1, 0x0c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x00, 0x10, 0xb1, 0x0d, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x33, 0x11, 0x21, 0x32, 0x04, 0x12, 0x17, 0x15, + 0x14, 0x02, 0x04, 0x07, 0x03, 0x11, 0x33, 0x32, 0x00, 0x11, 0x35, 0x34, 0x00, 0x23, 0xb2, 0x01, 0xb1, 0xc1, 0x01, + 0x38, 0xb1, 0x04, 0xad, 0xfe, 0xc2, 0xcb, 0xe9, 0xdf, 0xea, 0x01, 0x13, 0xfe, 0xf7, 0xe8, 0x05, 0xb0, 0xac, 0xfe, + 0xc4, 0xc8, 0x3e, 0xd0, 0xfe, 0xc1, 0xb1, 0x02, 0x05, 0x12, 0xfb, 0x8b, 0x01, 0x2a, 0x01, 0x03, 0x24, 0xfc, 0x01, + 0x28, 0x00, 0x02, 0x00, 0x7e, 0xff, 0xeb, 0x05, 0x5f, 0x05, 0xc5, 0x00, 0x11, 0x00, 0x22, 0x00, 0x48, 0xb2, 0x04, + 0x23, 0x24, 0x11, 0x12, 0x39, 0xb0, 0x04, 0x10, 0xb0, 0x1f, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, + 0x1b, 0xb1, 0x0d, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, + 0xb0, 0x0d, 0x10, 0xb1, 0x16, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0x10, 0xb1, + 0x1f, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x14, 0x02, 0x04, 0x23, 0x22, + 0x24, 0x02, 0x27, 0x35, 0x34, 0x12, 0x24, 0x33, 0x32, 0x04, 0x12, 0x17, 0x07, 0x34, 0x02, 0x26, 0x23, 0x22, 0x06, + 0x06, 0x07, 0x15, 0x14, 0x12, 0x16, 0x33, 0x32, 0x12, 0x35, 0x05, 0x5f, 0xa2, 0xfe, 0xe2, 0xaf, 0xab, 0xfe, 0xe1, + 0xa6, 0x02, 0xa4, 0x01, 0x21, 0xab, 0xad, 0x01, 0x20, 0xa3, 0x01, 0xbf, 0x6e, 0xc7, 0x7d, 0x78, 0xc6, 0x72, 0x01, + 0x71, 0xc9, 0x79, 0xc1, 0xef, 0x02, 0xc2, 0xce, 0xfe, 0xb0, 0xb9, 0xb9, 0x01, 0x4a, 0xc8, 0x37, 0xcd, 0x01, 0x4f, + 0xbc, 0xb9, 0xfe, 0xb4, 0xcc, 0x05, 0xa2, 0x01, 0x00, 0x8f, 0x8f, 0xfe, 0x9c, 0x35, 0xa0, 0xfe, 0xfe, 0x92, 0x01, + 0x3b, 0xff, 0x00, 0x00, 0x02, 0x00, 0x7e, 0xff, 0x04, 0x05, 0x5f, 0x05, 0xc5, 0x00, 0x15, 0x00, 0x26, 0x00, 0x4f, + 0xb2, 0x08, 0x27, 0x28, 0x11, 0x12, 0x39, 0xb0, 0x08, 0x10, 0xb0, 0x23, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x11, 0x2f, 0x1b, 0xb1, 0x11, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x12, + 0x3e, 0x59, 0xb2, 0x03, 0x08, 0x11, 0x11, 0x12, 0x39, 0xb0, 0x11, 0x10, 0xb1, 0x1a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, 0x10, 0xb1, 0x23, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0x30, 0x31, 0x01, 0x14, 0x02, 0x07, 0x17, 0x07, 0x25, 0x06, 0x23, 0x22, 0x24, 0x02, 0x27, 0x35, 0x34, 0x12, + 0x24, 0x33, 0x32, 0x04, 0x12, 0x15, 0x27, 0x34, 0x02, 0x26, 0x23, 0x22, 0x06, 0x06, 0x07, 0x15, 0x14, 0x12, 0x16, + 0x33, 0x32, 0x12, 0x35, 0x05, 0x5f, 0xa9, 0x94, 0xfa, 0x83, 0xfe, 0xcc, 0x39, 0x3c, 0xab, 0xfe, 0xe0, 0xa4, 0x03, + 0xa2, 0x01, 0x22, 0xac, 0xae, 0x01, 0x21, 0xa2, 0xbf, 0x6e, 0xc7, 0x7d, 0x78, 0xc7, 0x71, 0x01, 0x71, 0xc9, 0x79, + 0xc1, 0xef, 0x02, 0xc2, 0xd4, 0xfe, 0xac, 0x5a, 0xc3, 0x79, 0xf3, 0x0c, 0xba, 0x01, 0x46, 0xc6, 0x3a, 0xcc, 0x01, + 0x50, 0xbe, 0xbb, 0xfe, 0xb0, 0xce, 0x01, 0xa3, 0x01, 0x01, 0x8f, 0x90, 0xff, 0x9c, 0x33, 0xa0, 0xfe, 0xfe, 0x92, + 0x01, 0x3b, 0xff, 0x00, 0x00, 0x01, 0x00, 0xa0, 0x00, 0x00, 0x02, 0xc9, 0x04, 0x8d, 0x00, 0x06, 0x00, 0x33, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, + 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb2, 0x04, 0x00, 0x05, 0x11, 0x12, 0x39, 0xb0, 0x04, 0x2f, 0xb1, 0x03, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x21, 0x23, 0x11, 0x05, 0x35, 0x25, 0x33, + 0x02, 0xc9, 0xb9, 0xfe, 0x90, 0x02, 0x0a, 0x1f, 0x03, 0xa6, 0x8b, 0xa8, 0xca, 0x00, 0x00, 0x01, 0x00, 0x83, 0x00, + 0x00, 0x04, 0x20, 0x04, 0xa0, 0x00, 0x18, 0x00, 0x56, 0xb2, 0x09, 0x19, 0x1a, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x11, 0x2f, 0x1b, 0xb1, 0x11, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, + 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb1, 0x17, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x02, + 0xd0, 0xb2, 0x16, 0x17, 0x11, 0x11, 0x12, 0x39, 0xb2, 0x03, 0x11, 0x16, 0x11, 0x12, 0x39, 0xb0, 0x11, 0x10, 0xb1, + 0x09, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x11, 0x10, 0xb0, 0x0c, 0xd0, 0x30, 0x31, + 0x21, 0x21, 0x35, 0x01, 0x36, 0x37, 0x37, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x23, 0x34, 0x36, 0x36, 0x33, 0x32, + 0x16, 0x15, 0x14, 0x07, 0x01, 0x21, 0x04, 0x20, 0xfc, 0x87, 0x01, 0xfd, 0x7d, 0x0a, 0x03, 0x7d, 0x66, 0x7a, 0x95, + 0xb9, 0x78, 0xd2, 0x7e, 0xbb, 0xe1, 0xc5, 0xfe, 0x86, 0x02, 0x78, 0x83, 0x01, 0xc9, 0x73, 0x54, 0x35, 0x54, 0x6c, + 0x8e, 0x75, 0x70, 0xbf, 0x6c, 0xb8, 0x98, 0xb1, 0xb4, 0xfe, 0xac, 0x00, 0x01, 0x00, 0x0f, 0xfe, 0xa3, 0x03, 0xde, + 0x04, 0x8d, 0x00, 0x18, 0x00, 0x51, 0x00, 0xb0, 0x0b, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, + 0x02, 0x1c, 0x3e, 0x59, 0xb1, 0x01, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0xd0, + 0xb2, 0x05, 0x0b, 0x02, 0x11, 0x12, 0x39, 0xb0, 0x05, 0x2f, 0xb0, 0x0b, 0x10, 0xb1, 0x10, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x05, 0x10, 0xb1, 0x17, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb2, 0x18, 0x17, 0x05, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x21, 0x35, 0x21, 0x15, 0x01, 0x16, 0x16, + 0x15, 0x14, 0x00, 0x23, 0x22, 0x27, 0x37, 0x16, 0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x23, 0x23, 0x35, 0x02, 0xe4, + 0xfd, 0x74, 0x03, 0x72, 0xfe, 0x80, 0xb2, 0xe2, 0xfe, 0xcc, 0xff, 0xca, 0xd2, 0x34, 0xa5, 0xb1, 0xb4, 0xd7, 0xb9, + 0xc0, 0x3c, 0x03, 0xf4, 0x99, 0x76, 0xfe, 0x6c, 0x18, 0xf6, 0xb3, 0xf9, 0xfe, 0xda, 0x67, 0x8b, 0x58, 0xca, 0xa5, + 0xab, 0xa5, 0x67, 0x00, 0x00, 0x02, 0x00, 0x3e, 0xfe, 0xb6, 0x04, 0xa0, 0x04, 0x8d, 0x00, 0x0a, 0x00, 0x0e, 0x00, + 0x4c, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, + 0x12, 0x3e, 0x59, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x06, 0x10, 0xb0, + 0x05, 0xd0, 0xb0, 0x05, 0x2f, 0xb0, 0x00, 0x10, 0xb0, 0x0c, 0xd0, 0xb2, 0x0d, 0x09, 0x02, 0x11, 0x12, 0x39, 0x30, + 0x31, 0x25, 0x33, 0x15, 0x23, 0x11, 0x23, 0x11, 0x21, 0x35, 0x01, 0x33, 0x01, 0x21, 0x11, 0x07, 0x03, 0xdb, 0xc5, + 0xc5, 0xba, 0xfd, 0x1d, 0x02, 0xd6, 0xc7, 0xfd, 0x3c, 0x02, 0x0a, 0x1c, 0x96, 0x97, 0xfe, 0xb7, 0x01, 0x49, 0x6d, + 0x04, 0x21, 0xfc, 0x09, 0x02, 0xfc, 0x35, 0x00, 0x01, 0x00, 0x65, 0xfe, 0xa0, 0x04, 0x05, 0x04, 0x8c, 0x00, 0x1b, + 0x00, 0x51, 0x00, 0xb0, 0x0d, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x1c, 0x3e, 0x59, + 0xb1, 0x04, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x07, 0x0d, 0x01, 0x11, 0x12, 0x39, + 0xb0, 0x07, 0x2f, 0xb1, 0x18, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x05, 0x07, 0x18, + 0x11, 0x12, 0x39, 0xb0, 0x0d, 0x10, 0xb1, 0x12, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x07, 0x10, 0xb0, 0x1b, 0xd0, 0x30, 0x31, 0x13, 0x13, 0x21, 0x15, 0x21, 0x03, 0x36, 0x37, 0x36, 0x12, 0x15, 0x14, + 0x00, 0x23, 0x22, 0x27, 0x37, 0x16, 0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x07, 0x86, 0x66, 0x03, + 0x14, 0xfd, 0x7e, 0x36, 0x6f, 0x95, 0xc8, 0xf1, 0xfe, 0xe0, 0xf1, 0xe0, 0xaf, 0x3a, 0x82, 0xd3, 0x99, 0xbf, 0xa5, + 0x87, 0x6a, 0x75, 0x22, 0x01, 0x74, 0x03, 0x18, 0xab, 0xfe, 0x74, 0x40, 0x02, 0x02, 0xfe, 0xf5, 0xe1, 0xef, 0xfe, + 0xe2, 0x72, 0x8b, 0x65, 0xcf, 0xa4, 0x8f, 0xb6, 0x3a, 0x53, 0x00, 0x01, 0x00, 0x4a, 0xfe, 0xb6, 0x03, 0xf2, 0x04, + 0x8d, 0x00, 0x06, 0x00, 0x26, 0x00, 0xb0, 0x01, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, + 0x1c, 0x3e, 0x59, 0xb1, 0x03, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x00, 0x03, 0x05, + 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x01, 0x23, 0x01, 0x21, 0x35, 0x21, 0x03, 0xf2, 0xfd, 0xa0, 0xba, 0x02, 0x57, + 0xfd, 0x1b, 0x03, 0xa8, 0x04, 0x23, 0xfa, 0x93, 0x05, 0x3f, 0x98, 0x00, 0x00, 0x02, 0x00, 0x83, 0x04, 0xd9, 0x02, + 0xd2, 0x06, 0xd0, 0x00, 0x0d, 0x00, 0x21, 0x00, 0x7e, 0x00, 0xb0, 0x03, 0x2f, 0xb0, 0x07, 0xd0, 0xb0, 0x07, 0x2f, + 0x40, 0x0d, 0x0f, 0x07, 0x1f, 0x07, 0x2f, 0x07, 0x3f, 0x07, 0x4f, 0x07, 0x5f, 0x07, 0x06, 0x5d, 0xb0, 0x03, 0x10, + 0xb1, 0x0a, 0x04, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x07, 0x10, 0xb0, 0x0d, 0xd0, 0xb0, + 0x0d, 0x2f, 0xb0, 0x07, 0x10, 0xb0, 0x11, 0xd0, 0xb0, 0x11, 0x2f, 0xb0, 0x14, 0xd0, 0xb0, 0x14, 0x2f, 0x40, 0x0b, + 0x0f, 0x14, 0x1f, 0x14, 0x2f, 0x14, 0x3f, 0x14, 0x4f, 0x14, 0x05, 0x5d, 0xb0, 0x11, 0x10, 0xb0, 0x17, 0xd0, 0xb0, + 0x17, 0x2f, 0xb0, 0x14, 0x10, 0xb1, 0x1b, 0x04, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x11, + 0x10, 0xb1, 0x1e, 0x04, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x1b, 0x10, 0xb0, 0x21, 0xd0, + 0x30, 0x31, 0x01, 0x14, 0x06, 0x23, 0x22, 0x26, 0x35, 0x33, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x13, 0x14, 0x06, + 0x23, 0x22, 0x26, 0x23, 0x22, 0x06, 0x15, 0x27, 0x34, 0x36, 0x33, 0x32, 0x16, 0x33, 0x32, 0x36, 0x35, 0x02, 0xd2, + 0xa1, 0x86, 0x87, 0xa1, 0x96, 0x4a, 0x48, 0x47, 0x4a, 0x8d, 0x60, 0x46, 0x3a, 0x77, 0x2c, 0x22, 0x30, 0x53, 0x60, + 0x45, 0x30, 0x81, 0x2c, 0x23, 0x30, 0x05, 0xae, 0x5f, 0x76, 0x76, 0x5f, 0x36, 0x40, 0x40, 0x36, 0x01, 0x0a, 0x4a, + 0x69, 0x4b, 0x33, 0x26, 0x15, 0x4b, 0x6b, 0x4b, 0x33, 0x26, 0x00, 0x01, 0x00, 0x67, 0xfe, 0x99, 0x01, 0x21, 0x00, + 0x99, 0x00, 0x03, 0x00, 0x12, 0x00, 0xb0, 0x04, 0x2f, 0xb0, 0x02, 0xd0, 0xb0, 0x02, 0x2f, 0xb0, 0x01, 0xd0, 0xb0, + 0x01, 0x2f, 0x30, 0x31, 0x01, 0x23, 0x11, 0x33, 0x01, 0x21, 0xba, 0xba, 0xfe, 0x99, 0x02, 0x00, 0x00, 0x02, 0x00, + 0x60, 0xff, 0xf0, 0x06, 0x6d, 0x04, 0x9d, 0x00, 0x13, 0x00, 0x1d, 0x00, 0x9f, 0xb2, 0x15, 0x1e, 0x1f, 0x11, 0x12, + 0x39, 0xb0, 0x15, 0x10, 0xb0, 0x0a, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x1c, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, + 0x12, 0x3e, 0x59, 0xb0, 0x0b, 0x10, 0xb1, 0x0c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x00, 0x10, 0xb0, 0x0f, 0xd0, 0xb0, 0x0f, 0x2f, 0xb2, 0x1f, 0x0f, 0x01, 0x5d, 0xb2, 0xdf, 0x0f, 0x01, 0x5d, 0xb1, + 0x10, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x00, 0x10, 0xb1, 0x13, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x02, 0x10, 0xb1, 0x14, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x09, 0x10, 0xb1, 0x17, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, + 0x31, 0x21, 0x21, 0x05, 0x22, 0x00, 0x11, 0x35, 0x10, 0x00, 0x33, 0x05, 0x21, 0x15, 0x21, 0x11, 0x21, 0x15, 0x21, + 0x11, 0x21, 0x05, 0x37, 0x11, 0x27, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x06, 0x6d, 0xfd, 0x63, 0xfe, 0x8e, 0xe5, + 0xfe, 0xe7, 0x01, 0x17, 0xe5, 0x01, 0x5b, 0x02, 0xaf, 0xfd, 0x9b, 0x02, 0x14, 0xfd, 0xec, 0x02, 0x6c, 0xfb, 0xf1, + 0xea, 0xec, 0x96, 0xaf, 0xb0, 0x10, 0x01, 0x32, 0x01, 0x07, 0x3e, 0x01, 0x02, 0x01, 0x34, 0x10, 0x99, 0xfe, 0xb2, + 0x98, 0xfe, 0x89, 0x0d, 0x07, 0x03, 0x67, 0x09, 0xd6, 0xc5, 0x42, 0xc3, 0xd7, 0x00, 0x00, 0x02, 0x00, 0x82, 0xfe, + 0xa9, 0x04, 0x3f, 0x04, 0xa1, 0x00, 0x18, 0x00, 0x25, 0x00, 0x4e, 0x00, 0xb0, 0x14, 0x2f, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x1c, 0x3e, 0x59, 0xb0, 0x14, 0x10, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x05, 0x14, 0x0c, 0x11, 0x12, 0x39, 0xb0, 0x05, 0x2f, 0xb2, 0x03, 0x05, 0x0c, + 0x11, 0x12, 0x39, 0xb1, 0x1a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0c, 0x10, 0xb1, + 0x20, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x05, 0x32, 0x36, 0x37, 0x06, 0x23, + 0x22, 0x02, 0x35, 0x34, 0x36, 0x36, 0x33, 0x32, 0x00, 0x13, 0x15, 0x14, 0x02, 0x04, 0x23, 0x22, 0x27, 0x37, 0x16, + 0x13, 0x32, 0x36, 0x37, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x14, 0x16, 0x01, 0xdf, 0xb1, 0xdc, 0x15, 0x77, + 0xb7, 0xd2, 0xff, 0x75, 0xd2, 0x84, 0xeb, 0x01, 0x05, 0x02, 0x92, 0xfe, 0xf3, 0xaf, 0x9f, 0x76, 0x26, 0x7a, 0xe0, + 0x69, 0x9f, 0x22, 0xa1, 0x92, 0x7f, 0x98, 0xa3, 0xbf, 0xf4, 0xd9, 0x69, 0x01, 0x14, 0xe2, 0x9c, 0xec, 0x7e, 0xfe, + 0xdc, 0xfe, 0xf6, 0xfa, 0xdc, 0xfe, 0xba, 0xae, 0x3c, 0x8e, 0x32, 0x01, 0xfc, 0x5c, 0x52, 0x94, 0xc5, 0xc5, 0xc3, + 0xab, 0x95, 0xc9, 0x00, 0x01, 0xff, 0xb6, 0xfe, 0x4b, 0x01, 0x67, 0x00, 0x98, 0x00, 0x0c, 0x00, 0x28, 0x00, 0xb0, + 0x0d, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x14, 0x3e, 0x59, 0xb1, 0x09, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0d, 0x10, 0xb0, 0x0c, 0xd0, 0xb0, 0x0c, 0x2f, 0x30, 0x31, + 0x25, 0x15, 0x06, 0x06, 0x23, 0x22, 0x27, 0x37, 0x16, 0x33, 0x32, 0x35, 0x35, 0x01, 0x67, 0x01, 0xaa, 0x97, 0x3b, + 0x34, 0x0e, 0x1e, 0x43, 0x89, 0x98, 0xf5, 0xa8, 0xb0, 0x12, 0x9d, 0x0d, 0xc2, 0xe9, 0x00, 0xff, 0xff, 0x00, 0x3b, + 0xfe, 0xa3, 0x04, 0x0a, 0x04, 0x8d, 0x01, 0x06, 0x02, 0x4c, 0x2c, 0x00, 0x00, 0x10, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1c, 0x3e, 0x59, 0x30, 0x31, 0xff, 0xff, 0x00, 0x73, 0xfe, 0xa0, 0x04, 0x13, + 0x04, 0x8c, 0x01, 0x06, 0x02, 0x4e, 0x0e, 0x00, 0x00, 0x10, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, + 0xb1, 0x01, 0x1c, 0x3e, 0x59, 0x30, 0x31, 0xff, 0xff, 0x00, 0x23, 0xfe, 0xb6, 0x04, 0x85, 0x04, 0x8d, 0x01, 0x06, + 0x02, 0x4d, 0xe5, 0x00, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x12, 0x3e, + 0x59, 0xb0, 0x0c, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x77, 0x00, 0x00, 0x04, 0x14, 0x04, 0xa0, 0x01, 0x06, + 0x02, 0x4b, 0xf4, 0x00, 0x00, 0x10, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x11, 0x2f, 0x1b, 0xb1, 0x11, 0x1c, 0x3e, + 0x59, 0x30, 0x31, 0xff, 0xff, 0x00, 0x76, 0xfe, 0xb6, 0x04, 0x1e, 0x04, 0x8d, 0x01, 0x06, 0x02, 0x4f, 0x2c, 0x00, + 0x00, 0x10, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x1c, 0x3e, 0x59, 0x30, 0x31, 0xff, + 0xff, 0x00, 0x37, 0xff, 0xeb, 0x04, 0x48, 0x04, 0xa1, 0x01, 0x06, 0x02, 0x65, 0xbf, 0x00, 0x00, 0x13, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1c, 0x3e, 0x59, 0xb0, 0x0f, 0xd0, 0x30, 0x31, 0x00, 0xff, + 0xff, 0x00, 0x7e, 0xff, 0xec, 0x04, 0x16, 0x05, 0xb1, 0x01, 0x06, 0x00, 0x1a, 0xfa, 0x00, 0x00, 0x13, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1e, 0x3e, 0x59, 0xb0, 0x15, 0xd0, 0x30, 0x31, 0x00, 0xff, + 0xff, 0x00, 0x5f, 0xfe, 0xa9, 0x04, 0x1c, 0x04, 0xa1, 0x01, 0x06, 0x02, 0x53, 0xdd, 0x00, 0x00, 0x13, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x1c, 0x3e, 0x59, 0xb0, 0x20, 0xd0, 0x30, 0x31, 0x00, 0xff, + 0xff, 0x00, 0x70, 0xff, 0xec, 0x04, 0x0e, 0x05, 0xc4, 0x01, 0x06, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x19, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x15, 0x2f, 0x1b, 0xb1, 0x15, 0x1e, 0x3e, 0x59, 0xb0, 0x1b, 0xd0, 0xb0, 0x15, 0x10, 0xb0, + 0x22, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0xf4, 0x00, 0x00, 0x03, 0x1d, 0x04, 0x8d, 0x00, 0x06, 0x02, 0x4a, + 0x54, 0x00, 0xff, 0xff, 0xff, 0xb4, 0xfe, 0x4b, 0x01, 0x65, 0x04, 0x3a, 0x00, 0x06, 0x00, 0x9c, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xb4, 0xfe, 0x4b, 0x01, 0x65, 0x04, 0x3a, 0x00, 0x06, 0x00, 0x9c, 0x00, 0x00, 0xff, 0xff, 0x00, 0x9b, + 0x00, 0x00, 0x01, 0x55, 0x04, 0x3a, 0x01, 0x06, 0x00, 0x8d, 0x00, 0x00, 0x00, 0x10, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1a, 0x3e, 0x59, 0x30, 0x31, 0xff, 0xff, 0xff, 0xfa, 0xfe, 0x59, 0x01, 0x5a, + 0x04, 0x3a, 0x00, 0x26, 0x00, 0x8d, 0x00, 0x00, 0x00, 0x06, 0x00, 0xa4, 0xc8, 0x0a, 0xff, 0xff, 0x00, 0x9b, 0x00, + 0x00, 0x01, 0x55, 0x04, 0x3a, 0x00, 0x06, 0x00, 0x8d, 0x00, 0x00, 0x00, 0x01, 0x00, 0x8a, 0xff, 0xec, 0x03, 0xf9, + 0x04, 0x9d, 0x00, 0x21, 0x00, 0x66, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x15, 0x2f, 0x1b, 0xb1, 0x15, 0x1c, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x1f, 0x2f, 0x1b, 0xb1, 0x1f, 0x12, 0x3e, 0x59, 0xb1, 0x02, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb2, 0x19, 0x1f, 0x15, 0x11, 0x12, 0x39, 0xb0, 0x19, 0x2f, 0xb4, 0x1f, 0x19, 0x2f, 0x19, 0x02, 0x5d, 0xb0, + 0x08, 0xb0, 0x0a, 0x2b, 0x58, 0xd8, 0x1b, 0xdc, 0x59, 0xb0, 0x19, 0x10, 0xb0, 0x0a, 0xd0, 0xb0, 0x15, 0x10, 0xb1, + 0x0d, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x25, 0x16, 0x33, 0x32, 0x36, 0x35, + 0x34, 0x26, 0x23, 0x23, 0x35, 0x13, 0x26, 0x23, 0x22, 0x03, 0x11, 0x23, 0x11, 0x36, 0x36, 0x33, 0x32, 0x16, 0x17, + 0x01, 0x16, 0x16, 0x15, 0x14, 0x06, 0x23, 0x22, 0x27, 0x01, 0xc3, 0x52, 0x58, 0x61, 0x72, 0x88, 0x87, 0x54, 0xed, + 0x4e, 0x63, 0xd3, 0x04, 0xb8, 0x01, 0xc5, 0xc9, 0x6b, 0xc3, 0x65, 0xfe, 0xee, 0xa9, 0xb6, 0xd7, 0xb5, 0x77, 0x68, + 0xb5, 0x33, 0x7b, 0x63, 0x62, 0x55, 0x89, 0x01, 0x27, 0x3e, 0xfe, 0xf5, 0xfd, 0x06, 0x02, 0xf5, 0xd2, 0xd6, 0x55, + 0x62, 0xfe, 0xb6, 0x0f, 0xa3, 0x86, 0xac, 0xcc, 0x31, 0x00, 0x00, 0x02, 0x00, 0x78, 0xff, 0xeb, 0x04, 0x89, 0x04, + 0xa1, 0x00, 0x0b, 0x00, 0x19, 0x00, 0x3b, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1c, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x12, 0x3e, 0x59, 0xb0, 0x08, 0x10, 0xb1, + 0x0f, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x16, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x10, 0x00, 0x20, 0x00, 0x03, 0x35, 0x10, 0x00, 0x20, + 0x00, 0x13, 0x27, 0x34, 0x26, 0x23, 0x22, 0x06, 0x07, 0x15, 0x14, 0x16, 0x33, 0x32, 0x36, 0x37, 0x04, 0x89, 0xfe, + 0xe8, 0xfe, 0x22, 0xfe, 0xe6, 0x01, 0x01, 0x19, 0x01, 0xde, 0x01, 0x19, 0x01, 0xba, 0xb2, 0x9d, 0x9b, 0xb2, 0x02, + 0xb6, 0x9b, 0x9a, 0xb1, 0x02, 0x02, 0x3c, 0xfe, 0xea, 0xfe, 0xc5, 0x01, 0x3c, 0x01, 0x14, 0x14, 0x01, 0x14, 0x01, + 0x3e, 0xfe, 0xc4, 0xfe, 0xeb, 0x0d, 0xca, 0xe2, 0xe0, 0xc5, 0x34, 0xc9, 0xe5, 0xdd, 0xca, 0x00, 0x00, 0x01, 0x00, + 0x3b, 0x00, 0x00, 0x03, 0xd2, 0x05, 0xb0, 0x00, 0x06, 0x00, 0x33, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, + 0x1b, 0xb1, 0x05, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x12, 0x3e, 0x59, + 0xb0, 0x05, 0x10, 0xb1, 0x03, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x00, 0x03, 0x05, + 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x01, 0x23, 0x01, 0x21, 0x35, 0x21, 0x03, 0xd2, 0xfd, 0xbe, 0xba, 0x02, 0x40, + 0xfd, 0x25, 0x03, 0x97, 0x05, 0x48, 0xfa, 0xb8, 0x05, 0x18, 0x98, 0x00, 0x02, 0x00, 0x8c, 0xff, 0xec, 0x04, 0x34, + 0x06, 0x00, 0x00, 0x10, 0x00, 0x1b, 0x00, 0x66, 0xb2, 0x14, 0x1c, 0x1d, 0x11, 0x12, 0x39, 0xb0, 0x14, 0x10, 0xb0, + 0x0d, 0xd0, 0x00, 0xb0, 0x09, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1a, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, + 0x2f, 0x1b, 0xb1, 0x07, 0x12, 0x3e, 0x59, 0xb2, 0x06, 0x0d, 0x04, 0x11, 0x12, 0x39, 0xb2, 0x0b, 0x0d, 0x04, 0x11, + 0x12, 0x39, 0xb0, 0x0d, 0x10, 0xb1, 0x14, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, + 0x10, 0xb1, 0x19, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x14, 0x06, 0x06, + 0x23, 0x22, 0x27, 0x07, 0x23, 0x11, 0x33, 0x11, 0x36, 0x33, 0x32, 0x12, 0x11, 0x27, 0x34, 0x26, 0x23, 0x22, 0x07, + 0x11, 0x16, 0x33, 0x32, 0x36, 0x04, 0x34, 0x6f, 0xc9, 0x80, 0xd1, 0x70, 0x0f, 0xa0, 0xb9, 0x70, 0xc5, 0xc9, 0xf1, + 0xb9, 0xa3, 0x8c, 0xb7, 0x50, 0x55, 0xb4, 0x8a, 0xa3, 0x02, 0x12, 0x9f, 0xfc, 0x8b, 0x95, 0x81, 0x06, 0x00, 0xfd, + 0xc3, 0x8b, 0xfe, 0xd3, 0xfe, 0xff, 0x07, 0xb4, 0xd6, 0xaa, 0xfe, 0x2c, 0xab, 0xd8, 0x00, 0x00, 0x01, 0x00, 0x5c, + 0xff, 0xec, 0x03, 0xef, 0x04, 0x4e, 0x00, 0x1d, 0x00, 0x4b, 0xb2, 0x00, 0x1e, 0x1f, 0x11, 0x12, 0x39, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, + 0x1b, 0xb1, 0x08, 0x12, 0x3e, 0x59, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x08, 0x10, 0xb0, 0x03, 0xd0, 0xb0, 0x10, 0x10, 0xb0, 0x14, 0xd0, 0xb0, 0x10, 0x10, 0xb1, 0x17, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x25, 0x32, 0x36, 0x37, 0x33, 0x0e, 0x02, 0x23, 0x22, 0x00, + 0x35, 0x35, 0x34, 0x36, 0x36, 0x33, 0x32, 0x16, 0x17, 0x23, 0x26, 0x26, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, + 0x02, 0x40, 0x63, 0x94, 0x08, 0xb0, 0x05, 0x78, 0xc4, 0x6e, 0xdf, 0xfe, 0xfb, 0x76, 0xdb, 0x93, 0xb6, 0xf1, 0x08, + 0xb0, 0x08, 0x8f, 0x68, 0x8f, 0x9b, 0x9d, 0x83, 0x78, 0x5a, 0x5e, 0xa8, 0x63, 0x01, 0x2a, 0xfc, 0x20, 0x9d, 0xf9, + 0x86, 0xda, 0xae, 0x69, 0x87, 0xce, 0xbf, 0x21, 0xbc, 0xc9, 0x00, 0x02, 0x00, 0x5b, 0xff, 0xec, 0x04, 0x00, 0x06, + 0x00, 0x00, 0x11, 0x00, 0x1c, 0x00, 0x66, 0xb2, 0x1a, 0x1d, 0x1e, 0x11, 0x12, 0x39, 0xb0, 0x1a, 0x10, 0xb0, 0x04, + 0xd0, 0x00, 0xb0, 0x07, 0x2f, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, + 0x1b, 0xb1, 0x09, 0x12, 0x3e, 0x59, 0xb2, 0x06, 0x04, 0x0d, 0x11, 0x12, 0x39, 0xb2, 0x0b, 0x04, 0x0d, 0x11, 0x12, + 0x39, 0xb0, 0x0d, 0x10, 0xb1, 0x15, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0x10, + 0xb1, 0x1a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x13, 0x34, 0x36, 0x36, 0x33, + 0x32, 0x17, 0x11, 0x33, 0x11, 0x23, 0x27, 0x06, 0x23, 0x22, 0x26, 0x26, 0x27, 0x37, 0x14, 0x16, 0x33, 0x32, 0x37, + 0x11, 0x26, 0x23, 0x22, 0x06, 0x5b, 0x71, 0xce, 0x80, 0xbe, 0x6f, 0xb9, 0xa1, 0x0e, 0x6f, 0xca, 0x7c, 0xcb, 0x75, + 0x01, 0xb9, 0xa8, 0x8a, 0xaf, 0x52, 0x53, 0xac, 0x8d, 0xa7, 0x02, 0x26, 0x9f, 0xfc, 0x8d, 0x82, 0x02, 0x34, 0xfa, + 0x00, 0x78, 0x8c, 0x8c, 0xfb, 0x98, 0x06, 0xb1, 0xd8, 0x9f, 0x01, 0xf1, 0x99, 0xd6, 0x00, 0x02, 0x00, 0x5b, 0xfe, + 0x56, 0x04, 0x00, 0x04, 0x4e, 0x00, 0x1b, 0x00, 0x26, 0x00, 0x7f, 0xb2, 0x1f, 0x27, 0x28, 0x11, 0x12, 0x39, 0xb0, + 0x1f, 0x10, 0xb0, 0x0b, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1a, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, + 0x2f, 0x1b, 0xb1, 0x0b, 0x14, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x18, 0x2f, 0x1b, 0xb1, 0x18, 0x12, 0x3e, + 0x59, 0xb2, 0x05, 0x03, 0x18, 0x11, 0x12, 0x39, 0xb0, 0x0b, 0x10, 0xb1, 0x12, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x16, 0x03, 0x18, 0x11, 0x12, 0x39, 0xb0, 0x18, 0x10, 0xb1, 0x1f, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x24, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x13, 0x34, 0x12, 0x33, 0x32, 0x17, 0x37, 0x33, 0x11, 0x06, 0x02, 0x23, 0x22, 0x26, + 0x27, 0x37, 0x16, 0x16, 0x33, 0x32, 0x36, 0x35, 0x35, 0x06, 0x23, 0x22, 0x02, 0x35, 0x17, 0x14, 0x16, 0x33, 0x32, + 0x37, 0x11, 0x26, 0x23, 0x22, 0x06, 0x5b, 0xf8, 0xc6, 0xcc, 0x6f, 0x0f, 0x9d, 0x02, 0xf4, 0xe0, 0x56, 0xc8, 0x48, + 0x37, 0x3f, 0x9f, 0x4f, 0x95, 0x8a, 0x6f, 0xc1, 0xc2, 0xfa, 0xb9, 0xa6, 0x8b, 0xaf, 0x53, 0x53, 0xad, 0x8e, 0xa5, + 0x02, 0x26, 0xf6, 0x01, 0x32, 0x94, 0x80, 0xfc, 0x0e, 0xef, 0xfe, 0xfd, 0x37, 0x32, 0x8a, 0x2a, 0x32, 0xb0, 0xa8, + 0x28, 0x81, 0x01, 0x38, 0xf4, 0x07, 0xb0, 0xd9, 0xa1, 0x01, 0xeb, 0x9d, 0xd7, 0x00, 0x02, 0x00, 0x5a, 0xff, 0xec, + 0x04, 0x44, 0x04, 0x4e, 0x00, 0x10, 0x00, 0x1c, 0x00, 0x38, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, + 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x12, 0x3e, 0x59, 0xb1, + 0x14, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0x10, 0xb1, 0x1a, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x13, 0x34, 0x36, 0x36, 0x33, 0x32, 0x00, 0x15, 0x15, 0x14, + 0x06, 0x06, 0x23, 0x22, 0x26, 0x26, 0x27, 0x37, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, + 0x5a, 0x80, 0xe3, 0x90, 0xdd, 0x01, 0x1a, 0x7e, 0xe5, 0x92, 0x8f, 0xe3, 0x81, 0x02, 0xb9, 0xaf, 0x8d, 0x8e, 0xae, + 0xb1, 0x8d, 0x8b, 0xaf, 0x02, 0x27, 0x9c, 0xff, 0x8c, 0xfe, 0xcc, 0xfb, 0x0e, 0x9d, 0xfc, 0x8c, 0x88, 0xf9, 0x9a, + 0x0a, 0xb0, 0xde, 0xe0, 0xc4, 0xaf, 0xe0, 0xde, 0x00, 0x00, 0x02, 0x00, 0x8c, 0xfe, 0x60, 0x04, 0x32, 0x04, 0x4e, + 0x00, 0x10, 0x00, 0x1b, 0x00, 0x70, 0xb2, 0x19, 0x1c, 0x1d, 0x11, 0x12, 0x39, 0xb0, 0x19, 0x10, 0xb0, 0x0d, 0xd0, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x14, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb2, 0x06, 0x0d, 0x04, + 0x11, 0x12, 0x39, 0xb2, 0x0b, 0x0d, 0x04, 0x11, 0x12, 0x39, 0xb0, 0x0d, 0x10, 0xb1, 0x14, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0x10, 0xb1, 0x19, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0x30, 0x31, 0x01, 0x14, 0x06, 0x06, 0x23, 0x22, 0x27, 0x11, 0x23, 0x11, 0x33, 0x17, 0x36, 0x33, 0x32, + 0x12, 0x17, 0x07, 0x34, 0x26, 0x23, 0x22, 0x07, 0x11, 0x16, 0x33, 0x32, 0x36, 0x04, 0x32, 0x6e, 0xc8, 0x81, 0xc5, + 0x71, 0xb9, 0x9f, 0x0f, 0x74, 0xca, 0xc1, 0xee, 0x0a, 0xb8, 0xa9, 0x8f, 0xa8, 0x54, 0x53, 0xab, 0x8c, 0xaa, 0x02, + 0x11, 0x9e, 0xfc, 0x8b, 0x7d, 0xfd, 0xf7, 0x05, 0xda, 0x7d, 0x91, 0xfe, 0xe9, 0xea, 0x27, 0xb0, 0xdb, 0x95, 0xfd, + 0xfb, 0x94, 0xdf, 0x00, 0x00, 0x02, 0x00, 0x5b, 0xfe, 0x60, 0x03, 0xff, 0x04, 0x4e, 0x00, 0x0f, 0x00, 0x1a, 0x00, + 0x6d, 0xb2, 0x18, 0x1b, 0x1c, 0x11, 0x12, 0x39, 0xb0, 0x18, 0x10, 0xb0, 0x03, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, + 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x14, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x12, 0x3e, 0x59, 0xb2, 0x05, 0x03, 0x0c, 0x11, 0x12, 0x39, 0xb2, 0x0a, + 0x03, 0x0c, 0x11, 0x12, 0x39, 0xb1, 0x13, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, + 0x10, 0xb1, 0x18, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x13, 0x34, 0x12, 0x33, + 0x32, 0x17, 0x37, 0x33, 0x11, 0x23, 0x11, 0x06, 0x23, 0x22, 0x02, 0x35, 0x17, 0x14, 0x16, 0x33, 0x32, 0x37, 0x11, + 0x26, 0x23, 0x22, 0x06, 0x5b, 0xf7, 0xcc, 0xc4, 0x6f, 0x0e, 0xa0, 0xb9, 0x70, 0xba, 0xc7, 0xfa, 0xb9, 0xaa, 0x8c, + 0xa6, 0x56, 0x58, 0xa2, 0x8e, 0xaa, 0x02, 0x25, 0xf5, 0x01, 0x34, 0x86, 0x72, 0xfa, 0x26, 0x02, 0x04, 0x78, 0x01, + 0x35, 0xf6, 0x07, 0xae, 0xdf, 0x93, 0x02, 0x11, 0x8f, 0xdf, 0x00, 0x02, 0x00, 0x5d, 0xff, 0xec, 0x03, 0xf3, 0x04, + 0x4e, 0x00, 0x14, 0x00, 0x1c, 0x00, 0x65, 0xb2, 0x08, 0x1d, 0x1e, 0x11, 0x12, 0x39, 0xb0, 0x08, 0x10, 0xb0, 0x15, + 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb2, 0x19, 0x08, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x19, 0x2f, + 0xb4, 0xbf, 0x19, 0xcf, 0x19, 0x02, 0x5d, 0xb1, 0x0c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb0, 0x00, 0x10, 0xb1, 0x10, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, 0x10, 0xb1, + 0x15, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x05, 0x22, 0x00, 0x27, 0x27, 0x34, + 0x36, 0x36, 0x33, 0x32, 0x12, 0x15, 0x15, 0x21, 0x16, 0x16, 0x33, 0x32, 0x37, 0x17, 0x06, 0x01, 0x22, 0x06, 0x07, + 0x21, 0x35, 0x34, 0x26, 0x02, 0x71, 0xe5, 0xfe, 0xdd, 0x0b, 0x01, 0x7c, 0xdd, 0x80, 0xd5, 0xe8, 0xfd, 0x24, 0x08, + 0xc2, 0x99, 0xa0, 0x78, 0x39, 0x83, 0xfe, 0xee, 0x73, 0x98, 0x11, 0x02, 0x20, 0x89, 0x14, 0x01, 0x17, 0xe3, 0x4e, + 0x9b, 0xf5, 0x8a, 0xfe, 0xfe, 0xf0, 0x74, 0x9d, 0xc8, 0x5a, 0x7f, 0x72, 0x03, 0xca, 0xa0, 0x96, 0x19, 0x83, 0x9a, + 0x00, 0x00, 0x02, 0x00, 0x60, 0xfe, 0x56, 0x03, 0xf2, 0x04, 0x4e, 0x00, 0x1a, 0x00, 0x25, 0x00, 0x7f, 0xb2, 0x23, + 0x26, 0x27, 0x11, 0x12, 0x39, 0xb0, 0x23, 0x10, 0xb0, 0x0b, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, + 0x1b, 0xb1, 0x03, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1a, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x14, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x17, + 0x2f, 0x1b, 0xb1, 0x17, 0x12, 0x3e, 0x59, 0xb2, 0x05, 0x03, 0x17, 0x11, 0x12, 0x39, 0xb0, 0x0b, 0x10, 0xb1, 0x11, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x15, 0x03, 0x17, 0x11, 0x12, 0x39, 0xb0, 0x17, + 0x10, 0xb1, 0x1e, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x23, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x13, 0x34, 0x12, 0x33, 0x32, 0x17, 0x37, 0x33, + 0x11, 0x14, 0x06, 0x23, 0x22, 0x26, 0x27, 0x37, 0x16, 0x33, 0x32, 0x36, 0x35, 0x35, 0x06, 0x23, 0x22, 0x02, 0x35, + 0x17, 0x14, 0x16, 0x33, 0x32, 0x37, 0x11, 0x26, 0x23, 0x22, 0x06, 0x60, 0xe8, 0xc3, 0xca, 0x70, 0x10, 0x9d, 0xf5, + 0xe1, 0x52, 0xaf, 0x41, 0x37, 0x7a, 0x8f, 0x95, 0x89, 0x6f, 0xc0, 0xbe, 0xeb, 0xba, 0x95, 0x88, 0xaf, 0x52, 0x55, + 0xaa, 0x89, 0x96, 0x02, 0x25, 0xfa, 0x01, 0x2f, 0x93, 0x7f, 0xfc, 0x05, 0xea, 0xff, 0x2d, 0x29, 0x8a, 0x49, 0xa7, + 0x9e, 0x3a, 0x80, 0x01, 0x32, 0xfa, 0x08, 0xb5, 0xd3, 0xa0, 0x01, 0xee, 0x9b, 0xd0, 0x00, 0xff, 0xff, 0x00, 0x57, + 0x00, 0x00, 0x02, 0x86, 0x05, 0xb7, 0x00, 0x06, 0x00, 0x15, 0xad, 0x00, 0x00, 0x03, 0x00, 0x67, 0xff, 0xf0, 0x04, + 0x91, 0x04, 0x9d, 0x00, 0x1d, 0x00, 0x26, 0x00, 0x32, 0x00, 0x9a, 0xb2, 0x2c, 0x33, 0x34, 0x11, 0x12, 0x39, 0xb0, + 0x2c, 0x10, 0xb0, 0x0e, 0xd0, 0xb0, 0x2c, 0x10, 0xb0, 0x1f, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, + 0x1b, 0xb1, 0x0d, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x1a, 0x2f, 0x1b, 0xb1, 0x1a, 0x12, 0x3e, 0x59, 0xb2, 0x2a, 0x0d, 0x1a, 0x11, 0x12, + 0x39, 0xb2, 0x21, 0x0d, 0x1a, 0x11, 0x12, 0x39, 0xb2, 0x07, 0x2a, 0x21, 0x11, 0x12, 0x39, 0xb2, 0x13, 0x21, 0x2a, + 0x11, 0x12, 0x39, 0xb0, 0x00, 0x10, 0xb1, 0x1e, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, + 0x14, 0x1e, 0x0d, 0x11, 0x12, 0x39, 0xb2, 0x16, 0x0d, 0x00, 0x11, 0x12, 0x39, 0xb2, 0x1c, 0x00, 0x0d, 0x11, 0x12, + 0x39, 0xb2, 0x19, 0x14, 0x1c, 0x11, 0x12, 0x39, 0xb2, 0x20, 0x1e, 0x14, 0x11, 0x12, 0x39, 0xb0, 0x0d, 0x10, 0xb1, + 0x30, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x05, 0x22, 0x26, 0x35, 0x34, 0x36, + 0x37, 0x37, 0x27, 0x26, 0x35, 0x34, 0x36, 0x33, 0x32, 0x16, 0x15, 0x14, 0x07, 0x07, 0x01, 0x36, 0x35, 0x33, 0x14, + 0x07, 0x17, 0x23, 0x27, 0x06, 0x27, 0x32, 0x37, 0x01, 0x07, 0x06, 0x15, 0x14, 0x16, 0x03, 0x14, 0x17, 0x17, 0x37, + 0x36, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x01, 0xe8, 0xab, 0xd6, 0x4e, 0x68, 0x4b, 0x4b, 0x5d, 0xad, 0x90, 0x86, + 0xb1, 0x9b, 0x49, 0x01, 0x0c, 0x45, 0xa8, 0x7f, 0xc7, 0xd2, 0x5e, 0x97, 0xd1, 0x91, 0x6a, 0xfe, 0xdb, 0x64, 0x4c, + 0x6b, 0x15, 0x3f, 0x36, 0x42, 0x53, 0x48, 0x42, 0x38, 0x48, 0x10, 0xa5, 0x81, 0x56, 0x86, 0x4b, 0x36, 0x4f, 0x68, + 0x6c, 0x73, 0x94, 0x96, 0x70, 0x90, 0x6f, 0x34, 0xfe, 0xe3, 0x74, 0x9d, 0xe0, 0xa6, 0xd2, 0x61, 0x71, 0x99, 0x4b, + 0x01, 0x33, 0x49, 0x3b, 0x54, 0x49, 0x5d, 0x03, 0x00, 0x3a, 0x46, 0x39, 0x30, 0x3c, 0x4d, 0x34, 0x45, 0x46, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x03, 0x8b, 0x04, 0x8d, 0x00, 0x0d, 0x00, 0x61, 0xb2, 0x00, 0x0e, 0x0f, 0x11, 0x12, + 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb2, 0x0d, 0x04, 0x0a, 0x11, 0x12, 0x39, 0xb0, 0x0d, 0x2f, + 0xb1, 0x00, 0x02, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x01, 0xd0, 0xb0, 0x04, 0x10, 0xb1, + 0x02, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x01, 0x10, 0xb0, 0x06, 0xd0, 0xb0, 0x07, + 0xd0, 0xb0, 0x0d, 0x10, 0xb0, 0x0c, 0xd0, 0xb0, 0x09, 0xd0, 0xb0, 0x08, 0xd0, 0x30, 0x31, 0x01, 0x05, 0x11, 0x21, + 0x15, 0x21, 0x11, 0x07, 0x35, 0x37, 0x11, 0x33, 0x11, 0x25, 0x02, 0x4d, 0xfe, 0xf6, 0x02, 0x48, 0xfc, 0xff, 0x8a, + 0x8a, 0xb9, 0x01, 0x0a, 0x02, 0x91, 0x55, 0xfe, 0x5b, 0x97, 0x02, 0x02, 0x2c, 0x7d, 0x2c, 0x02, 0x0e, 0xfe, 0x2c, + 0x55, 0x00, 0x02, 0x00, 0x09, 0x00, 0x00, 0x05, 0xf1, 0x04, 0x8d, 0x00, 0x0f, 0x00, 0x12, 0x00, 0x88, 0xb2, 0x05, + 0x13, 0x14, 0x11, 0x12, 0x39, 0xb0, 0x05, 0x10, 0xb0, 0x11, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, + 0x1b, 0xb1, 0x0a, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x12, 0x3e, 0x59, 0xb2, 0x0f, 0x0a, 0x04, 0x11, 0x12, + 0x39, 0xb0, 0x0f, 0x2f, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0x10, + 0xb1, 0x02, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x11, 0x0a, 0x04, 0x11, 0x12, 0x39, + 0xb0, 0x11, 0x2f, 0xb1, 0x06, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0a, 0x10, 0xb1, + 0x0c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x12, 0x0a, 0x04, 0x11, 0x12, 0x39, 0x30, + 0x31, 0x01, 0x21, 0x13, 0x21, 0x15, 0x21, 0x03, 0x21, 0x03, 0x23, 0x01, 0x21, 0x15, 0x21, 0x13, 0x21, 0x05, 0x21, + 0x03, 0x05, 0x88, 0xfe, 0x35, 0x0e, 0x02, 0x26, 0xfd, 0x26, 0x0b, 0xfe, 0x66, 0xa3, 0xc6, 0x02, 0x96, 0x03, 0x29, + 0xfd, 0xe4, 0x0c, 0x01, 0xd0, 0xfc, 0x3b, 0x01, 0x44, 0x13, 0x02, 0x15, 0xfe, 0x80, 0x95, 0x01, 0x2d, 0xfe, 0xd3, + 0x04, 0x8d, 0x96, 0xfe, 0xb4, 0xe7, 0x02, 0x32, 0x00, 0x02, 0x00, 0x8a, 0x00, 0x00, 0x03, 0xb7, 0x04, 0x8d, 0x00, + 0x0c, 0x00, 0x15, 0x00, 0x59, 0xb2, 0x15, 0x16, 0x17, 0x11, 0x12, 0x39, 0xb0, 0x15, 0x10, 0xb0, 0x09, 0xd0, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, + 0x2f, 0x1b, 0xb1, 0x0b, 0x12, 0x3e, 0x59, 0xb2, 0x02, 0x00, 0x0b, 0x11, 0x12, 0x39, 0xb0, 0x02, 0x2f, 0xb2, 0x0f, + 0x00, 0x0b, 0x11, 0x12, 0x39, 0xb0, 0x0f, 0x2f, 0xb1, 0x09, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb0, 0x02, 0x10, 0xb1, 0x0d, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x13, + 0x33, 0x15, 0x33, 0x16, 0x16, 0x15, 0x14, 0x06, 0x23, 0x23, 0x15, 0x23, 0x13, 0x11, 0x33, 0x32, 0x36, 0x35, 0x34, + 0x26, 0x27, 0x8a, 0xb9, 0xc5, 0xc4, 0xeb, 0xea, 0xd6, 0xb4, 0xb9, 0xb9, 0xb6, 0x80, 0x84, 0x88, 0x77, 0x04, 0x8d, + 0xcb, 0x04, 0xc5, 0xa6, 0xa9, 0xbe, 0xec, 0x03, 0x2a, 0xfe, 0x5a, 0x6c, 0x62, 0x60, 0x77, 0x01, 0x00, 0x03, 0x00, + 0x60, 0xff, 0xc7, 0x04, 0x5a, 0x04, 0xb6, 0x00, 0x15, 0x00, 0x1e, 0x00, 0x27, 0x00, 0x6a, 0xb2, 0x06, 0x28, 0x29, + 0x11, 0x12, 0x39, 0xb0, 0x06, 0x10, 0xb0, 0x1b, 0xd0, 0xb0, 0x06, 0x10, 0xb0, 0x24, 0xd0, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x11, 0x2f, 0x1b, 0xb1, 0x11, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, + 0x06, 0x12, 0x3e, 0x59, 0xb2, 0x18, 0x11, 0x06, 0x11, 0x12, 0x39, 0xb2, 0x19, 0x11, 0x06, 0x11, 0x12, 0x39, 0xb0, + 0x11, 0x10, 0xb1, 0x1b, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x21, 0x11, 0x06, 0x11, + 0x12, 0x39, 0xb2, 0x22, 0x06, 0x11, 0x11, 0x12, 0x39, 0xb0, 0x06, 0x10, 0xb1, 0x24, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x16, 0x11, 0x15, 0x10, 0x00, 0x23, 0x22, 0x27, 0x07, 0x23, 0x37, + 0x26, 0x11, 0x35, 0x10, 0x00, 0x33, 0x32, 0x17, 0x37, 0x33, 0x01, 0x14, 0x17, 0x01, 0x26, 0x23, 0x22, 0x06, 0x15, + 0x25, 0x34, 0x27, 0x01, 0x16, 0x33, 0x32, 0x36, 0x35, 0x03, 0xd6, 0x84, 0xfe, 0xec, 0xe8, 0x9a, 0x74, 0x4b, 0x95, + 0x7f, 0x8f, 0x01, 0x17, 0xe5, 0xa1, 0x7b, 0x45, 0x95, 0xfc, 0xc5, 0x3d, 0x01, 0xc9, 0x4f, 0x72, 0x96, 0xaf, 0x02, + 0x8c, 0x34, 0xfe, 0x3b, 0x4a, 0x6a, 0x9c, 0xa9, 0x03, 0xfc, 0x99, 0xfe, 0xff, 0x3e, 0xfe, 0xfb, 0xfe, 0xd1, 0x47, + 0x70, 0xbe, 0x9a, 0x01, 0x09, 0x3f, 0x01, 0x02, 0x01, 0x34, 0x4e, 0x67, 0xfd, 0x6e, 0x9f, 0x69, 0x02, 0xaa, 0x3b, + 0xd6, 0xc5, 0x03, 0x97, 0x62, 0xfd, 0x5c, 0x34, 0xd3, 0xc7, 0x00, 0x00, 0x02, 0x00, 0x30, 0x00, 0x00, 0x04, 0xb3, + 0x04, 0x8d, 0x00, 0x13, 0x00, 0x17, 0x00, 0x8d, 0xb2, 0x03, 0x18, 0x19, 0x11, 0x12, 0x39, 0xb0, 0x03, 0x10, 0xb0, + 0x14, 0xd0, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, + 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x12, 0x3e, 0x59, 0xb2, 0x13, + 0x0c, 0x02, 0x11, 0x12, 0x39, 0xb0, 0x13, 0x2f, 0xb2, 0x0f, 0x13, 0x01, 0x5d, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x15, 0x0c, 0x02, 0x11, 0x12, 0x39, 0xb0, 0x15, 0x2f, 0xb1, 0x04, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x00, 0x10, 0xb0, 0x08, 0xd0, 0xb0, 0x13, 0x10, 0xb0, + 0x0a, 0xd0, 0xb0, 0x13, 0x10, 0xb0, 0x0e, 0xd0, 0xb0, 0x00, 0x10, 0xb0, 0x16, 0xd0, 0x30, 0x31, 0x01, 0x23, 0x11, + 0x23, 0x11, 0x21, 0x11, 0x23, 0x11, 0x23, 0x35, 0x33, 0x35, 0x33, 0x15, 0x21, 0x35, 0x33, 0x15, 0x33, 0x01, 0x21, + 0x35, 0x21, 0x04, 0xb3, 0x5b, 0xb9, 0xfd, 0xa4, 0xb9, 0x5a, 0x5a, 0xb9, 0x02, 0x5c, 0xb9, 0x5b, 0xfc, 0x90, 0x02, + 0x5c, 0xfd, 0xa4, 0x03, 0x4f, 0xfc, 0xb1, 0x01, 0xf2, 0xfe, 0x0e, 0x03, 0x4f, 0x97, 0xa7, 0xa7, 0xa7, 0xa7, 0xfe, + 0xa4, 0xc5, 0x00, 0x00, 0x01, 0x00, 0x8a, 0xfe, 0x4b, 0x04, 0x58, 0x04, 0x8d, 0x00, 0x13, 0x00, 0x5b, 0xb2, 0x02, + 0x14, 0x15, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x1c, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0f, 0x2f, 0x1b, 0xb1, 0x0f, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, + 0x2f, 0x1b, 0xb1, 0x00, 0x14, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x12, 0x3e, + 0x59, 0xb0, 0x00, 0x10, 0xb1, 0x05, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x09, 0x0c, + 0x0a, 0x11, 0x12, 0x39, 0xb2, 0x0e, 0x0a, 0x0c, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x22, 0x27, 0x37, 0x16, 0x33, + 0x32, 0x35, 0x35, 0x01, 0x11, 0x23, 0x11, 0x33, 0x01, 0x11, 0x33, 0x11, 0x14, 0x06, 0x03, 0x17, 0x3c, 0x34, 0x0d, + 0x23, 0x40, 0x88, 0xfd, 0xa4, 0xb9, 0xb9, 0x02, 0x5d, 0xb8, 0xaa, 0xfe, 0x4b, 0x12, 0x9d, 0x0d, 0xc3, 0x51, 0x03, + 0x6b, 0xfc, 0x94, 0x04, 0x8d, 0xfc, 0x93, 0x03, 0x6d, 0xfb, 0x1a, 0xa9, 0xb3, 0xff, 0xff, 0x00, 0x25, 0x02, 0x1f, + 0x02, 0x0d, 0x02, 0xb6, 0x02, 0x06, 0x00, 0x11, 0x00, 0x00, 0x00, 0x02, 0x00, 0x07, 0x00, 0x00, 0x04, 0xe4, 0x05, + 0xb0, 0x00, 0x0f, 0x00, 0x1d, 0x00, 0x69, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x1e, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb2, 0x04, 0x00, 0x05, + 0x11, 0x12, 0x39, 0xb0, 0x04, 0x2f, 0xb2, 0xcf, 0x04, 0x01, 0x5d, 0xb2, 0x2f, 0x04, 0x01, 0x5d, 0xb2, 0x9f, 0x04, + 0x01, 0x71, 0xb1, 0x01, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x11, 0xd0, 0xb0, 0x00, + 0x10, 0xb1, 0x12, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x05, 0x10, 0xb1, 0x1b, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0x10, 0xb0, 0x1c, 0xd0, 0x30, 0x31, 0x33, 0x11, + 0x23, 0x35, 0x33, 0x11, 0x21, 0x32, 0x04, 0x12, 0x17, 0x15, 0x14, 0x02, 0x04, 0x07, 0x13, 0x23, 0x11, 0x33, 0x32, + 0x12, 0x37, 0x35, 0x34, 0x02, 0x27, 0x23, 0x11, 0x33, 0xc7, 0xc0, 0xc0, 0x01, 0x9b, 0xbe, 0x01, 0x24, 0x9f, 0x01, + 0x9f, 0xfe, 0xd9, 0xc4, 0x29, 0xfc, 0xc9, 0xde, 0xf7, 0x01, 0xe9, 0xd6, 0xe0, 0xfc, 0x02, 0x9a, 0x97, 0x02, 0x7f, + 0xa8, 0xfe, 0xca, 0xc9, 0x5d, 0xce, 0xfe, 0xca, 0xa6, 0x02, 0x02, 0x9a, 0xfe, 0x03, 0x01, 0x12, 0xf9, 0x5d, 0xf8, + 0x01, 0x13, 0x02, 0xfe, 0x1f, 0x00, 0x02, 0x00, 0x07, 0x00, 0x00, 0x04, 0xe4, 0x05, 0xb0, 0x00, 0x0f, 0x00, 0x1d, + 0x00, 0x69, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb2, 0x04, 0x00, 0x05, 0x11, 0x12, 0x39, 0xb0, 0x04, + 0x2f, 0xb2, 0xcf, 0x04, 0x01, 0x5d, 0xb2, 0x2f, 0x04, 0x01, 0x5d, 0xb2, 0x9f, 0x04, 0x01, 0x71, 0xb1, 0x01, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x11, 0xd0, 0xb0, 0x00, 0x10, 0xb1, 0x12, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x05, 0x10, 0xb1, 0x1b, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0x10, 0xb0, 0x1c, 0xd0, 0x30, 0x31, 0x33, 0x11, 0x23, 0x35, 0x33, 0x11, 0x21, + 0x32, 0x04, 0x12, 0x17, 0x15, 0x14, 0x02, 0x04, 0x07, 0x13, 0x23, 0x11, 0x33, 0x32, 0x12, 0x37, 0x35, 0x34, 0x02, + 0x27, 0x23, 0x11, 0x33, 0xc7, 0xc0, 0xc0, 0x01, 0x9b, 0xbe, 0x01, 0x24, 0x9f, 0x01, 0x9f, 0xfe, 0xd9, 0xc4, 0x29, + 0xfc, 0xc9, 0xde, 0xf7, 0x01, 0xe9, 0xd6, 0xe0, 0xfc, 0x02, 0x9a, 0x97, 0x02, 0x7f, 0xa8, 0xfe, 0xca, 0xc9, 0x5d, + 0xce, 0xfe, 0xca, 0xa6, 0x02, 0x02, 0x9a, 0xfe, 0x03, 0x01, 0x12, 0xf9, 0x5d, 0xf8, 0x01, 0x13, 0x02, 0xfe, 0x1f, + 0x00, 0x01, 0xff, 0xe2, 0x00, 0x00, 0x03, 0xfd, 0x06, 0x00, 0x00, 0x19, 0x00, 0x6c, 0x00, 0xb0, 0x17, 0x2f, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, + 0x1b, 0xb1, 0x10, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x12, 0x3e, 0x59, + 0xb2, 0x2f, 0x17, 0x01, 0x5d, 0xb2, 0x0f, 0x17, 0x01, 0x5d, 0xb2, 0x15, 0x10, 0x17, 0x11, 0x12, 0x39, 0xb0, 0x15, + 0x2f, 0xb1, 0x12, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x01, 0xd0, 0xb2, 0x02, 0x10, + 0x04, 0x11, 0x12, 0x39, 0xb0, 0x04, 0x10, 0xb1, 0x0c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb0, 0x15, 0x10, 0xb0, 0x18, 0xd0, 0x30, 0x31, 0x01, 0x23, 0x11, 0x36, 0x33, 0x20, 0x13, 0x11, 0x23, 0x11, 0x26, + 0x26, 0x23, 0x22, 0x06, 0x07, 0x11, 0x23, 0x11, 0x23, 0x35, 0x33, 0x35, 0x33, 0x15, 0x33, 0x02, 0x5e, 0xfb, 0x7b, + 0xc5, 0x01, 0x57, 0x03, 0xb9, 0x01, 0x69, 0x6f, 0x5a, 0x88, 0x26, 0xb9, 0xc8, 0xc8, 0xb9, 0xfb, 0x04, 0xd2, 0xfe, + 0xe5, 0x97, 0xfe, 0x7d, 0xfd, 0x35, 0x02, 0xcc, 0x75, 0x70, 0x60, 0x4e, 0xfc, 0xfd, 0x04, 0xd2, 0x97, 0x97, 0x97, + 0x00, 0x01, 0x00, 0x31, 0x00, 0x00, 0x04, 0x97, 0x05, 0xb0, 0x00, 0x0f, 0x00, 0x4e, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, + 0x12, 0x3e, 0x59, 0xb2, 0x0f, 0x0a, 0x02, 0x11, 0x12, 0x39, 0xb0, 0x0f, 0x2f, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0xd0, 0xb0, 0x0f, 0x10, 0xb0, 0x06, 0xd0, 0xb0, 0x0a, 0x10, 0xb1, + 0x08, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0c, 0xd0, 0x30, 0x31, 0x01, 0x23, 0x11, + 0x23, 0x11, 0x23, 0x35, 0x33, 0x11, 0x21, 0x35, 0x21, 0x15, 0x21, 0x11, 0x33, 0x03, 0xaa, 0xe7, 0xbf, 0xd6, 0xd6, + 0xfe, 0x2d, 0x04, 0x66, 0xfe, 0x2c, 0xe7, 0x03, 0x37, 0xfc, 0xc9, 0x03, 0x37, 0x97, 0x01, 0x44, 0x9e, 0x9e, 0xfe, + 0xbc, 0x00, 0x01, 0xff, 0xf4, 0xff, 0xec, 0x02, 0x70, 0x05, 0x40, 0x00, 0x1d, 0x00, 0x76, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x11, 0x2f, 0x1b, 0xb1, + 0x11, 0x12, 0x3e, 0x59, 0xb0, 0x01, 0x10, 0xb0, 0x00, 0xd0, 0xb0, 0x00, 0x2f, 0xb0, 0x01, 0x10, 0xb1, 0x04, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x01, 0x10, 0xb0, 0x05, 0xd0, 0xb0, 0x05, 0x2f, 0xb2, + 0x00, 0x05, 0x01, 0x5d, 0xb1, 0x08, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x11, 0x10, + 0xb1, 0x0c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, 0x10, 0xb0, 0x15, 0xd0, 0xb0, + 0x05, 0x10, 0xb0, 0x18, 0xd0, 0xb0, 0x04, 0x10, 0xb0, 0x19, 0xd0, 0xb0, 0x01, 0x10, 0xb0, 0x1c, 0xd0, 0x30, 0x31, + 0x01, 0x11, 0x33, 0x15, 0x23, 0x15, 0x33, 0x15, 0x23, 0x11, 0x14, 0x16, 0x33, 0x32, 0x37, 0x15, 0x06, 0x23, 0x22, + 0x26, 0x35, 0x11, 0x23, 0x35, 0x33, 0x35, 0x23, 0x35, 0x33, 0x11, 0x01, 0x87, 0xca, 0xca, 0xe9, 0xe9, 0x36, 0x41, + 0x20, 0x38, 0x49, 0x45, 0x7c, 0x7e, 0xda, 0xda, 0xc5, 0xc5, 0x05, 0x40, 0xfe, 0xfa, 0x8f, 0xba, 0x97, 0xfe, 0xb2, + 0x41, 0x41, 0x0c, 0x96, 0x14, 0x96, 0x8a, 0x01, 0x4e, 0x97, 0xba, 0x8f, 0x01, 0x06, 0x00, 0xff, 0xff, 0x00, 0x1c, + 0x00, 0x00, 0x05, 0x1d, 0x07, 0x36, 0x02, 0x26, 0x00, 0x25, 0x00, 0x00, 0x01, 0x07, 0x00, 0x44, 0x01, 0x30, 0x01, + 0x36, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1e, 0x3e, 0x59, 0xb1, 0x0c, + 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x1c, 0x00, 0x00, 0x05, 0x1d, 0x07, 0x36, 0x02, 0x26, 0x00, 0x25, 0x00, + 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, 0xbf, 0x01, 0x36, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, + 0x1b, 0xb1, 0x05, 0x1e, 0x3e, 0x59, 0xb1, 0x0d, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x1c, 0x00, 0x00, 0x05, + 0x1d, 0x07, 0x36, 0x02, 0x26, 0x00, 0x25, 0x00, 0x00, 0x01, 0x07, 0x00, 0x9e, 0x00, 0xc9, 0x01, 0x36, 0x00, 0x14, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1e, 0x3e, 0x59, 0xb1, 0x0f, 0x06, 0xf4, 0x30, + 0x31, 0xff, 0xff, 0x00, 0x1c, 0x00, 0x00, 0x05, 0x1d, 0x07, 0x22, 0x02, 0x26, 0x00, 0x25, 0x00, 0x00, 0x01, 0x07, + 0x00, 0xa5, 0x00, 0xc5, 0x01, 0x3a, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, + 0x1e, 0x3e, 0x59, 0xb1, 0x0e, 0x04, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x1c, 0x00, 0x00, 0x05, 0x1d, 0x06, 0xfb, + 0x02, 0x26, 0x00, 0x25, 0x00, 0x00, 0x01, 0x07, 0x00, 0x6a, 0x00, 0xf9, 0x01, 0x36, 0x00, 0x17, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1e, 0x3e, 0x59, 0xb1, 0x11, 0x04, 0xf4, 0xb0, 0x1b, 0xd0, 0x30, + 0x31, 0x00, 0xff, 0xff, 0x00, 0x1c, 0x00, 0x00, 0x05, 0x1d, 0x07, 0x91, 0x02, 0x26, 0x00, 0x25, 0x00, 0x00, 0x01, + 0x07, 0x00, 0xa3, 0x01, 0x50, 0x01, 0x41, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, + 0x04, 0x1e, 0x3e, 0x59, 0xb1, 0x0e, 0x06, 0xf4, 0xb0, 0x18, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x1c, 0x00, + 0x00, 0x05, 0x1d, 0x07, 0x94, 0x02, 0x26, 0x00, 0x25, 0x00, 0x00, 0x00, 0x07, 0x02, 0x27, 0x01, 0x5a, 0x01, 0x22, + 0xff, 0xff, 0x00, 0x77, 0xfe, 0x44, 0x04, 0xd8, 0x05, 0xc4, 0x02, 0x26, 0x00, 0x27, 0x00, 0x00, 0x00, 0x07, 0x00, + 0x79, 0x01, 0xd2, 0xff, 0xf7, 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, 0x04, 0x46, 0x07, 0x42, 0x02, 0x26, 0x00, 0x29, + 0x00, 0x00, 0x01, 0x07, 0x00, 0x44, 0x00, 0xfb, 0x01, 0x42, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, + 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb1, 0x0d, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, + 0x04, 0x46, 0x07, 0x42, 0x02, 0x26, 0x00, 0x29, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, 0x8a, 0x01, 0x42, 0x00, + 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb1, 0x0e, 0x08, 0xf4, + 0x30, 0x31, 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, 0x04, 0x46, 0x07, 0x42, 0x02, 0x26, 0x00, 0x29, 0x00, 0x00, 0x01, + 0x07, 0x00, 0x9e, 0x00, 0x94, 0x01, 0x42, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, + 0x06, 0x1e, 0x3e, 0x59, 0xb1, 0x10, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, 0x04, 0x46, 0x07, + 0x07, 0x02, 0x26, 0x00, 0x29, 0x00, 0x00, 0x01, 0x07, 0x00, 0x6a, 0x00, 0xc4, 0x01, 0x42, 0x00, 0x17, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb1, 0x12, 0x04, 0xf4, 0xb0, 0x1b, 0xd0, + 0x30, 0x31, 0x00, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x01, 0x81, 0x07, 0x42, 0x02, 0x26, 0x00, 0x2d, 0x00, 0x00, + 0x01, 0x07, 0x00, 0x44, 0xff, 0xa7, 0x01, 0x42, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, + 0xb1, 0x02, 0x1e, 0x3e, 0x59, 0xb1, 0x05, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0xb0, 0x00, 0x00, 0x02, 0x51, + 0x07, 0x42, 0x02, 0x26, 0x00, 0x2d, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x00, 0x35, 0x01, 0x42, 0x00, 0x14, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1e, 0x3e, 0x59, 0xb1, 0x06, 0x08, 0xf4, 0x30, 0x31, + 0xff, 0xff, 0xff, 0xe9, 0x00, 0x00, 0x02, 0x46, 0x07, 0x42, 0x02, 0x26, 0x00, 0x2d, 0x00, 0x00, 0x01, 0x07, 0x00, + 0x9e, 0xff, 0x40, 0x01, 0x42, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1e, + 0x3e, 0x59, 0xb1, 0x08, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0xff, 0xd5, 0x00, 0x00, 0x02, 0x5e, 0x07, 0x07, 0x02, + 0x26, 0x00, 0x2d, 0x00, 0x00, 0x01, 0x07, 0x00, 0x6a, 0xff, 0x70, 0x01, 0x42, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1e, 0x3e, 0x59, 0xb1, 0x0a, 0x04, 0xf4, 0xb0, 0x14, 0xd0, 0x30, 0x31, + 0x00, 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, 0x05, 0x08, 0x07, 0x22, 0x02, 0x26, 0x00, 0x32, 0x00, 0x00, 0x01, 0x07, + 0x00, 0xa5, 0x00, 0xfb, 0x01, 0x3a, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, + 0x1e, 0x3e, 0x59, 0xb1, 0x0d, 0x04, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x76, 0xff, 0xec, 0x05, 0x09, 0x07, 0x38, + 0x02, 0x26, 0x00, 0x33, 0x00, 0x00, 0x01, 0x07, 0x00, 0x44, 0x01, 0x52, 0x01, 0x38, 0x00, 0x14, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1e, 0x3e, 0x59, 0xb1, 0x21, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, + 0x00, 0x76, 0xff, 0xec, 0x05, 0x09, 0x07, 0x38, 0x02, 0x26, 0x00, 0x33, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, + 0xe1, 0x01, 0x38, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1e, 0x3e, 0x59, + 0xb1, 0x22, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x76, 0xff, 0xec, 0x05, 0x09, 0x07, 0x38, 0x02, 0x26, 0x00, + 0x33, 0x00, 0x00, 0x01, 0x07, 0x00, 0x9e, 0x00, 0xeb, 0x01, 0x38, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1e, 0x3e, 0x59, 0xb1, 0x22, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x76, 0xff, + 0xec, 0x05, 0x09, 0x07, 0x24, 0x02, 0x26, 0x00, 0x33, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa5, 0x00, 0xe7, 0x01, 0x3c, + 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1e, 0x3e, 0x59, 0xb1, 0x23, 0x04, + 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x76, 0xff, 0xec, 0x05, 0x09, 0x06, 0xfd, 0x02, 0x26, 0x00, 0x33, 0x00, 0x00, + 0x01, 0x07, 0x00, 0x6a, 0x01, 0x1b, 0x01, 0x38, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, + 0xb1, 0x0d, 0x1e, 0x3e, 0x59, 0xb1, 0x27, 0x04, 0xf4, 0xb0, 0x30, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x8c, + 0xff, 0xec, 0x04, 0xaa, 0x07, 0x36, 0x02, 0x26, 0x00, 0x39, 0x00, 0x00, 0x01, 0x07, 0x00, 0x44, 0x01, 0x2b, 0x01, + 0x36, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1e, 0x3e, 0x59, 0xb1, 0x14, + 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x8c, 0xff, 0xec, 0x04, 0xaa, 0x07, 0x36, 0x02, 0x26, 0x00, 0x39, 0x00, + 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, 0xba, 0x01, 0x36, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x12, 0x2f, + 0x1b, 0xb1, 0x12, 0x1e, 0x3e, 0x59, 0xb1, 0x15, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x8c, 0xff, 0xec, 0x04, + 0xaa, 0x07, 0x36, 0x02, 0x26, 0x00, 0x39, 0x00, 0x00, 0x01, 0x07, 0x00, 0x9e, 0x00, 0xc4, 0x01, 0x36, 0x00, 0x14, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1e, 0x3e, 0x59, 0xb1, 0x17, 0x06, 0xf4, 0x30, + 0x31, 0xff, 0xff, 0x00, 0x8c, 0xff, 0xec, 0x04, 0xaa, 0x06, 0xfb, 0x02, 0x26, 0x00, 0x39, 0x00, 0x00, 0x01, 0x07, + 0x00, 0x6a, 0x00, 0xf4, 0x01, 0x36, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, + 0x1e, 0x3e, 0x59, 0xb1, 0x19, 0x04, 0xf4, 0xb0, 0x23, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x0f, 0x00, 0x00, + 0x04, 0xbb, 0x07, 0x36, 0x02, 0x26, 0x00, 0x3d, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, 0x88, 0x01, 0x36, 0x00, + 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x1e, 0x3e, 0x59, 0xb1, 0x0b, 0x08, 0xf4, + 0x30, 0x31, 0xff, 0xff, 0x00, 0x6d, 0xff, 0xec, 0x03, 0xea, 0x06, 0x00, 0x02, 0x26, 0x00, 0x45, 0x00, 0x00, 0x01, + 0x07, 0x00, 0x44, 0x00, 0xd5, 0x00, 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x17, 0x2f, 0x1b, 0xb1, + 0x17, 0x1a, 0x3e, 0x59, 0xb1, 0x2a, 0x09, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x6d, 0xff, 0xec, 0x03, 0xea, 0x06, + 0x00, 0x02, 0x26, 0x00, 0x45, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, 0x64, 0x00, 0x00, 0x00, 0x14, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x17, 0x2f, 0x1b, 0xb1, 0x17, 0x1a, 0x3e, 0x59, 0xb1, 0x2b, 0x09, 0xf4, 0x30, 0x31, 0xff, + 0xff, 0x00, 0x6d, 0xff, 0xec, 0x03, 0xea, 0x06, 0x00, 0x02, 0x26, 0x00, 0x45, 0x00, 0x00, 0x01, 0x06, 0x00, 0x9e, + 0x6e, 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x17, 0x2f, 0x1b, 0xb1, 0x17, 0x1a, 0x3e, 0x59, 0xb1, + 0x2b, 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x6d, 0xff, 0xec, 0x03, 0xea, 0x05, 0xec, 0x02, 0x26, 0x00, 0x45, + 0x00, 0x00, 0x01, 0x06, 0x00, 0xa5, 0x6a, 0x04, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x17, 0x2f, 0x1b, + 0xb1, 0x17, 0x1a, 0x3e, 0x59, 0xb1, 0x2c, 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x6d, 0xff, 0xec, 0x03, 0xea, + 0x05, 0xc5, 0x02, 0x26, 0x00, 0x45, 0x00, 0x00, 0x01, 0x07, 0x00, 0x6a, 0x00, 0x9e, 0x00, 0x00, 0x00, 0x17, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x17, 0x2f, 0x1b, 0xb1, 0x17, 0x1a, 0x3e, 0x59, 0xb1, 0x30, 0x01, 0xf4, 0xb0, 0x39, + 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x6d, 0xff, 0xec, 0x03, 0xea, 0x06, 0x5b, 0x02, 0x26, 0x00, 0x45, 0x00, + 0x00, 0x01, 0x07, 0x00, 0xa3, 0x00, 0xf5, 0x00, 0x0b, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x17, 0x2f, + 0x1b, 0xb1, 0x17, 0x1a, 0x3e, 0x59, 0xb1, 0x2c, 0x04, 0xf4, 0xb0, 0x36, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, + 0x6d, 0xff, 0xec, 0x03, 0xea, 0x06, 0x5f, 0x02, 0x26, 0x00, 0x45, 0x00, 0x00, 0x00, 0x07, 0x02, 0x27, 0x00, 0xff, + 0xff, 0xed, 0xff, 0xff, 0x00, 0x5c, 0xfe, 0x44, 0x03, 0xec, 0x04, 0x4e, 0x02, 0x26, 0x00, 0x47, 0x00, 0x00, 0x00, + 0x07, 0x00, 0x79, 0x01, 0x3f, 0xff, 0xf7, 0xff, 0xff, 0x00, 0x5d, 0xff, 0xec, 0x03, 0xf3, 0x06, 0x00, 0x02, 0x26, + 0x00, 0x49, 0x00, 0x00, 0x01, 0x07, 0x00, 0x44, 0x00, 0xc5, 0x00, 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, 0x3e, 0x59, 0xb1, 0x1f, 0x09, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x5d, + 0xff, 0xec, 0x03, 0xf3, 0x06, 0x00, 0x02, 0x26, 0x00, 0x49, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, 0x54, 0x00, + 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, 0x3e, 0x59, 0xb1, 0x20, + 0x09, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x5d, 0xff, 0xec, 0x03, 0xf3, 0x06, 0x00, 0x02, 0x26, 0x00, 0x49, 0x00, + 0x00, 0x01, 0x06, 0x00, 0x9e, 0x5e, 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, + 0x08, 0x1a, 0x3e, 0x59, 0xb1, 0x20, 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x5d, 0xff, 0xec, 0x03, 0xf3, 0x05, + 0xc5, 0x02, 0x26, 0x00, 0x49, 0x00, 0x00, 0x01, 0x07, 0x00, 0x6a, 0x00, 0x8e, 0x00, 0x00, 0x00, 0x17, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, 0x3e, 0x59, 0xb1, 0x25, 0x01, 0xf4, 0xb0, 0x2e, 0xd0, + 0x30, 0x31, 0x00, 0xff, 0xff, 0xff, 0xc6, 0x00, 0x00, 0x01, 0x67, 0x05, 0xff, 0x02, 0x26, 0x00, 0x8d, 0x00, 0x00, + 0x01, 0x06, 0x00, 0x44, 0x8d, 0xff, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, + 0x1a, 0x3e, 0x59, 0xb1, 0x05, 0x09, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x96, 0x00, 0x00, 0x02, 0x37, 0x05, 0xff, + 0x02, 0x26, 0x00, 0x8d, 0x00, 0x00, 0x01, 0x06, 0x00, 0x75, 0x1b, 0xff, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1a, 0x3e, 0x59, 0xb1, 0x06, 0x09, 0xf4, 0x30, 0x31, 0xff, 0xff, 0xff, 0xcf, + 0x00, 0x00, 0x02, 0x2c, 0x05, 0xff, 0x02, 0x26, 0x00, 0x8d, 0x00, 0x00, 0x01, 0x07, 0x00, 0x9e, 0xff, 0x26, 0xff, + 0xff, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1a, 0x3e, 0x59, 0xb1, 0x08, + 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0xff, 0xbb, 0x00, 0x00, 0x02, 0x44, 0x05, 0xc4, 0x02, 0x26, 0x00, 0x8d, 0x00, + 0x00, 0x01, 0x07, 0x00, 0x6a, 0xff, 0x56, 0xff, 0xff, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, + 0x1b, 0xb1, 0x02, 0x1a, 0x3e, 0x59, 0xb1, 0x0b, 0x01, 0xf4, 0xb0, 0x14, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, + 0x8c, 0x00, 0x00, 0x03, 0xdf, 0x05, 0xec, 0x02, 0x26, 0x00, 0x52, 0x00, 0x00, 0x01, 0x06, 0x00, 0xa5, 0x61, 0x04, + 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1a, 0x3e, 0x59, 0xb1, 0x15, 0x01, + 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x5b, 0xff, 0xec, 0x04, 0x34, 0x06, 0x00, 0x02, 0x26, 0x00, 0x53, 0x00, 0x00, + 0x01, 0x07, 0x00, 0x44, 0x00, 0xcf, 0x00, 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, + 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb1, 0x1d, 0x09, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x5b, 0xff, 0xec, 0x04, 0x34, + 0x06, 0x00, 0x02, 0x26, 0x00, 0x53, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, 0x5e, 0x00, 0x00, 0x00, 0x14, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb1, 0x1e, 0x09, 0xf4, 0x30, 0x31, + 0xff, 0xff, 0x00, 0x5b, 0xff, 0xec, 0x04, 0x34, 0x06, 0x00, 0x02, 0x26, 0x00, 0x53, 0x00, 0x00, 0x01, 0x06, 0x00, + 0x9e, 0x68, 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, + 0xb1, 0x1e, 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x5b, 0xff, 0xec, 0x04, 0x34, 0x05, 0xec, 0x02, 0x26, 0x00, + 0x53, 0x00, 0x00, 0x01, 0x06, 0x00, 0xa5, 0x64, 0x04, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, + 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb1, 0x1f, 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x5b, 0xff, 0xec, 0x04, + 0x34, 0x05, 0xc5, 0x02, 0x26, 0x00, 0x53, 0x00, 0x00, 0x01, 0x07, 0x00, 0x6a, 0x00, 0x98, 0x00, 0x00, 0x00, 0x17, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb1, 0x23, 0x01, 0xf4, 0xb0, + 0x2c, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x88, 0xff, 0xec, 0x03, 0xdc, 0x06, 0x00, 0x02, 0x26, 0x00, 0x59, + 0x00, 0x00, 0x01, 0x07, 0x00, 0x44, 0x00, 0xc7, 0x00, 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, + 0x2f, 0x1b, 0xb1, 0x07, 0x1a, 0x3e, 0x59, 0xb1, 0x12, 0x09, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x88, 0xff, 0xec, + 0x03, 0xdc, 0x06, 0x00, 0x02, 0x26, 0x00, 0x59, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, 0x56, 0x00, 0x00, 0x00, + 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1a, 0x3e, 0x59, 0xb1, 0x13, 0x09, 0xf4, + 0x30, 0x31, 0xff, 0xff, 0x00, 0x88, 0xff, 0xec, 0x03, 0xdc, 0x06, 0x00, 0x02, 0x26, 0x00, 0x59, 0x00, 0x00, 0x01, + 0x06, 0x00, 0x9e, 0x60, 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1a, + 0x3e, 0x59, 0xb1, 0x15, 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x88, 0xff, 0xec, 0x03, 0xdc, 0x05, 0xc5, 0x02, + 0x26, 0x00, 0x59, 0x00, 0x00, 0x01, 0x07, 0x00, 0x6a, 0x00, 0x90, 0x00, 0x00, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1a, 0x3e, 0x59, 0xb1, 0x18, 0x01, 0xf4, 0xb0, 0x21, 0xd0, 0x30, 0x31, + 0x00, 0xff, 0xff, 0x00, 0x16, 0xfe, 0x4b, 0x03, 0xb0, 0x06, 0x00, 0x02, 0x26, 0x00, 0x5d, 0x00, 0x00, 0x01, 0x07, + 0x00, 0x75, 0x01, 0x1b, 0x00, 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, + 0x1a, 0x3e, 0x59, 0xb1, 0x12, 0x09, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x16, 0xfe, 0x4b, 0x03, 0xb0, 0x05, 0xc5, + 0x02, 0x26, 0x00, 0x5d, 0x00, 0x00, 0x01, 0x06, 0x00, 0x6a, 0x55, 0x00, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x0f, 0x2f, 0x1b, 0xb1, 0x0f, 0x1a, 0x3e, 0x59, 0xb1, 0x17, 0x01, 0xf4, 0xb0, 0x20, 0xd0, 0x30, 0x31, 0x00, + 0xff, 0xff, 0x00, 0x1c, 0x00, 0x00, 0x05, 0x1d, 0x06, 0xe3, 0x02, 0x26, 0x00, 0x25, 0x00, 0x00, 0x01, 0x07, 0x00, + 0x70, 0x00, 0xc7, 0x01, 0x3e, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1e, + 0x3e, 0x59, 0xb0, 0x0c, 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x6d, 0xff, 0xec, 0x03, 0xea, 0x05, 0xad, 0x02, + 0x26, 0x00, 0x45, 0x00, 0x00, 0x01, 0x06, 0x00, 0x70, 0x6c, 0x08, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x17, 0x2f, 0x1b, 0xb1, 0x17, 0x1a, 0x3e, 0x59, 0xb0, 0x2a, 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x1c, 0x00, + 0x00, 0x05, 0x1d, 0x07, 0x0e, 0x02, 0x26, 0x00, 0x25, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa1, 0x00, 0xf4, 0x01, 0x37, + 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1e, 0x3e, 0x59, 0xb0, 0x0d, 0xdc, + 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x6d, 0xff, 0xec, 0x03, 0xea, 0x05, 0xd8, 0x02, 0x26, 0x00, 0x45, 0x00, 0x00, + 0x01, 0x07, 0x00, 0xa1, 0x00, 0x99, 0x00, 0x01, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x17, 0x2f, 0x1b, + 0xb1, 0x17, 0x1a, 0x3e, 0x59, 0xb0, 0x2b, 0xdc, 0x30, 0x31, 0x00, 0x00, 0x02, 0x00, 0x1c, 0xfe, 0x4f, 0x05, 0x1d, + 0x05, 0xb0, 0x00, 0x16, 0x00, 0x19, 0x00, 0x69, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x16, 0x2f, 0x1b, 0xb1, 0x16, + 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x14, 0x2f, 0x1b, 0xb1, 0x14, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, + 0x0c, 0x14, 0x3e, 0x59, 0xb1, 0x07, 0x03, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x01, 0x10, + 0xb0, 0x11, 0xd0, 0xb0, 0x11, 0x2f, 0xb2, 0x17, 0x14, 0x16, 0x11, 0x12, 0x39, 0xb0, 0x17, 0x2f, 0xb1, 0x13, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x19, 0x16, 0x14, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, + 0x01, 0x23, 0x07, 0x06, 0x15, 0x14, 0x33, 0x32, 0x37, 0x17, 0x06, 0x23, 0x22, 0x26, 0x35, 0x34, 0x37, 0x03, 0x21, + 0x03, 0x23, 0x01, 0x03, 0x21, 0x03, 0x02, 0xf0, 0x02, 0x2d, 0x26, 0x3a, 0x71, 0x4e, 0x30, 0x34, 0x0d, 0x46, 0x5a, + 0x59, 0x67, 0xa9, 0x87, 0xfd, 0x9e, 0x89, 0xc6, 0x02, 0x2c, 0xa3, 0x01, 0xef, 0xf8, 0x05, 0xb0, 0xfa, 0x50, 0x2d, + 0x5b, 0x56, 0x48, 0x1a, 0x79, 0x2c, 0x68, 0x56, 0x90, 0x6c, 0x01, 0x73, 0xfe, 0x84, 0x05, 0xb0, 0xfc, 0x6a, 0x02, + 0xa9, 0x00, 0x00, 0x02, 0x00, 0x6d, 0xfe, 0x4f, 0x03, 0xea, 0x04, 0x4e, 0x00, 0x2d, 0x00, 0x37, 0x00, 0x94, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x17, 0x2f, 0x1b, 0xb1, 0x17, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, + 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x1e, 0x2f, 0x1b, 0xb1, 0x1e, 0x12, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x29, 0x2f, 0x1b, 0xb1, 0x29, 0x14, 0x3e, 0x59, 0xb0, 0x1e, 0x10, 0xb0, 0x00, + 0xd0, 0xb0, 0x00, 0x2f, 0xb2, 0x02, 0x04, 0x17, 0x11, 0x12, 0x39, 0xb2, 0x0b, 0x17, 0x04, 0x11, 0x12, 0x39, 0xb0, + 0x0b, 0x2f, 0xb0, 0x17, 0x10, 0xb1, 0x0f, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x12, + 0x0b, 0x17, 0x11, 0x12, 0x39, 0xb0, 0x29, 0x10, 0xb1, 0x24, 0x03, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, + 0x59, 0xb0, 0x04, 0x10, 0xb1, 0x2e, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0b, 0x10, + 0xb1, 0x33, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x25, 0x26, 0x27, 0x06, 0x23, + 0x22, 0x26, 0x35, 0x34, 0x24, 0x33, 0x33, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x23, 0x34, 0x36, 0x36, 0x33, + 0x32, 0x16, 0x17, 0x11, 0x14, 0x17, 0x15, 0x23, 0x07, 0x06, 0x15, 0x14, 0x33, 0x32, 0x37, 0x17, 0x06, 0x23, 0x22, + 0x26, 0x35, 0x34, 0x27, 0x32, 0x36, 0x37, 0x35, 0x23, 0x20, 0x15, 0x14, 0x16, 0x03, 0x24, 0x0f, 0x07, 0x81, 0xb3, + 0xa0, 0xcd, 0x01, 0x01, 0xe9, 0xb4, 0x74, 0x71, 0x63, 0x86, 0xba, 0x73, 0xc5, 0x76, 0xbb, 0xd4, 0x04, 0x26, 0x21, + 0x3a, 0x71, 0x4e, 0x30, 0x34, 0x0d, 0x46, 0x5a, 0x59, 0x67, 0x88, 0x57, 0x9c, 0x23, 0x91, 0xfe, 0xac, 0x74, 0x07, + 0x26, 0x45, 0x86, 0xb5, 0x8b, 0xa9, 0xbb, 0x55, 0x61, 0x73, 0x64, 0x47, 0x51, 0x97, 0x58, 0xbb, 0xa4, 0xfe, 0x0e, + 0x95, 0x58, 0x10, 0x2d, 0x5b, 0x56, 0x48, 0x1a, 0x79, 0x2c, 0x68, 0x56, 0x90, 0xf0, 0x5a, 0x48, 0xde, 0xc7, 0x57, + 0x62, 0x00, 0xff, 0xff, 0x00, 0x77, 0xff, 0xec, 0x04, 0xd8, 0x07, 0x57, 0x02, 0x26, 0x00, 0x27, 0x00, 0x00, 0x01, + 0x07, 0x00, 0x75, 0x01, 0xc6, 0x01, 0x57, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, + 0x0b, 0x1e, 0x3e, 0x59, 0xb1, 0x1f, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x5c, 0xff, 0xec, 0x03, 0xec, 0x06, + 0x00, 0x02, 0x26, 0x00, 0x47, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, 0x33, 0x00, 0x00, 0x00, 0x14, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x1a, 0x3e, 0x59, 0xb1, 0x20, 0x09, 0xf4, 0x30, 0x31, 0xff, + 0xff, 0x00, 0x77, 0xff, 0xec, 0x04, 0xd8, 0x07, 0x57, 0x02, 0x26, 0x00, 0x27, 0x00, 0x00, 0x01, 0x07, 0x00, 0x9e, + 0x00, 0xd0, 0x01, 0x57, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1e, 0x3e, + 0x59, 0xb1, 0x1f, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x5c, 0xff, 0xec, 0x03, 0xec, 0x06, 0x00, 0x02, 0x26, + 0x00, 0x47, 0x00, 0x00, 0x01, 0x06, 0x00, 0x9e, 0x3d, 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, + 0x2f, 0x1b, 0xb1, 0x10, 0x1a, 0x3e, 0x59, 0xb1, 0x20, 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x77, 0xff, 0xec, + 0x04, 0xd8, 0x07, 0x19, 0x02, 0x26, 0x00, 0x27, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa2, 0x01, 0xad, 0x01, 0x57, 0x00, + 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1e, 0x3e, 0x59, 0xb1, 0x23, 0x04, 0xf4, + 0x30, 0x31, 0xff, 0xff, 0x00, 0x5c, 0xff, 0xec, 0x03, 0xec, 0x05, 0xc2, 0x02, 0x26, 0x00, 0x47, 0x00, 0x00, 0x01, + 0x07, 0x00, 0xa2, 0x01, 0x1a, 0x00, 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, + 0x10, 0x1a, 0x3e, 0x59, 0xb1, 0x24, 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x77, 0xff, 0xec, 0x04, 0xd8, 0x07, + 0x57, 0x02, 0x26, 0x00, 0x27, 0x00, 0x00, 0x01, 0x07, 0x00, 0x9f, 0x00, 0xe5, 0x01, 0x58, 0x00, 0x14, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1e, 0x3e, 0x59, 0xb1, 0x21, 0x06, 0xf4, 0x30, 0x31, 0xff, + 0xff, 0x00, 0x5c, 0xff, 0xec, 0x03, 0xec, 0x06, 0x00, 0x02, 0x26, 0x00, 0x47, 0x00, 0x00, 0x01, 0x06, 0x00, 0x9f, + 0x52, 0x01, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x1a, 0x3e, 0x59, 0xb1, + 0x22, 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, 0x04, 0xc6, 0x07, 0x42, 0x02, 0x26, 0x00, 0x28, + 0x00, 0x00, 0x01, 0x07, 0x00, 0x9f, 0x00, 0x9e, 0x01, 0x43, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, + 0x2f, 0x1b, 0xb1, 0x01, 0x1e, 0x3e, 0x59, 0xb1, 0x1b, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x5f, 0xff, 0xec, + 0x05, 0x2b, 0x06, 0x02, 0x00, 0x26, 0x00, 0x48, 0x00, 0x00, 0x01, 0x07, 0x01, 0xba, 0x03, 0xd4, 0x05, 0x13, 0x00, + 0x48, 0x00, 0xb2, 0xf0, 0x1f, 0x01, 0x72, 0xb2, 0x1f, 0x1f, 0x01, 0x5d, 0xb2, 0x9f, 0x1f, 0x01, 0x5d, 0xb2, 0x1f, + 0x1f, 0x01, 0x71, 0xb4, 0xcf, 0x1f, 0xdf, 0x1f, 0x02, 0x71, 0xb2, 0xdf, 0x1f, 0x01, 0x72, 0xb2, 0x5f, 0x1f, 0x01, + 0x72, 0xb2, 0x4f, 0x1f, 0x01, 0x71, 0xb2, 0xcf, 0x1f, 0x01, 0x5d, 0xb4, 0x4f, 0x1f, 0x5f, 0x1f, 0x02, 0x5d, 0xb2, + 0x60, 0x1f, 0x01, 0x5d, 0xb2, 0xe0, 0x1f, 0x01, 0x71, 0xb2, 0xe0, 0x1f, 0x01, 0x5d, 0x30, 0x31, 0xff, 0xff, 0x00, + 0xa9, 0x00, 0x00, 0x04, 0x46, 0x06, 0xef, 0x02, 0x26, 0x00, 0x29, 0x00, 0x00, 0x01, 0x07, 0x00, 0x70, 0x00, 0x92, + 0x01, 0x4a, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb0, + 0x0d, 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x5d, 0xff, 0xec, 0x03, 0xf3, 0x05, 0xad, 0x02, 0x26, 0x00, 0x49, + 0x00, 0x00, 0x01, 0x06, 0x00, 0x70, 0x5c, 0x08, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, + 0xb1, 0x08, 0x1a, 0x3e, 0x59, 0xb0, 0x1f, 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, 0x04, 0x46, + 0x07, 0x1a, 0x02, 0x26, 0x00, 0x29, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa1, 0x00, 0xbf, 0x01, 0x43, 0x00, 0x13, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb0, 0x0f, 0xdc, 0x30, 0x31, 0x00, + 0xff, 0xff, 0x00, 0x5d, 0xff, 0xec, 0x03, 0xf3, 0x05, 0xd8, 0x02, 0x26, 0x00, 0x49, 0x00, 0x00, 0x01, 0x07, 0x00, + 0xa1, 0x00, 0x89, 0x00, 0x01, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, + 0x3e, 0x59, 0xb0, 0x21, 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, 0x04, 0x46, 0x07, 0x04, 0x02, + 0x26, 0x00, 0x29, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa2, 0x01, 0x71, 0x01, 0x42, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb1, 0x13, 0x04, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, + 0x5d, 0xff, 0xec, 0x03, 0xf3, 0x05, 0xc2, 0x02, 0x26, 0x00, 0x49, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa2, 0x01, 0x3b, + 0x00, 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, 0x3e, 0x59, 0xb1, + 0x25, 0x01, 0xf4, 0x30, 0x31, 0x00, 0x01, 0x00, 0xa9, 0xfe, 0x4f, 0x04, 0x46, 0x05, 0xb0, 0x00, 0x1b, 0x00, 0x7a, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x16, 0x2f, 0x1b, 0xb1, 0x16, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x15, 0x2f, 0x1b, 0xb1, 0x15, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0f, 0x2f, 0x1b, 0xb1, 0x0f, 0x14, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb2, 0x1a, 0x15, 0x16, + 0x11, 0x12, 0x39, 0xb0, 0x1a, 0x2f, 0xb1, 0x01, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x15, 0x10, 0xb1, 0x02, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0f, 0x10, 0xb1, 0x0a, + 0x03, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x16, 0x10, 0xb1, 0x19, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, 0x11, 0x21, 0x15, 0x23, 0x07, 0x06, 0x15, 0x14, 0x33, + 0x32, 0x37, 0x17, 0x06, 0x23, 0x22, 0x26, 0x35, 0x34, 0x37, 0x21, 0x11, 0x21, 0x15, 0x21, 0x11, 0x21, 0x03, 0xe0, + 0xfd, 0x89, 0x02, 0xdd, 0x49, 0x3a, 0x71, 0x4e, 0x30, 0x34, 0x0d, 0x46, 0x5a, 0x59, 0x67, 0x9b, 0xfd, 0x5d, 0x03, + 0x93, 0xfd, 0x2d, 0x02, 0x77, 0x02, 0xa1, 0xfd, 0xfc, 0x9d, 0x2d, 0x5b, 0x56, 0x48, 0x1a, 0x79, 0x2c, 0x68, 0x56, + 0x8a, 0x69, 0x05, 0xb0, 0x9e, 0xfe, 0x2c, 0x00, 0x00, 0x02, 0x00, 0x5d, 0xfe, 0x68, 0x03, 0xf3, 0x04, 0x4e, 0x00, + 0x25, 0x00, 0x2d, 0x00, 0x7e, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x1a, 0x2f, 0x1b, 0xb1, 0x1a, 0x1a, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x14, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x12, + 0x2f, 0x1b, 0xb1, 0x12, 0x12, 0x3e, 0x59, 0xb0, 0x04, 0xd0, 0xb0, 0x0d, 0x10, 0xb1, 0x08, 0x03, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x2a, 0x12, 0x1a, 0x11, 0x12, 0x39, 0xb0, 0x2a, 0x2f, 0xb4, 0xbf, 0x2a, + 0xcf, 0x2a, 0x02, 0x5d, 0xb1, 0x1e, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x12, 0x10, + 0xb1, 0x22, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x25, 0x12, 0x1a, 0x11, 0x12, 0x39, + 0xb0, 0x1a, 0x10, 0xb1, 0x26, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x25, 0x06, + 0x07, 0x33, 0x07, 0x06, 0x15, 0x14, 0x33, 0x32, 0x37, 0x17, 0x06, 0x23, 0x22, 0x26, 0x35, 0x34, 0x37, 0x26, 0x00, + 0x35, 0x35, 0x34, 0x36, 0x36, 0x33, 0x32, 0x12, 0x11, 0x15, 0x21, 0x16, 0x16, 0x33, 0x32, 0x36, 0x37, 0x01, 0x22, + 0x06, 0x07, 0x21, 0x35, 0x26, 0x26, 0x03, 0xe5, 0x47, 0x73, 0x01, 0x3a, 0x71, 0x4e, 0x30, 0x34, 0x0d, 0x46, 0x5a, + 0x59, 0x67, 0x62, 0xda, 0xfe, 0xf5, 0x7b, 0xdd, 0x81, 0xd3, 0xea, 0xfd, 0x23, 0x04, 0xb3, 0x8a, 0x62, 0x88, 0x33, + 0xfe, 0xc2, 0x70, 0x98, 0x12, 0x02, 0x1e, 0x08, 0x88, 0xbd, 0x6e, 0x36, 0x2d, 0x5b, 0x56, 0x48, 0x1a, 0x79, 0x2c, + 0x68, 0x56, 0x6c, 0x5a, 0x04, 0x01, 0x21, 0xef, 0x21, 0xa1, 0xfd, 0x8f, 0xfe, 0xea, 0xfe, 0xfd, 0x4d, 0xa0, 0xc5, + 0x50, 0x42, 0x02, 0xa1, 0xa3, 0x93, 0x0e, 0x8d, 0x9b, 0x00, 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, 0x04, 0x46, 0x07, + 0x42, 0x02, 0x26, 0x00, 0x29, 0x00, 0x00, 0x01, 0x07, 0x00, 0x9f, 0x00, 0xa9, 0x01, 0x43, 0x00, 0x14, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb1, 0x11, 0x06, 0xf4, 0x30, 0x31, 0xff, + 0xff, 0x00, 0x5d, 0xff, 0xec, 0x03, 0xf3, 0x06, 0x00, 0x02, 0x26, 0x00, 0x49, 0x00, 0x00, 0x01, 0x06, 0x00, 0x9f, + 0x73, 0x01, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, 0x3e, 0x59, 0xb1, + 0x22, 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x7a, 0xff, 0xec, 0x04, 0xdc, 0x07, 0x57, 0x02, 0x26, 0x00, 0x2b, + 0x00, 0x00, 0x01, 0x07, 0x00, 0x9e, 0x00, 0xc8, 0x01, 0x57, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, + 0x2f, 0x1b, 0xb1, 0x0b, 0x1e, 0x3e, 0x59, 0xb1, 0x22, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x60, 0xfe, 0x56, + 0x03, 0xf2, 0x06, 0x00, 0x02, 0x26, 0x00, 0x4b, 0x00, 0x00, 0x01, 0x06, 0x00, 0x9e, 0x55, 0x00, 0x00, 0x14, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1a, 0x3e, 0x59, 0xb1, 0x27, 0x01, 0xf4, 0x30, 0x31, + 0xff, 0xff, 0x00, 0x7a, 0xff, 0xec, 0x04, 0xdc, 0x07, 0x2f, 0x02, 0x26, 0x00, 0x2b, 0x00, 0x00, 0x01, 0x07, 0x00, + 0xa1, 0x00, 0xf3, 0x01, 0x58, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1e, + 0x3e, 0x59, 0xb0, 0x22, 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x60, 0xfe, 0x56, 0x03, 0xf2, 0x05, 0xd8, 0x02, + 0x26, 0x00, 0x4b, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa1, 0x00, 0x80, 0x00, 0x01, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1a, 0x3e, 0x59, 0xb0, 0x27, 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, + 0x7a, 0xff, 0xec, 0x04, 0xdc, 0x07, 0x19, 0x02, 0x26, 0x00, 0x2b, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa2, 0x01, 0xa5, + 0x01, 0x57, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1e, 0x3e, 0x59, 0xb1, + 0x27, 0x04, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x60, 0xfe, 0x56, 0x03, 0xf2, 0x05, 0xc2, 0x02, 0x26, 0x00, 0x4b, + 0x00, 0x00, 0x01, 0x07, 0x00, 0xa2, 0x01, 0x32, 0x00, 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, + 0x2f, 0x1b, 0xb1, 0x03, 0x1a, 0x3e, 0x59, 0xb1, 0x2c, 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x7a, 0xfd, 0xf6, + 0x04, 0xdc, 0x05, 0xc4, 0x02, 0x26, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x07, 0x01, 0xba, 0x01, 0xda, 0xfe, 0x97, 0xff, + 0xff, 0x00, 0x60, 0xfe, 0x56, 0x03, 0xf2, 0x06, 0x93, 0x02, 0x26, 0x00, 0x4b, 0x00, 0x00, 0x01, 0x07, 0x02, 0x34, + 0x01, 0x2b, 0x00, 0x58, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1a, 0x3e, + 0x59, 0xb0, 0x2a, 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, 0x05, 0x08, 0x07, 0x42, 0x02, 0x26, + 0x00, 0x2c, 0x00, 0x00, 0x01, 0x07, 0x00, 0x9e, 0x00, 0xf1, 0x01, 0x42, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1e, 0x3e, 0x59, 0xb1, 0x10, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x8c, + 0x00, 0x00, 0x03, 0xdf, 0x07, 0x41, 0x02, 0x26, 0x00, 0x4c, 0x00, 0x00, 0x01, 0x07, 0x00, 0x9e, 0x00, 0x1d, 0x01, + 0x41, 0x00, 0x09, 0x00, 0xb0, 0x11, 0x2f, 0xb0, 0x14, 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0xff, 0xb7, 0x00, 0x00, + 0x02, 0x7a, 0x07, 0x2e, 0x02, 0x26, 0x00, 0x2d, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa5, 0xff, 0x3c, 0x01, 0x46, 0x00, + 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1e, 0x3e, 0x59, 0xb1, 0x07, 0x04, 0xf4, + 0x30, 0x31, 0xff, 0xff, 0xff, 0x9d, 0x00, 0x00, 0x02, 0x60, 0x05, 0xea, 0x02, 0x26, 0x00, 0x8d, 0x00, 0x00, 0x01, + 0x07, 0x00, 0xa5, 0xff, 0x22, 0x00, 0x02, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, + 0x03, 0x1a, 0x3e, 0x59, 0xb1, 0x07, 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0xff, 0xcc, 0x00, 0x00, 0x02, 0x6c, 0x06, + 0xef, 0x02, 0x26, 0x00, 0x2d, 0x00, 0x00, 0x01, 0x07, 0x00, 0x70, 0xff, 0x3e, 0x01, 0x4a, 0x00, 0x13, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1e, 0x3e, 0x59, 0xb0, 0x05, 0xdc, 0x30, 0x31, 0x00, 0xff, + 0xff, 0xff, 0xb2, 0x00, 0x00, 0x02, 0x52, 0x05, 0xab, 0x02, 0x26, 0x00, 0x8d, 0x00, 0x00, 0x01, 0x07, 0x00, 0x70, + 0xff, 0x24, 0x00, 0x06, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1a, 0x3e, + 0x59, 0xb0, 0x05, 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0xff, 0xec, 0x00, 0x00, 0x02, 0x43, 0x07, 0x1a, 0x02, 0x26, + 0x00, 0x2d, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa1, 0xff, 0x6b, 0x01, 0x43, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1e, 0x3e, 0x59, 0xb0, 0x07, 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0xff, 0xd2, + 0x00, 0x00, 0x02, 0x29, 0x05, 0xd7, 0x02, 0x26, 0x00, 0x8d, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa1, 0xff, 0x51, 0x00, + 0x00, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1a, 0x3e, 0x59, 0xb0, 0x07, + 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x18, 0xfe, 0x58, 0x01, 0x78, 0x05, 0xb0, 0x02, 0x26, 0x00, 0x2d, 0x00, + 0x00, 0x00, 0x06, 0x00, 0xa4, 0xe6, 0x09, 0xff, 0xff, 0xff, 0xfb, 0xfe, 0x4f, 0x01, 0x68, 0x05, 0xc4, 0x02, 0x26, + 0x00, 0x4d, 0x00, 0x00, 0x00, 0x06, 0x00, 0xa4, 0xc9, 0x00, 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, 0x01, 0x84, 0x07, + 0x04, 0x02, 0x26, 0x00, 0x2d, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa2, 0x00, 0x1c, 0x01, 0x42, 0x00, 0x14, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1e, 0x3e, 0x59, 0xb1, 0x0b, 0x04, 0xf4, 0x30, 0x31, 0xff, + 0xff, 0x00, 0xb7, 0xff, 0xec, 0x05, 0xf9, 0x05, 0xb0, 0x00, 0x26, 0x00, 0x2d, 0x00, 0x00, 0x00, 0x07, 0x00, 0x2e, + 0x02, 0x2d, 0x00, 0x00, 0xff, 0xff, 0x00, 0x8d, 0xfe, 0x4b, 0x03, 0x4a, 0x05, 0xc4, 0x00, 0x26, 0x00, 0x4d, 0x00, + 0x00, 0x00, 0x07, 0x00, 0x4e, 0x01, 0xf1, 0x00, 0x00, 0xff, 0xff, 0x00, 0x35, 0xff, 0xec, 0x04, 0x82, 0x07, 0x35, + 0x02, 0x26, 0x00, 0x2e, 0x00, 0x00, 0x01, 0x07, 0x00, 0x9e, 0x01, 0x7c, 0x01, 0x35, 0x00, 0x14, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1e, 0x3e, 0x59, 0xb1, 0x14, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, + 0xff, 0xb4, 0xfe, 0x4b, 0x02, 0x39, 0x05, 0xd8, 0x02, 0x26, 0x00, 0x9c, 0x00, 0x00, 0x01, 0x07, 0x00, 0x9e, 0xff, + 0x33, 0xff, 0xd8, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1a, 0x3e, 0x59, + 0xb1, 0x12, 0x04, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0xa9, 0xfe, 0x58, 0x05, 0x05, 0x05, 0xb0, 0x02, 0x26, 0x00, + 0x2f, 0x00, 0x00, 0x00, 0x07, 0x01, 0xba, 0x01, 0x94, 0xfe, 0xf9, 0xff, 0xff, 0x00, 0x8d, 0xfe, 0x45, 0x04, 0x0c, + 0x06, 0x00, 0x02, 0x26, 0x00, 0x4f, 0x00, 0x00, 0x00, 0x07, 0x01, 0xba, 0x01, 0x11, 0xfe, 0xe6, 0xff, 0xff, 0x00, + 0xa1, 0x00, 0x00, 0x04, 0x1c, 0x07, 0x31, 0x02, 0x26, 0x00, 0x30, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x00, 0x26, + 0x01, 0x31, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x1e, 0x3e, 0x59, 0xb1, + 0x08, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x93, 0x00, 0x00, 0x02, 0x34, 0x07, 0x96, 0x02, 0x26, 0x00, 0x50, + 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x00, 0x18, 0x01, 0x96, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, + 0x2f, 0x1b, 0xb1, 0x03, 0x20, 0x3e, 0x59, 0xb1, 0x06, 0x09, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0xa9, 0xfe, 0x09, + 0x04, 0x1c, 0x05, 0xb0, 0x02, 0x26, 0x00, 0x30, 0x00, 0x00, 0x00, 0x07, 0x01, 0xba, 0x01, 0x6c, 0xfe, 0xaa, 0xff, + 0xff, 0x00, 0x57, 0xfe, 0x09, 0x01, 0x55, 0x06, 0x00, 0x02, 0x26, 0x00, 0x50, 0x00, 0x00, 0x00, 0x07, 0x01, 0xba, + 0xff, 0xfb, 0xfe, 0xaa, 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, 0x04, 0x1c, 0x05, 0xb1, 0x02, 0x26, 0x00, 0x30, 0x00, + 0x00, 0x01, 0x07, 0x01, 0xba, 0x01, 0xd5, 0x04, 0xc2, 0x00, 0x10, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, + 0x1b, 0xb1, 0x0a, 0x1e, 0x3e, 0x59, 0x30, 0x31, 0xff, 0xff, 0x00, 0x9c, 0x00, 0x00, 0x02, 0xad, 0x06, 0x02, 0x00, + 0x26, 0x00, 0x50, 0x00, 0x00, 0x01, 0x07, 0x01, 0xba, 0x01, 0x56, 0x05, 0x13, 0x00, 0x50, 0x00, 0xb2, 0x1f, 0x08, + 0x01, 0x5d, 0xb2, 0x9f, 0x08, 0x01, 0x5d, 0xb4, 0x1f, 0x08, 0x2f, 0x08, 0x02, 0x71, 0xb2, 0xaf, 0x08, 0x01, 0x71, + 0xb4, 0x2f, 0x08, 0x3f, 0x08, 0x02, 0x72, 0xb2, 0xdf, 0x08, 0x01, 0x72, 0xb6, 0x5f, 0x08, 0x6f, 0x08, 0x7f, 0x08, + 0x03, 0x72, 0xb4, 0xcf, 0x08, 0xdf, 0x08, 0x02, 0x71, 0xb2, 0x4f, 0x08, 0x01, 0x71, 0xb2, 0xcf, 0x08, 0x01, 0x5d, + 0xb4, 0x4f, 0x08, 0x5f, 0x08, 0x02, 0x5d, 0xb2, 0x60, 0x08, 0x01, 0x5d, 0xb2, 0xf0, 0x08, 0x01, 0x72, 0x30, 0x31, + 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, 0x04, 0x1c, 0x05, 0xb0, 0x02, 0x26, 0x00, 0x30, 0x00, 0x00, 0x00, 0x07, 0x00, + 0xa2, 0x01, 0xbc, 0xfd, 0xc5, 0xff, 0xff, 0x00, 0x9c, 0x00, 0x00, 0x02, 0xa0, 0x06, 0x00, 0x00, 0x26, 0x00, 0x50, + 0x00, 0x00, 0x00, 0x07, 0x00, 0xa2, 0x01, 0x38, 0xfd, 0xb6, 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, 0x05, 0x08, 0x07, + 0x36, 0x02, 0x26, 0x00, 0x32, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, 0xf5, 0x01, 0x36, 0x00, 0x14, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1e, 0x3e, 0x59, 0xb1, 0x0c, 0x08, 0xf4, 0x30, 0x31, 0xff, + 0xff, 0x00, 0x8c, 0x00, 0x00, 0x03, 0xdf, 0x06, 0x00, 0x02, 0x26, 0x00, 0x52, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, + 0x01, 0x5b, 0x00, 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1a, 0x3e, + 0x59, 0xb1, 0x14, 0x09, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0xa9, 0xfe, 0x09, 0x05, 0x08, 0x05, 0xb0, 0x02, 0x26, + 0x00, 0x32, 0x00, 0x00, 0x00, 0x07, 0x01, 0xba, 0x01, 0xd0, 0xfe, 0xaa, 0xff, 0xff, 0x00, 0x8c, 0xfe, 0x09, 0x03, + 0xdf, 0x04, 0x4e, 0x02, 0x26, 0x00, 0x52, 0x00, 0x00, 0x00, 0x07, 0x01, 0xba, 0x01, 0x33, 0xfe, 0xaa, 0xff, 0xff, + 0x00, 0xa9, 0x00, 0x00, 0x05, 0x08, 0x07, 0x36, 0x02, 0x26, 0x00, 0x32, 0x00, 0x00, 0x01, 0x07, 0x00, 0x9f, 0x01, + 0x14, 0x01, 0x37, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, + 0xb1, 0x0f, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x8c, 0x00, 0x00, 0x03, 0xdf, 0x06, 0x00, 0x02, 0x26, 0x00, + 0x52, 0x00, 0x00, 0x01, 0x06, 0x00, 0x9f, 0x7a, 0x01, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, + 0x1b, 0xb1, 0x03, 0x1a, 0x3e, 0x59, 0xb1, 0x16, 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0xff, 0xbc, 0x00, 0x00, 0x03, + 0xdf, 0x06, 0x04, 0x02, 0x26, 0x00, 0x52, 0x00, 0x00, 0x01, 0x07, 0x01, 0xba, 0xff, 0x60, 0x05, 0x15, 0x00, 0x10, + 0x00, 0xb0, 0x17, 0x2f, 0xb2, 0x4f, 0x17, 0x01, 0x5d, 0xb2, 0x9f, 0x17, 0x01, 0x5d, 0x30, 0x31, 0xff, 0xff, 0x00, + 0x76, 0xff, 0xec, 0x05, 0x09, 0x06, 0xe5, 0x02, 0x26, 0x00, 0x33, 0x00, 0x00, 0x01, 0x07, 0x00, 0x70, 0x00, 0xe9, + 0x01, 0x40, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1e, 0x3e, 0x59, 0xb0, + 0x21, 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x5b, 0xff, 0xec, 0x04, 0x34, 0x05, 0xad, 0x02, 0x26, 0x00, 0x53, + 0x00, 0x00, 0x01, 0x06, 0x00, 0x70, 0x66, 0x08, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, + 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb0, 0x1d, 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x76, 0xff, 0xec, 0x05, 0x09, + 0x07, 0x10, 0x02, 0x26, 0x00, 0x33, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa1, 0x01, 0x16, 0x01, 0x39, 0x00, 0x13, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1e, 0x3e, 0x59, 0xb0, 0x22, 0xdc, 0x30, 0x31, 0x00, + 0xff, 0xff, 0x00, 0x5b, 0xff, 0xec, 0x04, 0x34, 0x05, 0xd8, 0x02, 0x26, 0x00, 0x53, 0x00, 0x00, 0x01, 0x07, 0x00, + 0xa1, 0x00, 0x93, 0x00, 0x01, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, + 0x3e, 0x59, 0xb0, 0x1f, 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x76, 0xff, 0xec, 0x05, 0x09, 0x07, 0x37, 0x02, + 0x26, 0x00, 0x33, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa6, 0x01, 0x6b, 0x01, 0x38, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1e, 0x3e, 0x59, 0xb1, 0x26, 0x08, 0xf4, 0xb0, 0x22, 0xd0, 0x30, 0x31, + 0x00, 0xff, 0xff, 0x00, 0x5b, 0xff, 0xec, 0x04, 0x34, 0x05, 0xff, 0x02, 0x26, 0x00, 0x53, 0x00, 0x00, 0x01, 0x07, + 0x00, 0xa6, 0x00, 0xe8, 0x00, 0x00, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, + 0x1a, 0x3e, 0x59, 0xb1, 0x22, 0x09, 0xf4, 0xb0, 0x1e, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0xa8, 0x00, 0x00, + 0x04, 0xc9, 0x07, 0x36, 0x02, 0x26, 0x00, 0x36, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, 0x80, 0x01, 0x36, 0x00, + 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1e, 0x3e, 0x59, 0xb1, 0x1a, 0x08, 0xf4, + 0x30, 0x31, 0xff, 0xff, 0x00, 0x8c, 0x00, 0x00, 0x02, 0xd2, 0x06, 0x00, 0x02, 0x26, 0x00, 0x56, 0x00, 0x00, 0x01, + 0x07, 0x00, 0x75, 0x00, 0xb6, 0x00, 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, + 0x0b, 0x1a, 0x3e, 0x59, 0xb1, 0x10, 0x09, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0xa8, 0xfe, 0x09, 0x04, 0xc9, 0x05, + 0xb0, 0x02, 0x26, 0x00, 0x36, 0x00, 0x00, 0x00, 0x07, 0x01, 0xba, 0x01, 0x63, 0xfe, 0xaa, 0xff, 0xff, 0x00, 0x53, + 0xfe, 0x09, 0x02, 0x97, 0x04, 0x4e, 0x02, 0x26, 0x00, 0x56, 0x00, 0x00, 0x00, 0x07, 0x01, 0xba, 0xff, 0xf7, 0xfe, + 0xaa, 0xff, 0xff, 0x00, 0xa8, 0x00, 0x00, 0x04, 0xc9, 0x07, 0x36, 0x02, 0x26, 0x00, 0x36, 0x00, 0x00, 0x01, 0x07, + 0x00, 0x9f, 0x00, 0x9f, 0x01, 0x37, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, + 0x1e, 0x3e, 0x59, 0xb1, 0x1d, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x63, 0x00, 0x00, 0x02, 0xcd, 0x06, 0x00, + 0x02, 0x26, 0x00, 0x56, 0x00, 0x00, 0x01, 0x06, 0x00, 0x9f, 0xd6, 0x01, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1a, 0x3e, 0x59, 0xb1, 0x12, 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x50, + 0xff, 0xec, 0x04, 0x72, 0x07, 0x38, 0x02, 0x26, 0x00, 0x37, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, 0x8d, 0x01, + 0x38, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb1, 0x29, + 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x5f, 0xff, 0xec, 0x03, 0xbb, 0x06, 0x00, 0x02, 0x26, 0x00, 0x57, 0x00, + 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, 0x51, 0x00, 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, + 0x1b, 0xb1, 0x09, 0x1a, 0x3e, 0x59, 0xb1, 0x29, 0x09, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x50, 0xff, 0xec, 0x04, + 0x72, 0x07, 0x38, 0x02, 0x26, 0x00, 0x37, 0x00, 0x00, 0x01, 0x07, 0x00, 0x9e, 0x00, 0x97, 0x01, 0x38, 0x00, 0x14, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb1, 0x29, 0x06, 0xf4, 0x30, + 0x31, 0xff, 0xff, 0x00, 0x5f, 0xff, 0xec, 0x03, 0xbb, 0x06, 0x00, 0x02, 0x26, 0x00, 0x57, 0x00, 0x00, 0x01, 0x06, + 0x00, 0x9e, 0x5b, 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x1a, 0x3e, + 0x59, 0xb1, 0x29, 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x50, 0xfe, 0x4d, 0x04, 0x72, 0x05, 0xc4, 0x02, 0x26, + 0x00, 0x37, 0x00, 0x00, 0x00, 0x07, 0x00, 0x79, 0x01, 0x9f, 0x00, 0x00, 0xff, 0xff, 0x00, 0x5f, 0xfe, 0x45, 0x03, + 0xbb, 0x04, 0x4e, 0x02, 0x26, 0x00, 0x57, 0x00, 0x00, 0x00, 0x07, 0x00, 0x79, 0x01, 0x5d, 0xff, 0xf8, 0xff, 0xff, + 0x00, 0x50, 0xfd, 0xff, 0x04, 0x72, 0x05, 0xc4, 0x02, 0x26, 0x00, 0x37, 0x00, 0x00, 0x00, 0x07, 0x01, 0xba, 0x01, + 0x75, 0xfe, 0xa0, 0xff, 0xff, 0x00, 0x5f, 0xfd, 0xf6, 0x03, 0xbb, 0x04, 0x4e, 0x02, 0x26, 0x00, 0x57, 0x00, 0x00, + 0x00, 0x07, 0x01, 0xba, 0x01, 0x33, 0xfe, 0x97, 0xff, 0xff, 0x00, 0x50, 0xff, 0xec, 0x04, 0x72, 0x07, 0x38, 0x02, + 0x26, 0x00, 0x37, 0x00, 0x00, 0x01, 0x07, 0x00, 0x9f, 0x00, 0xac, 0x01, 0x39, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb1, 0x2b, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, + 0x5f, 0xff, 0xec, 0x03, 0xbb, 0x06, 0x00, 0x02, 0x26, 0x00, 0x57, 0x00, 0x00, 0x01, 0x06, 0x00, 0x9f, 0x70, 0x01, + 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x1a, 0x3e, 0x59, 0xb1, 0x2b, 0x01, + 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x31, 0xfd, 0xff, 0x04, 0x97, 0x05, 0xb0, 0x02, 0x26, 0x00, 0x38, 0x00, 0x00, + 0x00, 0x07, 0x01, 0xba, 0x01, 0x66, 0xfe, 0xa0, 0xff, 0xff, 0x00, 0x09, 0xfd, 0xff, 0x02, 0x56, 0x05, 0x40, 0x02, + 0x26, 0x00, 0x58, 0x00, 0x00, 0x00, 0x07, 0x01, 0xba, 0x00, 0xc5, 0xfe, 0xa0, 0xff, 0xff, 0x00, 0x31, 0xfe, 0x4d, + 0x04, 0x97, 0x05, 0xb0, 0x02, 0x26, 0x00, 0x38, 0x00, 0x00, 0x00, 0x07, 0x00, 0x79, 0x01, 0x90, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x09, 0xfe, 0x4d, 0x02, 0x99, 0x05, 0x40, 0x02, 0x26, 0x00, 0x58, 0x00, 0x00, 0x00, 0x07, 0x00, 0x79, + 0x00, 0xef, 0x00, 0x00, 0xff, 0xff, 0x00, 0x31, 0x00, 0x00, 0x04, 0x97, 0x07, 0x36, 0x02, 0x26, 0x00, 0x38, 0x00, + 0x00, 0x01, 0x07, 0x00, 0x9f, 0x00, 0xa1, 0x01, 0x37, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, + 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb1, 0x0d, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x09, 0xff, 0xec, 0x02, + 0xec, 0x06, 0x79, 0x00, 0x26, 0x00, 0x58, 0x00, 0x00, 0x01, 0x07, 0x01, 0xba, 0x01, 0x95, 0x05, 0x8a, 0x00, 0x12, + 0x00, 0xb2, 0x0f, 0x1a, 0x01, 0x5d, 0xb2, 0x9f, 0x1a, 0x01, 0x5d, 0xb2, 0x4f, 0x1a, 0x01, 0x5d, 0x30, 0x31, 0xff, + 0xff, 0x00, 0x8c, 0xff, 0xec, 0x04, 0xaa, 0x07, 0x22, 0x02, 0x26, 0x00, 0x39, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa5, + 0x00, 0xc0, 0x01, 0x3a, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x12, 0x2f, 0x1b, 0xb1, 0x12, 0x1e, 0x3e, + 0x59, 0xb1, 0x16, 0x04, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x88, 0xff, 0xec, 0x03, 0xdc, 0x05, 0xec, 0x02, 0x26, + 0x00, 0x59, 0x00, 0x00, 0x01, 0x06, 0x00, 0xa5, 0x5c, 0x04, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, + 0x2f, 0x1b, 0xb1, 0x0d, 0x1a, 0x3e, 0x59, 0xb1, 0x14, 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x8c, 0xff, 0xec, + 0x04, 0xaa, 0x06, 0xe3, 0x02, 0x26, 0x00, 0x39, 0x00, 0x00, 0x01, 0x07, 0x00, 0x70, 0x00, 0xc2, 0x01, 0x3e, 0x00, + 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x12, 0x2f, 0x1b, 0xb1, 0x12, 0x1e, 0x3e, 0x59, 0xb0, 0x13, 0xdc, 0x30, + 0x31, 0x00, 0xff, 0xff, 0x00, 0x88, 0xff, 0xec, 0x03, 0xdc, 0x05, 0xad, 0x02, 0x26, 0x00, 0x59, 0x00, 0x00, 0x01, + 0x06, 0x00, 0x70, 0x5e, 0x08, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1a, + 0x3e, 0x59, 0xb0, 0x12, 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x8c, 0xff, 0xec, 0x04, 0xaa, 0x07, 0x0e, 0x02, + 0x26, 0x00, 0x39, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa1, 0x00, 0xef, 0x01, 0x37, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1e, 0x3e, 0x59, 0xb0, 0x16, 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, + 0x88, 0xff, 0xec, 0x03, 0xdc, 0x05, 0xd8, 0x02, 0x26, 0x00, 0x59, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa1, 0x00, 0x8b, + 0x00, 0x01, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1a, 0x3e, 0x59, 0xb0, + 0x14, 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x8c, 0xff, 0xec, 0x04, 0xaa, 0x07, 0x91, 0x02, 0x26, 0x00, 0x39, + 0x00, 0x00, 0x01, 0x07, 0x00, 0xa3, 0x01, 0x4b, 0x01, 0x41, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, + 0x2f, 0x1b, 0xb1, 0x0a, 0x1e, 0x3e, 0x59, 0xb1, 0x16, 0x06, 0xf4, 0xb0, 0x20, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, + 0x00, 0x88, 0xff, 0xec, 0x03, 0xdc, 0x06, 0x5b, 0x02, 0x26, 0x00, 0x59, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa3, 0x00, + 0xe7, 0x00, 0x0b, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1a, 0x3e, 0x59, + 0xb1, 0x14, 0x04, 0xf4, 0xb0, 0x1e, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x8c, 0xff, 0xec, 0x04, 0xaa, 0x07, + 0x35, 0x02, 0x26, 0x00, 0x39, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa6, 0x01, 0x44, 0x01, 0x36, 0x00, 0x17, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x12, 0x2f, 0x1b, 0xb1, 0x12, 0x1e, 0x3e, 0x59, 0xb1, 0x15, 0x08, 0xf4, 0xb0, 0x19, 0xd0, + 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x88, 0xff, 0xec, 0x04, 0x0c, 0x05, 0xff, 0x02, 0x26, 0x00, 0x59, 0x00, 0x00, + 0x01, 0x07, 0x00, 0xa6, 0x00, 0xe0, 0x00, 0x00, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, + 0xb1, 0x0d, 0x1a, 0x3e, 0x59, 0xb1, 0x13, 0x09, 0xf4, 0xb0, 0x17, 0xd0, 0x30, 0x31, 0x00, 0x00, 0x01, 0x00, 0x8c, + 0xfe, 0x7b, 0x04, 0xaa, 0x05, 0xb0, 0x00, 0x20, 0x00, 0x55, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x18, 0x2f, 0x1b, + 0xb1, 0x18, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x14, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x13, 0x2f, 0x1b, 0xb1, 0x13, 0x12, 0x3e, 0x59, 0xb0, 0x18, 0x10, 0xb0, 0x20, 0xd0, 0xb2, + 0x04, 0x13, 0x20, 0x11, 0x12, 0x39, 0xb0, 0x0d, 0x10, 0xb1, 0x08, 0x03, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0xb0, 0x13, 0x10, 0xb1, 0x1c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, + 0x01, 0x11, 0x06, 0x06, 0x07, 0x06, 0x15, 0x14, 0x33, 0x32, 0x37, 0x17, 0x06, 0x23, 0x22, 0x26, 0x35, 0x34, 0x37, + 0x07, 0x22, 0x00, 0x27, 0x11, 0x33, 0x11, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x11, 0x04, 0xaa, 0x01, 0x8a, 0x83, + 0x9b, 0x4e, 0x30, 0x34, 0x0d, 0x46, 0x5a, 0x59, 0x67, 0x4f, 0x16, 0xef, 0xfe, 0xe4, 0x02, 0xbe, 0xae, 0xa1, 0xa3, + 0xad, 0x05, 0xb0, 0xfc, 0x21, 0x94, 0xe2, 0x3b, 0x72, 0x60, 0x48, 0x1a, 0x79, 0x2c, 0x68, 0x56, 0x61, 0x53, 0x01, + 0x01, 0x02, 0xe2, 0x03, 0xe0, 0xfc, 0x26, 0x9e, 0xaf, 0xae, 0x9e, 0x03, 0xdb, 0x00, 0x01, 0x00, 0x88, 0xfe, 0x4f, + 0x03, 0xe6, 0x04, 0x3a, 0x00, 0x1f, 0x00, 0x6f, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x17, 0x2f, 0x1b, 0xb1, 0x17, + 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x1d, 0x2f, 0x1b, 0xb1, 0x1d, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x1f, 0x2f, 0x1b, 0xb1, 0x1f, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x12, 0x2f, 0x1b, 0xb1, + 0x12, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x14, 0x3e, 0x59, 0xb1, 0x05, + 0x03, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x1f, 0x10, 0xb0, 0x0f, 0xd0, 0xb0, 0x0f, 0x2f, + 0xb2, 0x10, 0x12, 0x1d, 0x11, 0x12, 0x39, 0xb0, 0x12, 0x10, 0xb1, 0x1a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x21, 0x07, 0x06, 0x15, 0x14, 0x33, 0x32, 0x37, 0x17, 0x06, 0x23, 0x22, 0x26, 0x35, + 0x34, 0x37, 0x27, 0x06, 0x23, 0x22, 0x26, 0x27, 0x11, 0x33, 0x11, 0x14, 0x33, 0x32, 0x37, 0x11, 0x33, 0x11, 0x03, + 0xd2, 0x3a, 0x71, 0x4e, 0x30, 0x34, 0x0d, 0x46, 0x5a, 0x59, 0x67, 0xa6, 0x04, 0x6c, 0xd1, 0xad, 0xb5, 0x01, 0xb9, + 0xc8, 0xd4, 0x46, 0xb9, 0x2d, 0x5b, 0x56, 0x48, 0x1a, 0x79, 0x2c, 0x68, 0x56, 0x8f, 0x6a, 0x65, 0x7f, 0xc9, 0xc5, + 0x02, 0xc0, 0xfd, 0x45, 0xf6, 0x9e, 0x03, 0x13, 0xfb, 0xc6, 0xff, 0xff, 0x00, 0x3d, 0x00, 0x00, 0x06, 0xed, 0x07, + 0x36, 0x02, 0x26, 0x00, 0x3b, 0x00, 0x00, 0x01, 0x07, 0x00, 0x9e, 0x01, 0xc5, 0x01, 0x36, 0x00, 0x14, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1e, 0x3e, 0x59, 0xb1, 0x17, 0x06, 0xf4, 0x30, 0x31, 0xff, + 0xff, 0x00, 0x2b, 0x00, 0x00, 0x05, 0xd3, 0x06, 0x00, 0x02, 0x26, 0x00, 0x5b, 0x00, 0x00, 0x01, 0x07, 0x00, 0x9e, + 0x01, 0x24, 0x00, 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x1a, 0x3e, + 0x59, 0xb1, 0x0f, 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x0f, 0x00, 0x00, 0x04, 0xbb, 0x07, 0x36, 0x02, 0x26, + 0x00, 0x3d, 0x00, 0x00, 0x01, 0x07, 0x00, 0x9e, 0x00, 0x92, 0x01, 0x36, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x1e, 0x3e, 0x59, 0xb1, 0x0b, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x16, + 0xfe, 0x4b, 0x03, 0xb0, 0x06, 0x00, 0x02, 0x26, 0x00, 0x5d, 0x00, 0x00, 0x01, 0x06, 0x00, 0x9e, 0x25, 0x00, 0x00, + 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0f, 0x2f, 0x1b, 0xb1, 0x0f, 0x1a, 0x3e, 0x59, 0xb1, 0x14, 0x01, 0xf4, + 0x30, 0x31, 0xff, 0xff, 0x00, 0x0f, 0x00, 0x00, 0x04, 0xbb, 0x06, 0xfb, 0x02, 0x26, 0x00, 0x3d, 0x00, 0x00, 0x01, + 0x07, 0x00, 0x6a, 0x00, 0xc2, 0x01, 0x36, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, + 0x08, 0x1e, 0x3e, 0x59, 0xb1, 0x10, 0x04, 0xf4, 0xb0, 0x19, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x56, 0x00, + 0x00, 0x04, 0x7a, 0x07, 0x36, 0x02, 0x26, 0x00, 0x3e, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, 0x87, 0x01, 0x36, + 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1e, 0x3e, 0x59, 0xb1, 0x0c, 0x08, + 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x58, 0x00, 0x00, 0x03, 0xb3, 0x06, 0x00, 0x02, 0x26, 0x00, 0x5e, 0x00, 0x00, + 0x01, 0x07, 0x00, 0x75, 0x01, 0x21, 0x00, 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, + 0xb1, 0x07, 0x1a, 0x3e, 0x59, 0xb1, 0x0c, 0x09, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x56, 0x00, 0x00, 0x04, 0x7a, + 0x06, 0xf8, 0x02, 0x26, 0x00, 0x3e, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa2, 0x01, 0x6e, 0x01, 0x36, 0x00, 0x14, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1e, 0x3e, 0x59, 0xb1, 0x11, 0x04, 0xf4, 0x30, 0x31, + 0xff, 0xff, 0x00, 0x58, 0x00, 0x00, 0x03, 0xb3, 0x05, 0xc2, 0x02, 0x26, 0x00, 0x5e, 0x00, 0x00, 0x01, 0x07, 0x00, + 0xa2, 0x01, 0x08, 0x00, 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1a, + 0x3e, 0x59, 0xb1, 0x11, 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x56, 0x00, 0x00, 0x04, 0x7a, 0x07, 0x36, 0x02, + 0x26, 0x00, 0x3e, 0x00, 0x00, 0x01, 0x07, 0x00, 0x9f, 0x00, 0xa6, 0x01, 0x37, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1e, 0x3e, 0x59, 0xb1, 0x0f, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, + 0x58, 0x00, 0x00, 0x03, 0xb3, 0x06, 0x00, 0x02, 0x26, 0x00, 0x5e, 0x00, 0x00, 0x01, 0x06, 0x00, 0x9f, 0x40, 0x01, + 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1a, 0x3e, 0x59, 0xb1, 0x0f, 0x01, + 0xf4, 0x30, 0x31, 0xff, 0xff, 0xff, 0xf2, 0x00, 0x00, 0x07, 0x57, 0x07, 0x42, 0x02, 0x26, 0x00, 0x81, 0x00, 0x00, + 0x01, 0x07, 0x00, 0x75, 0x02, 0xc9, 0x01, 0x42, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, + 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb1, 0x15, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x4e, 0xff, 0xec, 0x06, 0x7c, + 0x06, 0x01, 0x02, 0x26, 0x00, 0x86, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x02, 0x7a, 0x00, 0x01, 0x00, 0x14, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x1d, 0x2f, 0x1b, 0xb1, 0x1d, 0x1a, 0x3e, 0x59, 0xb1, 0x40, 0x09, 0xf4, 0x30, 0x31, + 0xff, 0xff, 0x00, 0x76, 0xff, 0xa3, 0x05, 0x1d, 0x07, 0x80, 0x02, 0x26, 0x00, 0x83, 0x00, 0x00, 0x01, 0x07, 0x00, + 0x75, 0x01, 0xe9, 0x01, 0x80, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x1e, + 0x3e, 0x59, 0xb1, 0x2c, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x5b, 0xff, 0x7a, 0x04, 0x34, 0x06, 0x00, 0x02, + 0x26, 0x00, 0x89, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, 0x37, 0x00, 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb1, 0x29, 0x09, 0xf4, 0x30, 0x31, 0xff, 0xff, 0xff, + 0xbe, 0x00, 0x00, 0x04, 0x1f, 0x04, 0x8d, 0x02, 0x26, 0x02, 0x30, 0x00, 0x00, 0x01, 0x07, 0x02, 0x26, 0xff, 0x2f, + 0xff, 0x78, 0x00, 0x2c, 0x00, 0xb2, 0x1f, 0x18, 0x01, 0x71, 0xb4, 0xdf, 0x18, 0xef, 0x18, 0x02, 0x71, 0xb4, 0x1f, + 0x18, 0x2f, 0x18, 0x02, 0x5d, 0xb2, 0x1f, 0x18, 0x01, 0x72, 0xb2, 0x4f, 0x18, 0x01, 0x71, 0xb4, 0xef, 0x18, 0xff, + 0x18, 0x02, 0x5d, 0xb2, 0x5f, 0x18, 0x01, 0x5d, 0x30, 0x31, 0xff, 0xff, 0xff, 0xbe, 0x00, 0x00, 0x04, 0x1f, 0x04, + 0x8d, 0x02, 0x26, 0x02, 0x30, 0x00, 0x00, 0x01, 0x07, 0x02, 0x26, 0xff, 0x2f, 0xff, 0x78, 0x00, 0x36, 0x00, 0xb4, + 0xef, 0x17, 0xff, 0x17, 0x02, 0x5d, 0xb2, 0x4f, 0x17, 0x01, 0x71, 0xb2, 0x1f, 0x17, 0x01, 0x72, 0xb2, 0xdf, 0x17, + 0x01, 0x72, 0xb2, 0x6f, 0x17, 0x01, 0x72, 0xb4, 0xdf, 0x17, 0xef, 0x17, 0x02, 0x71, 0xb2, 0x1f, 0x17, 0x01, 0x71, + 0xb2, 0x5f, 0x17, 0x01, 0x5d, 0xb4, 0x1f, 0x17, 0x2f, 0x17, 0x02, 0x5d, 0x30, 0x31, 0xff, 0xff, 0x00, 0x28, 0x00, + 0x00, 0x03, 0xfd, 0x04, 0x8d, 0x02, 0x26, 0x01, 0xd8, 0x00, 0x00, 0x01, 0x06, 0x02, 0x26, 0x45, 0xe0, 0x00, 0x0d, + 0x00, 0xb2, 0x03, 0x0a, 0x01, 0x5d, 0xb2, 0xb0, 0x0a, 0x01, 0x5d, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x13, 0x00, + 0x00, 0x04, 0x70, 0x06, 0x1e, 0x02, 0x26, 0x02, 0x33, 0x00, 0x00, 0x01, 0x07, 0x00, 0x44, 0x00, 0xd5, 0x00, 0x1e, + 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1c, 0x3e, 0x59, 0xb1, 0x0c, 0x06, + 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x13, 0x00, 0x00, 0x04, 0x70, 0x06, 0x1e, 0x02, 0x26, 0x02, 0x33, 0x00, 0x00, + 0x01, 0x07, 0x00, 0x75, 0x01, 0x64, 0x00, 0x1e, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, + 0xb1, 0x05, 0x1c, 0x3e, 0x59, 0xb1, 0x0d, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x13, 0x00, 0x00, 0x04, 0x70, + 0x06, 0x1e, 0x02, 0x26, 0x02, 0x33, 0x00, 0x00, 0x01, 0x06, 0x00, 0x9e, 0x6e, 0x1e, 0x00, 0x14, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1c, 0x3e, 0x59, 0xb1, 0x0f, 0x04, 0xf4, 0x30, 0x31, 0xff, 0xff, + 0x00, 0x13, 0x00, 0x00, 0x04, 0x70, 0x06, 0x0a, 0x02, 0x26, 0x02, 0x33, 0x00, 0x00, 0x01, 0x06, 0x00, 0xa5, 0x6a, + 0x22, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x1c, 0x3e, 0x59, 0xb1, 0x0e, + 0x02, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x13, 0x00, 0x00, 0x04, 0x70, 0x05, 0xe3, 0x02, 0x26, 0x02, 0x33, 0x00, + 0x00, 0x01, 0x07, 0x00, 0x6a, 0x00, 0x9e, 0x00, 0x1e, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, + 0x1b, 0xb1, 0x04, 0x1c, 0x3e, 0x59, 0xb1, 0x12, 0x02, 0xf4, 0xb0, 0x1b, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, + 0x13, 0x00, 0x00, 0x04, 0x70, 0x06, 0x79, 0x02, 0x26, 0x02, 0x33, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa3, 0x00, 0xf5, + 0x00, 0x29, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1c, 0x3e, 0x59, 0xb1, + 0x0e, 0x06, 0xf4, 0xb0, 0x18, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x13, 0x00, 0x00, 0x04, 0x70, 0x06, 0x7c, + 0x02, 0x26, 0x02, 0x33, 0x00, 0x00, 0x00, 0x07, 0x02, 0x27, 0x00, 0xff, 0x00, 0x0a, 0xff, 0xff, 0x00, 0x60, 0xfe, + 0x4a, 0x04, 0x30, 0x04, 0x9d, 0x02, 0x26, 0x02, 0x31, 0x00, 0x00, 0x00, 0x07, 0x00, 0x79, 0x01, 0x74, 0xff, 0xfd, + 0xff, 0xff, 0x00, 0x8a, 0x00, 0x00, 0x03, 0xae, 0x06, 0x1e, 0x02, 0x26, 0x02, 0x28, 0x00, 0x00, 0x01, 0x07, 0x00, + 0x44, 0x00, 0xa8, 0x00, 0x1e, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1c, + 0x3e, 0x59, 0xb1, 0x0d, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x8a, 0x00, 0x00, 0x03, 0xae, 0x06, 0x1e, 0x02, + 0x26, 0x02, 0x28, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, 0x37, 0x00, 0x1e, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1c, 0x3e, 0x59, 0xb1, 0x0e, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, + 0x8a, 0x00, 0x00, 0x03, 0xae, 0x06, 0x1e, 0x02, 0x26, 0x02, 0x28, 0x00, 0x00, 0x01, 0x06, 0x00, 0x9e, 0x41, 0x1e, + 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1c, 0x3e, 0x59, 0xb1, 0x10, 0x04, + 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x8a, 0x00, 0x00, 0x03, 0xae, 0x05, 0xe3, 0x02, 0x26, 0x02, 0x28, 0x00, 0x00, + 0x01, 0x06, 0x00, 0x6a, 0x71, 0x1e, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, + 0x1c, 0x3e, 0x59, 0xb1, 0x13, 0x02, 0xf4, 0xb0, 0x1c, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0xff, 0xbe, 0x00, 0x00, + 0x01, 0x5f, 0x06, 0x1e, 0x02, 0x26, 0x01, 0xe3, 0x00, 0x00, 0x01, 0x06, 0x00, 0x44, 0x85, 0x1e, 0x00, 0x14, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1c, 0x3e, 0x59, 0xb1, 0x05, 0x06, 0xf4, 0x30, 0x31, + 0xff, 0xff, 0x00, 0x8e, 0x00, 0x00, 0x02, 0x2f, 0x06, 0x1e, 0x02, 0x26, 0x01, 0xe3, 0x00, 0x00, 0x01, 0x06, 0x00, + 0x75, 0x13, 0x1e, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1c, 0x3e, 0x59, + 0xb1, 0x06, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0xff, 0xc7, 0x00, 0x00, 0x02, 0x24, 0x06, 0x1e, 0x02, 0x26, 0x01, + 0xe3, 0x00, 0x00, 0x01, 0x07, 0x00, 0x9e, 0xff, 0x1e, 0x00, 0x1e, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1c, 0x3e, 0x59, 0xb1, 0x08, 0x04, 0xf4, 0x30, 0x31, 0xff, 0xff, 0xff, 0xb3, 0x00, + 0x00, 0x02, 0x3c, 0x05, 0xe3, 0x02, 0x26, 0x01, 0xe3, 0x00, 0x00, 0x01, 0x07, 0x00, 0x6a, 0xff, 0x4e, 0x00, 0x1e, + 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1c, 0x3e, 0x59, 0xb1, 0x0b, 0x02, + 0xf4, 0xb0, 0x14, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x8a, 0x00, 0x00, 0x04, 0x58, 0x06, 0x0a, 0x02, 0x26, + 0x01, 0xde, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa5, 0x00, 0x95, 0x00, 0x22, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1c, 0x3e, 0x59, 0xb1, 0x0d, 0x02, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x60, + 0xff, 0xf0, 0x04, 0x5a, 0x06, 0x1e, 0x02, 0x26, 0x01, 0xdd, 0x00, 0x00, 0x01, 0x07, 0x00, 0x44, 0x00, 0xee, 0x00, + 0x1e, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1c, 0x3e, 0x59, 0xb1, 0x1d, + 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x60, 0xff, 0xf0, 0x04, 0x5a, 0x06, 0x1e, 0x02, 0x26, 0x01, 0xdd, 0x00, + 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, 0x7d, 0x00, 0x1e, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, + 0x1b, 0xb1, 0x0a, 0x1c, 0x3e, 0x59, 0xb1, 0x1e, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x60, 0xff, 0xf0, 0x04, + 0x5a, 0x06, 0x1e, 0x02, 0x26, 0x01, 0xdd, 0x00, 0x00, 0x01, 0x07, 0x00, 0x9e, 0x00, 0x87, 0x00, 0x1e, 0x00, 0x14, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1c, 0x3e, 0x59, 0xb1, 0x20, 0x04, 0xf4, 0x30, + 0x31, 0xff, 0xff, 0x00, 0x60, 0xff, 0xf0, 0x04, 0x5a, 0x06, 0x0a, 0x02, 0x26, 0x01, 0xdd, 0x00, 0x00, 0x01, 0x07, + 0x00, 0xa5, 0x00, 0x83, 0x00, 0x22, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, + 0x1c, 0x3e, 0x59, 0xb1, 0x1f, 0x02, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x60, 0xff, 0xf0, 0x04, 0x5a, 0x05, 0xe3, + 0x02, 0x26, 0x01, 0xdd, 0x00, 0x00, 0x01, 0x07, 0x00, 0x6a, 0x00, 0xb7, 0x00, 0x1e, 0x00, 0x17, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1c, 0x3e, 0x59, 0xb1, 0x23, 0x02, 0xf4, 0xb0, 0x2c, 0xd0, 0x30, + 0x31, 0x00, 0xff, 0xff, 0x00, 0x74, 0xff, 0xf0, 0x04, 0x0a, 0x06, 0x1e, 0x02, 0x26, 0x01, 0xd7, 0x00, 0x00, 0x01, + 0x07, 0x00, 0x44, 0x00, 0xcf, 0x00, 0x1e, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, + 0x09, 0x1c, 0x3e, 0x59, 0xb1, 0x13, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x74, 0xff, 0xf0, 0x04, 0x0a, 0x06, + 0x1e, 0x02, 0x26, 0x01, 0xd7, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, 0x5e, 0x00, 0x1e, 0x00, 0x14, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x11, 0x2f, 0x1b, 0xb1, 0x11, 0x1c, 0x3e, 0x59, 0xb1, 0x14, 0x06, 0xf4, 0x30, 0x31, 0xff, + 0xff, 0x00, 0x74, 0xff, 0xf0, 0x04, 0x0a, 0x06, 0x1e, 0x02, 0x26, 0x01, 0xd7, 0x00, 0x00, 0x01, 0x06, 0x00, 0x9e, + 0x68, 0x1e, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x1c, 0x3e, 0x59, 0xb1, + 0x16, 0x04, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x74, 0xff, 0xf0, 0x04, 0x0a, 0x05, 0xe3, 0x02, 0x26, 0x01, 0xd7, + 0x00, 0x00, 0x01, 0x07, 0x00, 0x6a, 0x00, 0x98, 0x00, 0x1e, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, + 0x2f, 0x1b, 0xb1, 0x09, 0x1c, 0x3e, 0x59, 0xb1, 0x19, 0x02, 0xf4, 0xb0, 0x22, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, + 0x00, 0x0d, 0x00, 0x00, 0x04, 0x1c, 0x06, 0x1e, 0x02, 0x26, 0x01, 0xd3, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, + 0x33, 0x00, 0x1e, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x1c, 0x3e, 0x59, + 0xb1, 0x0b, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x13, 0x00, 0x00, 0x04, 0x70, 0x05, 0xcb, 0x02, 0x26, 0x02, + 0x33, 0x00, 0x00, 0x01, 0x06, 0x00, 0x70, 0x6c, 0x26, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, + 0x1b, 0xb1, 0x04, 0x1c, 0x3e, 0x59, 0xb0, 0x0c, 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x13, 0x00, 0x00, 0x04, + 0x70, 0x05, 0xf6, 0x02, 0x26, 0x02, 0x33, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa1, 0x00, 0x99, 0x00, 0x1f, 0x00, 0x14, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1c, 0x3e, 0x59, 0xb1, 0x0e, 0x08, 0xf4, 0x30, + 0x31, 0x00, 0x02, 0x00, 0x13, 0xfe, 0x4f, 0x04, 0x70, 0x04, 0x8d, 0x00, 0x16, 0x00, 0x19, 0x00, 0x69, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x14, 0x2f, + 0x1b, 0xb1, 0x14, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x12, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x14, 0x3e, 0x59, 0xb1, 0x07, 0x03, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x01, 0x10, 0xb0, 0x11, 0xd0, 0xb0, 0x11, 0x2f, 0xb2, 0x17, 0x14, 0x00, + 0x11, 0x12, 0x39, 0xb0, 0x17, 0x2f, 0xb1, 0x13, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, + 0x19, 0x00, 0x14, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x01, 0x23, 0x07, 0x06, 0x15, 0x14, 0x33, 0x32, 0x37, 0x17, + 0x06, 0x23, 0x22, 0x26, 0x35, 0x34, 0x37, 0x03, 0x21, 0x03, 0x23, 0x01, 0x03, 0x21, 0x03, 0x02, 0x98, 0x01, 0xd8, + 0x26, 0x3a, 0x71, 0x4e, 0x30, 0x34, 0x0d, 0x46, 0x5a, 0x59, 0x67, 0xb0, 0x68, 0xfd, 0xf8, 0x6e, 0xbd, 0x01, 0xdf, + 0x78, 0x01, 0x91, 0xc7, 0x04, 0x8d, 0xfb, 0x73, 0x2d, 0x5b, 0x56, 0x48, 0x1a, 0x79, 0x2c, 0x68, 0x56, 0x94, 0x6c, + 0x01, 0x0a, 0xfe, 0xe9, 0x04, 0x8d, 0xfd, 0x21, 0x01, 0xfd, 0x00, 0xff, 0xff, 0x00, 0x60, 0xff, 0xf0, 0x04, 0x30, + 0x06, 0x1e, 0x02, 0x26, 0x02, 0x31, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, 0x69, 0x00, 0x1e, 0x00, 0x14, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1c, 0x3e, 0x59, 0xb1, 0x1f, 0x06, 0xf4, 0x30, 0x31, + 0xff, 0xff, 0x00, 0x60, 0xff, 0xf0, 0x04, 0x30, 0x06, 0x1e, 0x02, 0x26, 0x02, 0x31, 0x00, 0x00, 0x01, 0x06, 0x00, + 0x9e, 0x73, 0x1e, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1c, 0x3e, 0x59, + 0xb1, 0x21, 0x04, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x60, 0xff, 0xf0, 0x04, 0x30, 0x05, 0xe0, 0x02, 0x26, 0x02, + 0x31, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa2, 0x01, 0x50, 0x00, 0x1e, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1c, 0x3e, 0x59, 0xb1, 0x23, 0x02, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x60, 0xff, + 0xf0, 0x04, 0x30, 0x06, 0x1e, 0x02, 0x26, 0x02, 0x31, 0x00, 0x00, 0x01, 0x07, 0x00, 0x9f, 0x00, 0x88, 0x00, 0x1f, + 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1c, 0x3e, 0x59, 0xb1, 0x21, 0x06, + 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x8a, 0x00, 0x00, 0x04, 0x1f, 0x06, 0x1e, 0x02, 0x26, 0x02, 0x30, 0x00, 0x00, + 0x01, 0x06, 0x00, 0x9f, 0x31, 0x1f, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, + 0x1c, 0x3e, 0x59, 0xb1, 0x1a, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x8a, 0x00, 0x00, 0x03, 0xae, 0x05, 0xcb, + 0x02, 0x26, 0x02, 0x28, 0x00, 0x00, 0x01, 0x06, 0x00, 0x70, 0x3f, 0x26, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1c, 0x3e, 0x59, 0xb0, 0x0d, 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x8a, + 0x00, 0x00, 0x03, 0xae, 0x05, 0xf6, 0x02, 0x26, 0x02, 0x28, 0x00, 0x00, 0x01, 0x06, 0x00, 0xa1, 0x6c, 0x1f, 0x00, + 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1c, 0x3e, 0x59, 0xb1, 0x0f, 0x08, 0xf4, + 0x30, 0x31, 0xff, 0xff, 0x00, 0x8a, 0x00, 0x00, 0x03, 0xae, 0x05, 0xe0, 0x02, 0x26, 0x02, 0x28, 0x00, 0x00, 0x01, + 0x07, 0x00, 0xa2, 0x01, 0x1e, 0x00, 0x1e, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, + 0x06, 0x1c, 0x3e, 0x59, 0xb1, 0x13, 0x02, 0xf4, 0x30, 0x31, 0x00, 0x01, 0x00, 0x8a, 0xfe, 0x4f, 0x03, 0xae, 0x04, + 0x8d, 0x00, 0x1b, 0x00, 0x7c, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x16, 0x2f, 0x1b, 0xb1, 0x16, 0x1c, 0x3e, 0x59, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x14, 0x2f, 0x1b, 0xb1, 0x14, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0f, + 0x2f, 0x1b, 0xb1, 0x0f, 0x14, 0x3e, 0x59, 0xb0, 0x14, 0x10, 0xb0, 0x1b, 0xd0, 0xb0, 0x1b, 0x2f, 0xb2, 0x1f, 0x1b, + 0x01, 0x5d, 0xb2, 0xdf, 0x1b, 0x01, 0x5d, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb0, 0x14, 0x10, 0xb1, 0x02, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x14, 0x10, 0xb0, + 0x05, 0xd0, 0xb0, 0x0f, 0x10, 0xb1, 0x0a, 0x03, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x16, + 0x10, 0xb1, 0x19, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, 0x11, 0x21, + 0x15, 0x23, 0x07, 0x06, 0x15, 0x14, 0x33, 0x32, 0x37, 0x17, 0x06, 0x23, 0x22, 0x26, 0x35, 0x34, 0x37, 0x21, 0x11, + 0x21, 0x15, 0x21, 0x11, 0x21, 0x03, 0x57, 0xfd, 0xec, 0x02, 0x6b, 0x3d, 0x3a, 0x71, 0x4e, 0x30, 0x34, 0x0d, 0x46, + 0x5a, 0x59, 0x67, 0x9b, 0xfd, 0xca, 0x03, 0x1e, 0xfd, 0x9b, 0x02, 0x14, 0x02, 0x0e, 0xfe, 0x89, 0x97, 0x2d, 0x5b, + 0x56, 0x48, 0x1a, 0x79, 0x2c, 0x68, 0x56, 0x8a, 0x69, 0x04, 0x8d, 0x99, 0xfe, 0xb2, 0x00, 0xff, 0xff, 0x00, 0x8a, + 0x00, 0x00, 0x03, 0xae, 0x06, 0x1e, 0x02, 0x26, 0x02, 0x28, 0x00, 0x00, 0x01, 0x06, 0x00, 0x9f, 0x56, 0x1f, 0x00, + 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1c, 0x3e, 0x59, 0xb1, 0x11, 0x06, 0xf4, + 0x30, 0x31, 0xff, 0xff, 0x00, 0x63, 0xff, 0xf0, 0x04, 0x35, 0x06, 0x1e, 0x02, 0x26, 0x01, 0xe5, 0x00, 0x00, 0x01, + 0x06, 0x00, 0x9e, 0x71, 0x1e, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1c, + 0x3e, 0x59, 0xb1, 0x20, 0x04, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x63, 0xff, 0xf0, 0x04, 0x35, 0x05, 0xf6, 0x02, + 0x26, 0x01, 0xe5, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa1, 0x00, 0x9c, 0x00, 0x1f, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1c, 0x3e, 0x59, 0xb1, 0x20, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, + 0x63, 0xff, 0xf0, 0x04, 0x35, 0x05, 0xe0, 0x02, 0x26, 0x01, 0xe5, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa2, 0x01, 0x4e, + 0x00, 0x1e, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1c, 0x3e, 0x59, 0xb1, + 0x25, 0x02, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x63, 0xfd, 0xfc, 0x04, 0x35, 0x04, 0x9d, 0x02, 0x26, 0x01, 0xe5, + 0x00, 0x00, 0x00, 0x07, 0x01, 0xba, 0x01, 0x4f, 0xfe, 0x9d, 0xff, 0xff, 0x00, 0x8a, 0x00, 0x00, 0x04, 0x58, 0x06, + 0x1e, 0x02, 0x26, 0x01, 0xe4, 0x00, 0x00, 0x01, 0x07, 0x00, 0x9e, 0x00, 0x90, 0x00, 0x1e, 0x00, 0x14, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1c, 0x3e, 0x59, 0xb1, 0x10, 0x04, 0xf4, 0x30, 0x31, 0xff, + 0xff, 0xff, 0x95, 0x00, 0x00, 0x02, 0x58, 0x06, 0x0a, 0x02, 0x26, 0x01, 0xe3, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa5, + 0xff, 0x1a, 0x00, 0x22, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1c, 0x3e, + 0x59, 0xb1, 0x07, 0x02, 0xf4, 0x30, 0x31, 0xff, 0xff, 0xff, 0xaa, 0x00, 0x00, 0x02, 0x4a, 0x05, 0xcb, 0x02, 0x26, + 0x01, 0xe3, 0x00, 0x00, 0x01, 0x07, 0x00, 0x70, 0xff, 0x1c, 0x00, 0x26, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1c, 0x3e, 0x59, 0xb0, 0x05, 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0xff, 0xca, + 0x00, 0x00, 0x02, 0x21, 0x05, 0xf6, 0x02, 0x26, 0x01, 0xe3, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa1, 0xff, 0x49, 0x00, + 0x1f, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1c, 0x3e, 0x59, 0xb1, 0x07, + 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x06, 0xfe, 0x4f, 0x01, 0x66, 0x04, 0x8d, 0x02, 0x26, 0x01, 0xe3, 0x00, + 0x00, 0x00, 0x06, 0x00, 0xa4, 0xd4, 0x00, 0xff, 0xff, 0x00, 0x88, 0x00, 0x00, 0x01, 0x63, 0x05, 0xe0, 0x02, 0x26, + 0x01, 0xe3, 0x00, 0x00, 0x01, 0x06, 0x00, 0xa2, 0xfb, 0x1e, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, + 0x2f, 0x1b, 0xb1, 0x02, 0x1c, 0x3e, 0x59, 0xb1, 0x0b, 0x02, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x2b, 0xff, 0xf0, + 0x04, 0x0d, 0x06, 0x1e, 0x02, 0x26, 0x01, 0xe2, 0x00, 0x00, 0x01, 0x07, 0x00, 0x9e, 0x01, 0x07, 0x00, 0x1e, 0x00, + 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1c, 0x3e, 0x59, 0xb1, 0x14, 0x04, 0xf4, + 0x30, 0x31, 0xff, 0xff, 0x00, 0x8a, 0xfe, 0x05, 0x04, 0x57, 0x04, 0x8d, 0x02, 0x26, 0x01, 0xe1, 0x00, 0x00, 0x00, + 0x07, 0x01, 0xba, 0x01, 0x14, 0xfe, 0xa6, 0xff, 0xff, 0x00, 0x82, 0x00, 0x00, 0x03, 0x8b, 0x06, 0x1e, 0x02, 0x26, + 0x01, 0xe0, 0x00, 0x00, 0x01, 0x06, 0x00, 0x75, 0x07, 0x1e, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, + 0x2f, 0x1b, 0xb1, 0x05, 0x1c, 0x3e, 0x59, 0xb1, 0x08, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x8a, 0xfe, 0x07, + 0x03, 0x8b, 0x04, 0x8d, 0x02, 0x26, 0x01, 0xe0, 0x00, 0x00, 0x00, 0x07, 0x01, 0xba, 0x01, 0x10, 0xfe, 0xa8, 0xff, + 0xff, 0x00, 0x8a, 0x00, 0x00, 0x03, 0x8b, 0x04, 0x8e, 0x02, 0x26, 0x01, 0xe0, 0x00, 0x00, 0x01, 0x07, 0x01, 0xba, + 0x01, 0x7e, 0x03, 0x9f, 0x00, 0x10, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1c, 0x3e, + 0x59, 0x30, 0x31, 0xff, 0xff, 0x00, 0x8a, 0x00, 0x00, 0x03, 0x8b, 0x04, 0x8d, 0x02, 0x26, 0x01, 0xe0, 0x00, 0x00, + 0x00, 0x07, 0x00, 0xa2, 0x01, 0x66, 0xfd, 0x37, 0xff, 0xff, 0x00, 0x8a, 0x00, 0x00, 0x04, 0x58, 0x06, 0x1e, 0x02, + 0x26, 0x01, 0xde, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, 0x8f, 0x00, 0x1e, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1c, 0x3e, 0x59, 0xb1, 0x0c, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, + 0x8a, 0xfe, 0x03, 0x04, 0x58, 0x04, 0x8d, 0x02, 0x26, 0x01, 0xde, 0x00, 0x00, 0x00, 0x07, 0x01, 0xba, 0x01, 0x6c, + 0xfe, 0xa4, 0xff, 0xff, 0x00, 0x8a, 0x00, 0x00, 0x04, 0x58, 0x06, 0x1e, 0x02, 0x26, 0x01, 0xde, 0x00, 0x00, 0x01, + 0x07, 0x00, 0x9f, 0x00, 0xae, 0x00, 0x1f, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, + 0x06, 0x1c, 0x3e, 0x59, 0xb1, 0x0f, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x60, 0xff, 0xf0, 0x04, 0x5a, 0x05, + 0xcb, 0x02, 0x26, 0x01, 0xdd, 0x00, 0x00, 0x01, 0x07, 0x00, 0x70, 0x00, 0x85, 0x00, 0x26, 0x00, 0x13, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1c, 0x3e, 0x59, 0xb0, 0x1d, 0xdc, 0x30, 0x31, 0x00, 0xff, + 0xff, 0x00, 0x60, 0xff, 0xf0, 0x04, 0x5a, 0x05, 0xf6, 0x02, 0x26, 0x01, 0xdd, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa1, + 0x00, 0xb2, 0x00, 0x1f, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1c, 0x3e, + 0x59, 0xb1, 0x1f, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x60, 0xff, 0xf0, 0x04, 0x5a, 0x06, 0x1d, 0x02, 0x26, + 0x01, 0xdd, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa6, 0x01, 0x07, 0x00, 0x1e, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1c, 0x3e, 0x59, 0xb1, 0x1e, 0x06, 0xf4, 0xb0, 0x22, 0xd0, 0x30, 0x31, 0x00, + 0xff, 0xff, 0x00, 0x8a, 0x00, 0x00, 0x04, 0x25, 0x06, 0x1e, 0x02, 0x26, 0x01, 0xda, 0x00, 0x00, 0x01, 0x07, 0x00, + 0x75, 0x01, 0x27, 0x00, 0x1e, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x1c, + 0x3e, 0x59, 0xb1, 0x19, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x8a, 0xfe, 0x07, 0x04, 0x25, 0x04, 0x8d, 0x02, + 0x26, 0x01, 0xda, 0x00, 0x00, 0x00, 0x07, 0x01, 0xba, 0x01, 0x0d, 0xfe, 0xa8, 0xff, 0xff, 0x00, 0x8a, 0x00, 0x00, + 0x04, 0x25, 0x06, 0x1e, 0x02, 0x26, 0x01, 0xda, 0x00, 0x00, 0x01, 0x06, 0x00, 0x9f, 0x46, 0x1f, 0x00, 0x14, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1c, 0x3e, 0x59, 0xb1, 0x1c, 0x06, 0xf4, 0x30, 0x31, + 0xff, 0xff, 0x00, 0x43, 0xff, 0xf0, 0x03, 0xdd, 0x06, 0x1e, 0x02, 0x26, 0x01, 0xd9, 0x00, 0x00, 0x01, 0x07, 0x00, + 0x75, 0x01, 0x3e, 0x00, 0x1e, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x1c, + 0x3e, 0x59, 0xb1, 0x28, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x43, 0xff, 0xf0, 0x03, 0xdd, 0x06, 0x1e, 0x02, + 0x26, 0x01, 0xd9, 0x00, 0x00, 0x01, 0x06, 0x00, 0x9e, 0x48, 0x1e, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x1c, 0x3e, 0x59, 0xb1, 0x2a, 0x04, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x43, 0xfe, + 0x4d, 0x03, 0xdd, 0x04, 0x9d, 0x02, 0x26, 0x01, 0xd9, 0x00, 0x00, 0x00, 0x07, 0x00, 0x79, 0x01, 0x53, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x43, 0xff, 0xf0, 0x03, 0xdd, 0x06, 0x1e, 0x02, 0x26, 0x01, 0xd9, 0x00, 0x00, 0x01, 0x06, 0x00, + 0x9f, 0x5d, 0x1f, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x1c, 0x3e, 0x59, + 0xb1, 0x2a, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x28, 0xfe, 0x01, 0x03, 0xfd, 0x04, 0x8d, 0x02, 0x26, 0x01, + 0xd8, 0x00, 0x00, 0x00, 0x07, 0x01, 0xba, 0x01, 0x14, 0xfe, 0xa2, 0xff, 0xff, 0x00, 0x28, 0x00, 0x00, 0x03, 0xfd, + 0x06, 0x1e, 0x02, 0x26, 0x01, 0xd8, 0x00, 0x00, 0x01, 0x06, 0x00, 0x9f, 0x50, 0x1f, 0x00, 0x14, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1c, 0x3e, 0x59, 0xb1, 0x0d, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, + 0x00, 0x28, 0xfe, 0x4f, 0x03, 0xfd, 0x04, 0x8d, 0x02, 0x26, 0x01, 0xd8, 0x00, 0x00, 0x00, 0x07, 0x00, 0x79, 0x01, + 0x3e, 0x00, 0x02, 0xff, 0xff, 0x00, 0x74, 0xff, 0xf0, 0x04, 0x0a, 0x06, 0x0a, 0x02, 0x26, 0x01, 0xd7, 0x00, 0x00, + 0x01, 0x06, 0x00, 0xa5, 0x64, 0x22, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x11, 0x2f, 0x1b, 0xb1, 0x11, + 0x1c, 0x3e, 0x59, 0xb1, 0x15, 0x02, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x74, 0xff, 0xf0, 0x04, 0x0a, 0x05, 0xcb, + 0x02, 0x26, 0x01, 0xd7, 0x00, 0x00, 0x01, 0x06, 0x00, 0x70, 0x66, 0x26, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x1c, 0x3e, 0x59, 0xb0, 0x13, 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x74, + 0xff, 0xf0, 0x04, 0x0a, 0x05, 0xf6, 0x02, 0x26, 0x01, 0xd7, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa1, 0x00, 0x93, 0x00, + 0x1f, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x1c, 0x3e, 0x59, 0xb1, 0x15, + 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x74, 0xff, 0xf0, 0x04, 0x0a, 0x06, 0x79, 0x02, 0x26, 0x01, 0xd7, 0x00, + 0x00, 0x01, 0x07, 0x00, 0xa3, 0x00, 0xef, 0x00, 0x29, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, + 0x1b, 0xb1, 0x09, 0x1c, 0x3e, 0x59, 0xb1, 0x15, 0x06, 0xf4, 0xb0, 0x1f, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, + 0x74, 0xff, 0xf0, 0x04, 0x14, 0x06, 0x1d, 0x02, 0x26, 0x01, 0xd7, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa6, 0x00, 0xe8, + 0x00, 0x1e, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x11, 0x2f, 0x1b, 0xb1, 0x11, 0x1c, 0x3e, 0x59, 0xb1, + 0x14, 0x06, 0xf4, 0xb0, 0x18, 0xd0, 0x30, 0x31, 0x00, 0x00, 0x01, 0x00, 0x74, 0xfe, 0x74, 0x04, 0x0a, 0x04, 0x8d, + 0x00, 0x20, 0x00, 0x55, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x18, 0x2f, 0x1b, 0xb1, 0x18, 0x1c, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x0e, 0x2f, 0x1b, 0xb1, 0x0e, 0x14, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x13, 0x2f, + 0x1b, 0xb1, 0x13, 0x12, 0x3e, 0x59, 0xb0, 0x18, 0x10, 0xb0, 0x20, 0xd0, 0xb2, 0x05, 0x13, 0x20, 0x11, 0x12, 0x39, + 0xb0, 0x0e, 0x10, 0xb1, 0x09, 0x03, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x13, 0x10, 0xb1, + 0x1c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x11, 0x14, 0x06, 0x07, 0x07, + 0x06, 0x15, 0x14, 0x33, 0x32, 0x37, 0x17, 0x06, 0x23, 0x22, 0x26, 0x35, 0x34, 0x37, 0x22, 0x26, 0x27, 0x11, 0x33, + 0x11, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x11, 0x04, 0x0a, 0x78, 0x6f, 0x32, 0x6c, 0x4e, 0x30, 0x34, 0x0d, 0x46, + 0x5a, 0x59, 0x67, 0x5a, 0xcd, 0xf9, 0x04, 0xb7, 0x8f, 0x85, 0x83, 0x8f, 0x04, 0x8d, 0xfc, 0xf3, 0x7a, 0xba, 0x30, + 0x28, 0x5b, 0x52, 0x48, 0x1a, 0x79, 0x2c, 0x68, 0x56, 0x68, 0x56, 0xce, 0xb8, 0x03, 0x17, 0xfc, 0xf4, 0x79, 0x81, + 0x7f, 0x7b, 0x03, 0x0c, 0x00, 0xff, 0xff, 0x00, 0x31, 0x00, 0x00, 0x05, 0xf1, 0x06, 0x1e, 0x02, 0x26, 0x01, 0xd5, + 0x00, 0x00, 0x01, 0x07, 0x00, 0x9e, 0x01, 0x3b, 0x00, 0x1e, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, + 0x2f, 0x1b, 0xb1, 0x03, 0x1c, 0x3e, 0x59, 0xb1, 0x17, 0x04, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x0d, 0x00, 0x00, + 0x04, 0x1c, 0x06, 0x1e, 0x02, 0x26, 0x01, 0xd3, 0x00, 0x00, 0x01, 0x06, 0x00, 0x9e, 0x3d, 0x1e, 0x00, 0x14, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1c, 0x3e, 0x59, 0xb1, 0x0d, 0x04, 0xf4, 0x30, 0x31, + 0xff, 0xff, 0x00, 0x0d, 0x00, 0x00, 0x04, 0x1c, 0x05, 0xe3, 0x02, 0x26, 0x01, 0xd3, 0x00, 0x00, 0x01, 0x06, 0x00, + 0x6a, 0x6d, 0x1e, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1c, 0x3e, 0x59, + 0xb1, 0x10, 0x02, 0xf4, 0xb0, 0x19, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x47, 0x00, 0x00, 0x03, 0xe0, 0x06, + 0x1e, 0x02, 0x26, 0x01, 0xd2, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, 0x33, 0x00, 0x1e, 0x00, 0x14, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1c, 0x3e, 0x59, 0xb1, 0x0c, 0x06, 0xf4, 0x30, 0x31, 0xff, + 0xff, 0x00, 0x47, 0x00, 0x00, 0x03, 0xe0, 0x05, 0xe0, 0x02, 0x26, 0x01, 0xd2, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa2, + 0x01, 0x1a, 0x00, 0x1e, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1c, 0x3e, + 0x59, 0xb1, 0x11, 0x02, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x47, 0x00, 0x00, 0x03, 0xe0, 0x06, 0x1e, 0x02, 0x26, + 0x01, 0xd2, 0x00, 0x00, 0x01, 0x06, 0x00, 0x9f, 0x52, 0x1f, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, + 0x2f, 0x1b, 0xb1, 0x07, 0x1c, 0x3e, 0x59, 0xb1, 0x0f, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x1c, 0x00, 0x00, + 0x05, 0x1d, 0x06, 0x3f, 0x02, 0x26, 0x00, 0x25, 0x00, 0x00, 0x00, 0x06, 0x00, 0xae, 0x04, 0x00, 0xff, 0xff, 0xff, + 0x29, 0x00, 0x00, 0x04, 0x46, 0x06, 0x3f, 0x02, 0x26, 0x00, 0x29, 0x00, 0x00, 0x00, 0x07, 0x00, 0xae, 0xfe, 0x72, + 0x00, 0x00, 0xff, 0xff, 0xff, 0x37, 0x00, 0x00, 0x05, 0x08, 0x06, 0x41, 0x02, 0x26, 0x00, 0x2c, 0x00, 0x00, 0x00, + 0x07, 0x00, 0xae, 0xfe, 0x80, 0x00, 0x02, 0xff, 0xff, 0xff, 0x3d, 0x00, 0x00, 0x01, 0x77, 0x06, 0x40, 0x02, 0x26, + 0x00, 0x2d, 0x00, 0x00, 0x00, 0x07, 0x00, 0xae, 0xfe, 0x86, 0x00, 0x01, 0xff, 0xff, 0xff, 0xe6, 0xff, 0xec, 0x05, + 0x1d, 0x06, 0x3f, 0x00, 0x26, 0x00, 0x33, 0x14, 0x00, 0x00, 0x07, 0x00, 0xae, 0xff, 0x2f, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x14, 0x00, 0x00, 0x05, 0x1f, 0x06, 0x3f, 0x00, 0x26, 0x00, 0x3d, 0x64, 0x00, 0x00, 0x07, 0x00, 0xae, 0xfe, + 0x5d, 0x00, 0x00, 0xff, 0xff, 0xff, 0xe9, 0x00, 0x00, 0x04, 0xdf, 0x06, 0x3f, 0x00, 0x26, 0x00, 0xba, 0x14, 0x00, + 0x00, 0x07, 0x00, 0xae, 0xff, 0x32, 0x00, 0x00, 0xff, 0xff, 0xff, 0x9b, 0xff, 0xf4, 0x02, 0xad, 0x06, 0x74, 0x02, + 0x26, 0x00, 0xc3, 0x00, 0x00, 0x01, 0x07, 0x00, 0xaf, 0xff, 0x2a, 0xff, 0xec, 0x00, 0x1d, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x1a, 0x3e, 0x59, 0xb1, 0x18, 0x01, 0xf4, 0xb0, 0x0f, 0xd0, 0xb0, 0x18, + 0x10, 0xb0, 0x21, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x1c, 0x00, 0x00, 0x05, 0x1d, 0x05, 0xb0, 0x02, 0x06, + 0x00, 0x25, 0x00, 0x00, 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, 0x04, 0x88, 0x05, 0xb0, 0x02, 0x06, 0x00, 0x26, 0x00, + 0x00, 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, 0x04, 0x46, 0x05, 0xb0, 0x02, 0x06, 0x00, 0x29, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x56, 0x00, 0x00, 0x04, 0x7a, 0x05, 0xb0, 0x02, 0x06, 0x00, 0x3e, 0x00, 0x00, 0xff, 0xff, 0x00, 0xa9, 0x00, + 0x00, 0x05, 0x08, 0x05, 0xb0, 0x02, 0x06, 0x00, 0x2c, 0x00, 0x00, 0xff, 0xff, 0x00, 0xb7, 0x00, 0x00, 0x01, 0x77, + 0x05, 0xb0, 0x02, 0x06, 0x00, 0x2d, 0x00, 0x00, 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, 0x05, 0x05, 0x05, 0xb0, 0x02, + 0x06, 0x00, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, 0x06, 0x52, 0x05, 0xb0, 0x02, 0x06, 0x00, 0x31, + 0x00, 0x00, 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, 0x05, 0x08, 0x05, 0xb0, 0x02, 0x06, 0x00, 0x32, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x76, 0xff, 0xec, 0x05, 0x09, 0x05, 0xc4, 0x02, 0x06, 0x00, 0x33, 0x00, 0x00, 0xff, 0xff, 0x00, 0xa9, + 0x00, 0x00, 0x04, 0xc0, 0x05, 0xb0, 0x02, 0x06, 0x00, 0x34, 0x00, 0x00, 0xff, 0xff, 0x00, 0x31, 0x00, 0x00, 0x04, + 0x97, 0x05, 0xb0, 0x02, 0x06, 0x00, 0x38, 0x00, 0x00, 0xff, 0xff, 0x00, 0x0f, 0x00, 0x00, 0x04, 0xbb, 0x05, 0xb0, + 0x02, 0x06, 0x00, 0x3d, 0x00, 0x00, 0xff, 0xff, 0x00, 0x39, 0x00, 0x00, 0x04, 0xce, 0x05, 0xb0, 0x02, 0x06, 0x00, + 0x3c, 0x00, 0x00, 0xff, 0xff, 0xff, 0xd5, 0x00, 0x00, 0x02, 0x5e, 0x07, 0x07, 0x02, 0x26, 0x00, 0x2d, 0x00, 0x00, + 0x01, 0x07, 0x00, 0x6a, 0xff, 0x70, 0x01, 0x42, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, + 0xb1, 0x02, 0x1e, 0x3e, 0x59, 0xb1, 0x0b, 0x04, 0xf4, 0xb0, 0x14, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x0f, + 0x00, 0x00, 0x04, 0xbb, 0x06, 0xfb, 0x02, 0x26, 0x00, 0x3d, 0x00, 0x00, 0x01, 0x07, 0x00, 0x6a, 0x00, 0xc2, 0x01, + 0x36, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1e, 0x3e, 0x59, 0xb1, 0x10, + 0x04, 0xf4, 0xb0, 0x19, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x64, 0xff, 0xeb, 0x04, 0x77, 0x06, 0x3a, 0x02, + 0x26, 0x00, 0xbb, 0x00, 0x00, 0x01, 0x07, 0x00, 0xae, 0x01, 0x75, 0xff, 0xfb, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x13, 0x2f, 0x1b, 0xb1, 0x13, 0x1a, 0x3e, 0x59, 0xb1, 0x24, 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, + 0x63, 0xff, 0xec, 0x03, 0xec, 0x06, 0x39, 0x02, 0x26, 0x00, 0xbf, 0x00, 0x00, 0x01, 0x07, 0x00, 0xae, 0x01, 0x2b, + 0xff, 0xfa, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x15, 0x2f, 0x1b, 0xb1, 0x15, 0x1a, 0x3e, 0x59, 0xb1, + 0x28, 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x91, 0xfe, 0x61, 0x03, 0xf0, 0x06, 0x3a, 0x02, 0x26, 0x00, 0xc1, + 0x00, 0x00, 0x01, 0x07, 0x00, 0xae, 0x01, 0x46, 0xff, 0xfb, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, + 0x2f, 0x1b, 0xb1, 0x03, 0x1a, 0x3e, 0x59, 0xb1, 0x15, 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0xc3, 0xff, 0xf4, + 0x02, 0x4b, 0x06, 0x25, 0x02, 0x26, 0x00, 0xc3, 0x00, 0x00, 0x01, 0x06, 0x00, 0xae, 0x2a, 0xe6, 0x00, 0x14, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x1a, 0x3e, 0x59, 0xb1, 0x0f, 0x01, 0xf4, 0x30, 0x31, + 0xff, 0xff, 0x00, 0x8f, 0xff, 0xec, 0x03, 0xf6, 0x06, 0x74, 0x02, 0x26, 0x00, 0xcb, 0x00, 0x00, 0x01, 0x06, 0x00, + 0xaf, 0x21, 0xec, 0x00, 0x1d, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1a, 0x3e, 0x59, + 0xb1, 0x1d, 0x01, 0xf4, 0xb0, 0x15, 0xd0, 0xb0, 0x1d, 0x10, 0xb0, 0x27, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, + 0x9a, 0x00, 0x00, 0x04, 0x3f, 0x04, 0x3a, 0x02, 0x06, 0x00, 0x8e, 0x00, 0x00, 0xff, 0xff, 0x00, 0x5b, 0xff, 0xec, + 0x04, 0x34, 0x04, 0x4e, 0x02, 0x06, 0x00, 0x53, 0x00, 0x00, 0xff, 0xff, 0x00, 0x9a, 0xfe, 0x60, 0x03, 0xee, 0x04, + 0x3a, 0x02, 0x06, 0x00, 0x76, 0x00, 0x00, 0xff, 0xff, 0x00, 0x21, 0x00, 0x00, 0x03, 0xba, 0x04, 0x3a, 0x02, 0x06, + 0x00, 0x5a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x5a, 0xfe, 0x4c, 0x04, 0x74, 0x04, 0x49, 0x00, 0x1b, 0x00, 0x6e, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, + 0x2f, 0x1b, 0xb1, 0x00, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x13, 0x2f, 0x1b, 0xb1, 0x13, 0x14, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0e, 0x2f, 0x1b, 0xb1, 0x0e, 0x14, 0x3e, 0x59, 0xb2, 0x03, 0x04, 0x13, 0x11, + 0x12, 0x39, 0xb2, 0x12, 0x13, 0x04, 0x11, 0x12, 0x39, 0xb2, 0x06, 0x03, 0x12, 0x11, 0x12, 0x39, 0xb1, 0x09, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x15, 0x12, 0x03, 0x11, 0x12, 0x39, 0xb0, 0x00, 0x10, + 0xb1, 0x18, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x13, 0x32, 0x17, 0x13, 0x13, + 0x33, 0x01, 0x13, 0x16, 0x17, 0x33, 0x37, 0x07, 0x06, 0x23, 0x22, 0x26, 0x27, 0x03, 0x01, 0x23, 0x01, 0x03, 0x26, + 0x23, 0x07, 0x27, 0x36, 0xc2, 0xae, 0x58, 0x95, 0xff, 0xbb, 0xfe, 0xa0, 0xda, 0x3d, 0x44, 0x1a, 0x48, 0x2f, 0x18, + 0x25, 0x5b, 0x78, 0x3e, 0xa2, 0xfe, 0xe7, 0xc4, 0x01, 0x83, 0xa8, 0x49, 0x6b, 0x44, 0x01, 0x44, 0x04, 0x49, 0xc0, + 0xfe, 0xad, 0x02, 0x04, 0xfd, 0x2f, 0xfe, 0x0e, 0x80, 0x03, 0x05, 0x9e, 0x0f, 0x5e, 0x86, 0x01, 0x72, 0xfd, 0xbf, + 0x03, 0x10, 0x01, 0x83, 0xb7, 0x05, 0x94, 0x0f, 0x00, 0xff, 0xff, 0xff, 0xe5, 0xff, 0xf4, 0x02, 0x6e, 0x05, 0xb1, + 0x02, 0x26, 0x00, 0xc3, 0x00, 0x00, 0x01, 0x06, 0x00, 0x6a, 0x80, 0xec, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, 0x0c, 0x1a, 0x3e, 0x59, 0xb1, 0x14, 0x01, 0xf4, 0xb0, 0x1d, 0xd0, 0x30, 0x31, 0x00, + 0xff, 0xff, 0x00, 0x8f, 0xff, 0xec, 0x03, 0xf6, 0x05, 0xb1, 0x02, 0x26, 0x00, 0xcb, 0x00, 0x00, 0x01, 0x06, 0x00, + 0x6a, 0x77, 0xec, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1a, 0x3e, 0x59, + 0xb1, 0x1a, 0x01, 0xf4, 0xb0, 0x23, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x5b, 0xff, 0xec, 0x04, 0x34, 0x06, + 0x3a, 0x02, 0x26, 0x00, 0x53, 0x00, 0x00, 0x01, 0x07, 0x00, 0xae, 0x01, 0x43, 0xff, 0xfb, 0x00, 0x14, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb1, 0x1e, 0x01, 0xf4, 0x30, 0x31, 0xff, + 0xff, 0x00, 0x8f, 0xff, 0xec, 0x03, 0xf6, 0x06, 0x25, 0x02, 0x26, 0x00, 0xcb, 0x00, 0x00, 0x01, 0x07, 0x00, 0xae, + 0x01, 0x22, 0xff, 0xe6, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1a, 0x3e, + 0x59, 0xb1, 0x15, 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x7a, 0xff, 0xec, 0x06, 0x19, 0x06, 0x22, 0x02, 0x26, + 0x00, 0xce, 0x00, 0x00, 0x01, 0x07, 0x00, 0xae, 0x02, 0x53, 0xff, 0xe3, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1a, 0x3e, 0x59, 0xb1, 0x26, 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0xa9, + 0x00, 0x00, 0x04, 0x46, 0x07, 0x07, 0x02, 0x26, 0x00, 0x29, 0x00, 0x00, 0x01, 0x07, 0x00, 0x6a, 0x00, 0xc4, 0x01, + 0x42, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb1, 0x13, + 0x04, 0xf4, 0xb0, 0x1c, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0xb1, 0x00, 0x00, 0x04, 0x30, 0x07, 0x42, 0x02, + 0x26, 0x00, 0xb1, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, 0x90, 0x01, 0x42, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1e, 0x3e, 0x59, 0xb1, 0x08, 0x08, 0xf4, 0x30, 0x31, 0x00, 0x01, 0x00, + 0x50, 0xff, 0xec, 0x04, 0x72, 0x05, 0xc4, 0x00, 0x26, 0x00, 0x64, 0xb2, 0x00, 0x27, 0x28, 0x11, 0x12, 0x39, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x1a, + 0x2f, 0x1b, 0xb1, 0x1a, 0x12, 0x3e, 0x59, 0xb0, 0x06, 0x10, 0xb0, 0x0b, 0xd0, 0xb0, 0x06, 0x10, 0xb1, 0x0e, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x26, 0x1a, 0x06, 0x11, 0x12, 0x39, 0xb0, 0x26, 0x10, + 0xb1, 0x14, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x1a, 0x10, 0xb0, 0x1f, 0xd0, 0xb0, + 0x1a, 0x10, 0xb1, 0x22, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x26, 0x26, + 0x35, 0x34, 0x24, 0x33, 0x32, 0x16, 0x16, 0x15, 0x23, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x14, 0x16, 0x04, 0x16, + 0x16, 0x15, 0x14, 0x04, 0x23, 0x22, 0x24, 0x26, 0x35, 0x33, 0x14, 0x16, 0x33, 0x32, 0x36, 0x34, 0x26, 0x02, 0x56, + 0xf7, 0xe1, 0x01, 0x13, 0xdc, 0x96, 0xeb, 0x81, 0xc1, 0xa8, 0x99, 0x8e, 0x9f, 0x97, 0x01, 0x6b, 0xcd, 0x63, 0xfe, + 0xec, 0xe7, 0x96, 0xfe, 0xfc, 0x8d, 0xc1, 0xc3, 0xa3, 0x98, 0xa2, 0x96, 0x02, 0x89, 0x47, 0xcf, 0x98, 0xac, 0xe1, + 0x74, 0xcc, 0x79, 0x84, 0x97, 0x7d, 0x6f, 0x59, 0x7b, 0x66, 0x7b, 0xa4, 0x6f, 0xb1, 0xd5, 0x73, 0xc8, 0x7f, 0x84, + 0x99, 0x7c, 0xd6, 0x75, 0xff, 0xff, 0x00, 0xb7, 0x00, 0x00, 0x01, 0x77, 0x05, 0xb0, 0x02, 0x06, 0x00, 0x2d, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xd5, 0x00, 0x00, 0x02, 0x5e, 0x07, 0x07, 0x02, 0x26, 0x00, 0x2d, 0x00, 0x00, 0x01, 0x07, + 0x00, 0x6a, 0xff, 0x70, 0x01, 0x42, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, + 0x1e, 0x3e, 0x59, 0xb1, 0x0b, 0x04, 0xf4, 0xb0, 0x14, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x35, 0xff, 0xec, + 0x03, 0xcc, 0x05, 0xb0, 0x02, 0x06, 0x00, 0x2e, 0x00, 0x00, 0xff, 0xff, 0x00, 0xb2, 0x00, 0x00, 0x05, 0x1d, 0x05, + 0xb0, 0x02, 0x06, 0x02, 0x2c, 0x00, 0x00, 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, 0x05, 0x05, 0x07, 0x30, 0x02, 0x26, + 0x00, 0x2f, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, 0x7b, 0x01, 0x30, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x1e, 0x3e, 0x59, 0xb1, 0x0e, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x4d, + 0xff, 0xeb, 0x04, 0xcb, 0x07, 0x1a, 0x02, 0x26, 0x00, 0xde, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa1, 0x00, 0xda, 0x01, + 0x43, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x11, 0x2f, 0x1b, 0xb1, 0x11, 0x1e, 0x3e, 0x59, 0xb0, 0x15, + 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x1c, 0x00, 0x00, 0x05, 0x1d, 0x05, 0xb0, 0x02, 0x06, 0x00, 0x25, 0x00, + 0x00, 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, 0x04, 0x88, 0x05, 0xb0, 0x02, 0x06, 0x00, 0x26, 0x00, 0x00, 0xff, 0xff, + 0x00, 0xb1, 0x00, 0x00, 0x04, 0x30, 0x05, 0xb0, 0x02, 0x06, 0x00, 0xb1, 0x00, 0x00, 0xff, 0xff, 0x00, 0xa9, 0x00, + 0x00, 0x04, 0x46, 0x05, 0xb0, 0x02, 0x06, 0x00, 0x29, 0x00, 0x00, 0xff, 0xff, 0x00, 0xb1, 0x00, 0x00, 0x04, 0xff, + 0x07, 0x1a, 0x02, 0x26, 0x00, 0xdc, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa1, 0x01, 0x31, 0x01, 0x43, 0x00, 0x13, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1e, 0x3e, 0x59, 0xb0, 0x0d, 0xdc, 0x30, 0x31, 0x00, + 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, 0x06, 0x52, 0x05, 0xb0, 0x02, 0x06, 0x00, 0x31, 0x00, 0x00, 0xff, 0xff, 0x00, + 0xa9, 0x00, 0x00, 0x05, 0x08, 0x05, 0xb0, 0x02, 0x06, 0x00, 0x2c, 0x00, 0x00, 0xff, 0xff, 0x00, 0x76, 0xff, 0xec, + 0x05, 0x09, 0x05, 0xc4, 0x02, 0x06, 0x00, 0x33, 0x00, 0x00, 0xff, 0xff, 0x00, 0xb2, 0x00, 0x00, 0x05, 0x01, 0x05, + 0xb0, 0x02, 0x06, 0x00, 0xb6, 0x00, 0x00, 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, 0x04, 0xc0, 0x05, 0xb0, 0x02, 0x06, + 0x00, 0x34, 0x00, 0x00, 0xff, 0xff, 0x00, 0x77, 0xff, 0xec, 0x04, 0xd8, 0x05, 0xc4, 0x02, 0x06, 0x00, 0x27, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x31, 0x00, 0x00, 0x04, 0x97, 0x05, 0xb0, 0x02, 0x06, 0x00, 0x38, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x39, 0x00, 0x00, 0x04, 0xce, 0x05, 0xb0, 0x02, 0x06, 0x00, 0x3c, 0x00, 0x00, 0xff, 0xff, 0x00, 0x6d, 0xff, + 0xec, 0x03, 0xea, 0x04, 0x4e, 0x02, 0x06, 0x00, 0x45, 0x00, 0x00, 0xff, 0xff, 0x00, 0x5d, 0xff, 0xec, 0x03, 0xf3, + 0x04, 0x4e, 0x02, 0x06, 0x00, 0x49, 0x00, 0x00, 0xff, 0xff, 0x00, 0x9c, 0x00, 0x00, 0x04, 0x01, 0x05, 0xc4, 0x02, + 0x26, 0x00, 0xf0, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa1, 0x00, 0xa2, 0xff, 0xed, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, 0x3e, 0x59, 0xb0, 0x0d, 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, + 0x5b, 0xff, 0xec, 0x04, 0x34, 0x04, 0x4e, 0x02, 0x06, 0x00, 0x53, 0x00, 0x00, 0xff, 0xff, 0x00, 0x8c, 0xfe, 0x60, + 0x04, 0x1e, 0x04, 0x4e, 0x02, 0x06, 0x00, 0x54, 0x00, 0x00, 0x00, 0x01, 0x00, 0x5c, 0xff, 0xec, 0x03, 0xec, 0x04, + 0x4e, 0x00, 0x1d, 0x00, 0x4b, 0xb2, 0x10, 0x1e, 0x1f, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, + 0x2f, 0x1b, 0xb1, 0x10, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x12, 0x3e, + 0x59, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x08, 0x10, 0xb0, 0x03, 0xd0, + 0xb0, 0x10, 0x10, 0xb0, 0x14, 0xd0, 0xb0, 0x10, 0x10, 0xb1, 0x17, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, + 0xf4, 0x59, 0x30, 0x31, 0x25, 0x32, 0x36, 0x37, 0x33, 0x0e, 0x02, 0x23, 0x22, 0x00, 0x11, 0x35, 0x34, 0x36, 0x36, + 0x33, 0x32, 0x16, 0x17, 0x23, 0x26, 0x26, 0x23, 0x22, 0x06, 0x15, 0x15, 0x14, 0x16, 0x02, 0x3e, 0x63, 0x94, 0x08, + 0xaf, 0x05, 0x76, 0xc5, 0x6e, 0xdd, 0xfe, 0xfb, 0x74, 0xd9, 0x94, 0xb6, 0xf1, 0x08, 0xaf, 0x08, 0x8f, 0x69, 0x8d, + 0x9b, 0x9a, 0x83, 0x78, 0x5a, 0x5d, 0xa8, 0x64, 0x01, 0x27, 0x01, 0x00, 0x1f, 0x9e, 0xf6, 0x88, 0xda, 0xae, 0x69, + 0x87, 0xcb, 0xc0, 0x23, 0xbb, 0xca, 0x00, 0xff, 0xff, 0x00, 0x16, 0xfe, 0x4b, 0x03, 0xb0, 0x04, 0x3a, 0x02, 0x06, + 0x00, 0x5d, 0x00, 0x00, 0xff, 0xff, 0x00, 0x29, 0x00, 0x00, 0x03, 0xca, 0x04, 0x3a, 0x02, 0x06, 0x00, 0x5c, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x5d, 0xff, 0xec, 0x03, 0xf3, 0x05, 0xc5, 0x02, 0x26, 0x00, 0x49, 0x00, 0x00, 0x01, 0x07, + 0x00, 0x6a, 0x00, 0x8e, 0x00, 0x00, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, + 0x1a, 0x3e, 0x59, 0xb1, 0x25, 0x01, 0xf4, 0xb0, 0x2e, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x9a, 0x00, 0x00, + 0x03, 0x47, 0x05, 0xec, 0x02, 0x26, 0x00, 0xec, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x00, 0xcd, 0xff, 0xec, 0x00, + 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb1, 0x08, 0x09, 0xf4, + 0x30, 0x31, 0xff, 0xff, 0x00, 0x5f, 0xff, 0xec, 0x03, 0xbb, 0x04, 0x4e, 0x02, 0x06, 0x00, 0x57, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x8d, 0x00, 0x00, 0x01, 0x68, 0x05, 0xc4, 0x02, 0x06, 0x00, 0x4d, 0x00, 0x00, 0xff, 0xff, 0xff, 0xbb, + 0x00, 0x00, 0x02, 0x44, 0x05, 0xc4, 0x02, 0x26, 0x00, 0x8d, 0x00, 0x00, 0x01, 0x07, 0x00, 0x6a, 0xff, 0x56, 0xff, + 0xff, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1a, 0x3e, 0x59, 0xb1, 0x0b, + 0x01, 0xf4, 0xb0, 0x14, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0xff, 0xbf, 0xfe, 0x4b, 0x01, 0x59, 0x05, 0xc4, 0x02, + 0x06, 0x00, 0x4e, 0x00, 0x00, 0xff, 0xff, 0x00, 0x9c, 0x00, 0x00, 0x04, 0x3f, 0x05, 0xeb, 0x02, 0x26, 0x00, 0xf1, + 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, 0x3b, 0xff, 0xeb, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, + 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb1, 0x0f, 0x09, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x16, 0xfe, 0x4b, + 0x03, 0xb0, 0x05, 0xd8, 0x02, 0x26, 0x00, 0x5d, 0x00, 0x00, 0x01, 0x06, 0x00, 0xa1, 0x50, 0x01, 0x00, 0x13, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0f, 0x2f, 0x1b, 0xb1, 0x0f, 0x1a, 0x3e, 0x59, 0xb0, 0x13, 0xdc, 0x30, 0x31, 0x00, + 0xff, 0xff, 0x00, 0x3d, 0x00, 0x00, 0x06, 0xed, 0x07, 0x36, 0x02, 0x26, 0x00, 0x3b, 0x00, 0x00, 0x01, 0x07, 0x00, + 0x44, 0x02, 0x2c, 0x01, 0x36, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1e, + 0x3e, 0x59, 0xb1, 0x14, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x2b, 0x00, 0x00, 0x05, 0xd3, 0x06, 0x00, 0x02, + 0x26, 0x00, 0x5b, 0x00, 0x00, 0x01, 0x07, 0x00, 0x44, 0x01, 0x8b, 0x00, 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1a, 0x3e, 0x59, 0xb1, 0x0e, 0x09, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, + 0x3d, 0x00, 0x00, 0x06, 0xed, 0x07, 0x36, 0x02, 0x26, 0x00, 0x3b, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x02, 0xbb, + 0x01, 0x36, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1e, 0x3e, 0x59, 0xb1, + 0x15, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x2b, 0x00, 0x00, 0x05, 0xd3, 0x06, 0x00, 0x02, 0x26, 0x00, 0x5b, + 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x02, 0x1a, 0x00, 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, + 0x2f, 0x1b, 0xb1, 0x0c, 0x1a, 0x3e, 0x59, 0xb1, 0x0f, 0x09, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x3d, 0x00, 0x00, + 0x06, 0xed, 0x06, 0xfb, 0x02, 0x26, 0x00, 0x3b, 0x00, 0x00, 0x01, 0x07, 0x00, 0x6a, 0x01, 0xf5, 0x01, 0x36, 0x00, + 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1e, 0x3e, 0x59, 0xb1, 0x1a, 0x04, 0xf4, + 0xb0, 0x23, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x2b, 0x00, 0x00, 0x05, 0xd3, 0x05, 0xc5, 0x02, 0x26, 0x00, + 0x5b, 0x00, 0x00, 0x01, 0x07, 0x00, 0x6a, 0x01, 0x54, 0x00, 0x00, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1a, 0x3e, 0x59, 0xb1, 0x14, 0x01, 0xf4, 0xb0, 0x1d, 0xd0, 0x30, 0x31, 0x00, 0xff, + 0xff, 0x00, 0x0f, 0x00, 0x00, 0x04, 0xbb, 0x07, 0x36, 0x02, 0x26, 0x00, 0x3d, 0x00, 0x00, 0x01, 0x07, 0x00, 0x44, + 0x00, 0xf9, 0x01, 0x36, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1e, 0x3e, + 0x59, 0xb1, 0x0a, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x16, 0xfe, 0x4b, 0x03, 0xb0, 0x06, 0x00, 0x02, 0x26, + 0x00, 0x5d, 0x00, 0x00, 0x01, 0x07, 0x00, 0x44, 0x00, 0x8c, 0x00, 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x0f, 0x2f, 0x1b, 0xb1, 0x0f, 0x1a, 0x3e, 0x59, 0xb1, 0x11, 0x09, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x67, + 0x04, 0x21, 0x00, 0xfd, 0x06, 0x00, 0x02, 0x06, 0x00, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x00, 0x88, 0x04, 0x12, 0x02, + 0x23, 0x06, 0x00, 0x02, 0x06, 0x00, 0x06, 0x00, 0x00, 0xff, 0xff, 0x00, 0xa0, 0xff, 0xf5, 0x03, 0x8a, 0x05, 0xb0, + 0x00, 0x26, 0x00, 0x05, 0x00, 0x00, 0x00, 0x07, 0x00, 0x05, 0x02, 0x0f, 0x00, 0x00, 0xff, 0xff, 0xff, 0xb4, 0xfe, + 0x4b, 0x02, 0x3f, 0x05, 0xd8, 0x02, 0x26, 0x00, 0x9c, 0x00, 0x00, 0x01, 0x07, 0x00, 0x9f, 0xff, 0x48, 0xff, 0xd9, + 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1a, 0x3e, 0x59, 0xb1, 0x13, 0x01, + 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x30, 0x04, 0x16, 0x01, 0x47, 0x06, 0x00, 0x02, 0x06, 0x01, 0x85, 0x00, 0x00, + 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, 0x06, 0x52, 0x07, 0x36, 0x02, 0x26, 0x00, 0x31, 0x00, 0x00, 0x01, 0x07, 0x00, + 0x75, 0x02, 0x99, 0x01, 0x36, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1e, + 0x3e, 0x59, 0xb1, 0x11, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x8b, 0x00, 0x00, 0x06, 0x78, 0x06, 0x00, 0x02, + 0x26, 0x00, 0x51, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x02, 0xad, 0x00, 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1a, 0x3e, 0x59, 0xb1, 0x20, 0x09, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, + 0x1c, 0xfe, 0x6b, 0x05, 0x1d, 0x05, 0xb0, 0x02, 0x26, 0x00, 0x25, 0x00, 0x00, 0x00, 0x07, 0x00, 0xa7, 0x01, 0x7f, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x6d, 0xfe, 0x6b, 0x03, 0xea, 0x04, 0x4e, 0x02, 0x26, 0x00, 0x45, 0x00, 0x00, 0x00, + 0x07, 0x00, 0xa7, 0x00, 0xc7, 0x00, 0x00, 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, 0x04, 0x46, 0x07, 0x42, 0x02, 0x26, + 0x00, 0x29, 0x00, 0x00, 0x01, 0x07, 0x00, 0x44, 0x00, 0xfb, 0x01, 0x42, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb1, 0x0d, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0xb1, + 0x00, 0x00, 0x04, 0xff, 0x07, 0x42, 0x02, 0x26, 0x00, 0xdc, 0x00, 0x00, 0x01, 0x07, 0x00, 0x44, 0x01, 0x6d, 0x01, + 0x42, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1e, 0x3e, 0x59, 0xb1, 0x0b, + 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x5d, 0xff, 0xec, 0x03, 0xf3, 0x06, 0x00, 0x02, 0x26, 0x00, 0x49, 0x00, + 0x00, 0x01, 0x07, 0x00, 0x44, 0x00, 0xc5, 0x00, 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, + 0x1b, 0xb1, 0x08, 0x1a, 0x3e, 0x59, 0xb1, 0x1f, 0x09, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x9c, 0x00, 0x00, 0x04, + 0x01, 0x05, 0xec, 0x02, 0x26, 0x00, 0xf0, 0x00, 0x00, 0x01, 0x07, 0x00, 0x44, 0x00, 0xde, 0xff, 0xec, 0x00, 0x14, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, 0x3e, 0x59, 0xb1, 0x0b, 0x09, 0xf4, 0x30, + 0x31, 0xff, 0xff, 0x00, 0x5a, 0x00, 0x00, 0x05, 0x21, 0x05, 0xb0, 0x02, 0x06, 0x00, 0xb9, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x5f, 0xfe, 0x28, 0x05, 0x43, 0x04, 0x3a, 0x02, 0x06, 0x00, 0xcd, 0x00, 0x00, 0xff, 0xff, 0x00, 0x16, 0x00, + 0x00, 0x04, 0xdd, 0x06, 0xe8, 0x02, 0x26, 0x01, 0x19, 0x00, 0x00, 0x01, 0x07, 0x00, 0xac, 0x04, 0x39, 0x00, 0xfa, + 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0f, 0x2f, 0x1b, 0xb1, 0x0f, 0x1e, 0x3e, 0x59, 0xb1, 0x11, 0x08, + 0xf4, 0xb0, 0x15, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0xff, 0xfb, 0x00, 0x00, 0x04, 0x0b, 0x05, 0xc1, 0x02, 0x26, + 0x01, 0x1a, 0x00, 0x00, 0x01, 0x07, 0x00, 0xac, 0x03, 0xd4, 0xff, 0xd3, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x11, 0x2f, 0x1b, 0xb1, 0x11, 0x1a, 0x3e, 0x59, 0xb1, 0x13, 0x09, 0xf4, 0xb0, 0x17, 0xd0, 0x30, 0x31, 0x00, + 0xff, 0xff, 0x00, 0x5b, 0xfe, 0x4b, 0x08, 0x40, 0x04, 0x4e, 0x00, 0x26, 0x00, 0x53, 0x00, 0x00, 0x00, 0x07, 0x00, + 0x5d, 0x04, 0x90, 0x00, 0x00, 0xff, 0xff, 0x00, 0x76, 0xfe, 0x4b, 0x09, 0x30, 0x05, 0xc4, 0x00, 0x26, 0x00, 0x33, + 0x00, 0x00, 0x00, 0x07, 0x00, 0x5d, 0x05, 0x80, 0x00, 0x00, 0xff, 0xff, 0x00, 0x50, 0xfe, 0x51, 0x04, 0x6a, 0x05, + 0xc4, 0x02, 0x26, 0x00, 0xdb, 0x00, 0x00, 0x00, 0x07, 0x02, 0x51, 0x01, 0x9c, 0xff, 0xb8, 0xff, 0xff, 0x00, 0x58, + 0xfe, 0x52, 0x03, 0xac, 0x04, 0x4d, 0x02, 0x26, 0x00, 0xef, 0x00, 0x00, 0x00, 0x07, 0x02, 0x51, 0x01, 0x43, 0xff, + 0xb9, 0xff, 0xff, 0x00, 0x77, 0xfe, 0x51, 0x04, 0xd8, 0x05, 0xc4, 0x02, 0x26, 0x00, 0x27, 0x00, 0x00, 0x00, 0x07, + 0x02, 0x51, 0x01, 0xe5, 0xff, 0xb8, 0xff, 0xff, 0x00, 0x5c, 0xfe, 0x51, 0x03, 0xec, 0x04, 0x4e, 0x02, 0x26, 0x00, + 0x47, 0x00, 0x00, 0x00, 0x07, 0x02, 0x51, 0x01, 0x52, 0xff, 0xb8, 0xff, 0xff, 0x00, 0x0f, 0x00, 0x00, 0x04, 0xbb, + 0x05, 0xb0, 0x02, 0x06, 0x00, 0x3d, 0x00, 0x00, 0xff, 0xff, 0x00, 0x2e, 0xfe, 0x60, 0x03, 0xdf, 0x04, 0x3a, 0x02, + 0x06, 0x00, 0xbd, 0x00, 0x00, 0xff, 0xff, 0x00, 0xb7, 0x00, 0x00, 0x01, 0x77, 0x05, 0xb0, 0x02, 0x06, 0x00, 0x2d, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x1b, 0x00, 0x00, 0x07, 0x35, 0x07, 0x1a, 0x02, 0x26, 0x00, 0xda, 0x00, 0x00, 0x01, + 0x07, 0x00, 0xa1, 0x01, 0xf8, 0x01, 0x43, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, + 0x0d, 0x1e, 0x3e, 0x59, 0xb0, 0x19, 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x15, 0x00, 0x00, 0x06, 0x04, 0x05, + 0xc4, 0x02, 0x26, 0x00, 0xee, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa1, 0x01, 0x5f, 0xff, 0xed, 0x00, 0x13, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1a, 0x3e, 0x59, 0xb0, 0x19, 0xdc, 0x30, 0x31, 0x00, 0xff, + 0xff, 0x00, 0xb7, 0x00, 0x00, 0x01, 0x77, 0x05, 0xb0, 0x02, 0x06, 0x00, 0x2d, 0x00, 0x00, 0xff, 0xff, 0x00, 0x1c, + 0x00, 0x00, 0x05, 0x1d, 0x07, 0x0e, 0x02, 0x26, 0x00, 0x25, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa1, 0x00, 0xf4, 0x01, + 0x37, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1e, 0x3e, 0x59, 0xb0, 0x0e, + 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x6d, 0xff, 0xec, 0x03, 0xea, 0x05, 0xd8, 0x02, 0x26, 0x00, 0x45, 0x00, + 0x00, 0x01, 0x07, 0x00, 0xa1, 0x00, 0x99, 0x00, 0x01, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x17, 0x2f, + 0x1b, 0xb1, 0x17, 0x1a, 0x3e, 0x59, 0xb0, 0x2c, 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x1c, 0x00, 0x00, 0x05, + 0x1d, 0x06, 0xfb, 0x02, 0x26, 0x00, 0x25, 0x00, 0x00, 0x01, 0x07, 0x00, 0x6a, 0x00, 0xf9, 0x01, 0x36, 0x00, 0x17, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1e, 0x3e, 0x59, 0xb1, 0x12, 0x04, 0xf4, 0xb0, + 0x1b, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x6d, 0xff, 0xec, 0x03, 0xea, 0x05, 0xc5, 0x02, 0x26, 0x00, 0x45, + 0x00, 0x00, 0x01, 0x07, 0x00, 0x6a, 0x00, 0x9e, 0x00, 0x00, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x17, + 0x2f, 0x1b, 0xb1, 0x17, 0x1a, 0x3e, 0x59, 0xb1, 0x30, 0x01, 0xf4, 0xb0, 0x39, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, + 0xff, 0xf2, 0x00, 0x00, 0x07, 0x57, 0x05, 0xb0, 0x02, 0x06, 0x00, 0x81, 0x00, 0x00, 0xff, 0xff, 0x00, 0x4e, 0xff, + 0xec, 0x06, 0x7c, 0x04, 0x4e, 0x02, 0x06, 0x00, 0x86, 0x00, 0x00, 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, 0x04, 0x46, + 0x07, 0x1a, 0x02, 0x26, 0x00, 0x29, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa1, 0x00, 0xbf, 0x01, 0x43, 0x00, 0x13, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb0, 0x0f, 0xdc, 0x30, 0x31, 0x00, + 0xff, 0xff, 0x00, 0x5d, 0xff, 0xec, 0x03, 0xf3, 0x05, 0xd8, 0x02, 0x26, 0x00, 0x49, 0x00, 0x00, 0x01, 0x07, 0x00, + 0xa1, 0x00, 0x89, 0x00, 0x01, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, + 0x3e, 0x59, 0xb0, 0x21, 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x5d, 0xff, 0xec, 0x05, 0x12, 0x06, 0xd9, 0x02, + 0x26, 0x01, 0x58, 0x00, 0x00, 0x01, 0x07, 0x00, 0x6a, 0x00, 0xd3, 0x01, 0x14, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1e, 0x3e, 0x59, 0xb1, 0x27, 0x04, 0xf4, 0xb0, 0x30, 0xd0, 0x30, 0x31, + 0x00, 0xff, 0xff, 0x00, 0x62, 0xff, 0xec, 0x03, 0xe9, 0x04, 0x4f, 0x02, 0x06, 0x00, 0x9d, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x62, 0xff, 0xec, 0x03, 0xe9, 0x05, 0xc6, 0x02, 0x26, 0x00, 0x9d, 0x00, 0x00, 0x01, 0x07, 0x00, 0x6a, 0x00, + 0x87, 0x00, 0x01, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x1a, 0x3e, 0x59, + 0xb1, 0x24, 0x01, 0xf4, 0xb0, 0x2d, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x1b, 0x00, 0x00, 0x07, 0x35, 0x07, + 0x07, 0x02, 0x26, 0x00, 0xda, 0x00, 0x00, 0x01, 0x07, 0x00, 0x6a, 0x01, 0xfd, 0x01, 0x42, 0x00, 0x17, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1e, 0x3e, 0x59, 0xb1, 0x1d, 0x04, 0xf4, 0xb0, 0x26, 0xd0, + 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x15, 0x00, 0x00, 0x06, 0x04, 0x05, 0xb1, 0x02, 0x26, 0x00, 0xee, 0x00, 0x00, + 0x01, 0x07, 0x00, 0x6a, 0x01, 0x64, 0xff, 0xec, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, + 0xb1, 0x0d, 0x1a, 0x3e, 0x59, 0xb1, 0x1d, 0x01, 0xf4, 0xb0, 0x26, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x50, + 0xff, 0xec, 0x04, 0x6a, 0x07, 0x1c, 0x02, 0x26, 0x00, 0xdb, 0x00, 0x00, 0x01, 0x07, 0x00, 0x6a, 0x00, 0xb7, 0x01, + 0x57, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1e, 0x3e, 0x59, 0xb1, 0x30, + 0x04, 0xf4, 0xb0, 0x39, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x58, 0xff, 0xed, 0x03, 0xac, 0x05, 0xc5, 0x02, + 0x26, 0x00, 0xef, 0x00, 0x00, 0x01, 0x06, 0x00, 0x6a, 0x5e, 0x00, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1a, 0x3e, 0x59, 0xb1, 0x2e, 0x01, 0xf4, 0xb0, 0x37, 0xd0, 0x30, 0x31, 0x00, 0xff, + 0xff, 0x00, 0xb1, 0x00, 0x00, 0x04, 0xff, 0x06, 0xef, 0x02, 0x26, 0x00, 0xdc, 0x00, 0x00, 0x01, 0x07, 0x00, 0x70, + 0x01, 0x04, 0x01, 0x4a, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1e, 0x3e, + 0x59, 0xb0, 0x0b, 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x9c, 0x00, 0x00, 0x04, 0x01, 0x05, 0x99, 0x02, 0x26, + 0x00, 0xf0, 0x00, 0x00, 0x01, 0x06, 0x00, 0x70, 0x75, 0xf4, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, + 0x2f, 0x1b, 0xb1, 0x07, 0x1a, 0x3e, 0x59, 0xb0, 0x0b, 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0xb1, 0x00, 0x00, + 0x04, 0xff, 0x07, 0x07, 0x02, 0x26, 0x00, 0xdc, 0x00, 0x00, 0x01, 0x07, 0x00, 0x6a, 0x01, 0x36, 0x01, 0x42, 0x00, + 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1e, 0x3e, 0x59, 0xb1, 0x11, 0x04, 0xf4, + 0xb0, 0x1a, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x9c, 0x00, 0x00, 0x04, 0x01, 0x05, 0xb1, 0x02, 0x26, 0x00, + 0xf0, 0x00, 0x00, 0x01, 0x07, 0x00, 0x6a, 0x00, 0xa7, 0xff, 0xec, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, 0x3e, 0x59, 0xb1, 0x11, 0x01, 0xf4, 0xb0, 0x1a, 0xd0, 0x30, 0x31, 0x00, 0xff, + 0xff, 0x00, 0x76, 0xff, 0xec, 0x05, 0x09, 0x06, 0xfd, 0x02, 0x26, 0x00, 0x33, 0x00, 0x00, 0x01, 0x07, 0x00, 0x6a, + 0x01, 0x1b, 0x01, 0x38, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1e, 0x3e, + 0x59, 0xb1, 0x27, 0x04, 0xf4, 0xb0, 0x30, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x5b, 0xff, 0xec, 0x04, 0x34, + 0x05, 0xc5, 0x02, 0x26, 0x00, 0x53, 0x00, 0x00, 0x01, 0x07, 0x00, 0x6a, 0x00, 0x98, 0x00, 0x00, 0x00, 0x17, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb1, 0x23, 0x01, 0xf4, 0xb0, 0x2c, + 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x67, 0xff, 0xec, 0x04, 0xfa, 0x05, 0xc4, 0x02, 0x06, 0x01, 0x17, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x5b, 0xff, 0xec, 0x04, 0x34, 0x04, 0x4e, 0x02, 0x06, 0x01, 0x18, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x67, 0xff, 0xec, 0x04, 0xfa, 0x07, 0x02, 0x02, 0x26, 0x01, 0x17, 0x00, 0x00, 0x01, 0x07, 0x00, 0x6a, 0x01, + 0x27, 0x01, 0x3d, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1e, 0x3e, 0x59, + 0xb1, 0x27, 0x04, 0xf4, 0xb0, 0x30, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x5b, 0xff, 0xec, 0x04, 0x34, 0x05, + 0xc7, 0x02, 0x26, 0x01, 0x18, 0x00, 0x00, 0x01, 0x07, 0x00, 0x6a, 0x00, 0x88, 0x00, 0x02, 0x00, 0x17, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb1, 0x24, 0x01, 0xf4, 0xb0, 0x2d, 0xd0, + 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x93, 0xff, 0xec, 0x04, 0xf4, 0x07, 0x1d, 0x02, 0x26, 0x00, 0xe7, 0x00, 0x00, + 0x01, 0x07, 0x00, 0x6a, 0x01, 0x0d, 0x01, 0x58, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x13, 0x2f, 0x1b, + 0xb1, 0x13, 0x1e, 0x3e, 0x59, 0xb1, 0x27, 0x04, 0xf4, 0xb0, 0x30, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x64, + 0xff, 0xec, 0x03, 0xe0, 0x05, 0xc5, 0x02, 0x26, 0x00, 0xff, 0x00, 0x00, 0x01, 0x06, 0x00, 0x6a, 0x7c, 0x00, 0x00, + 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, 0x3e, 0x59, 0xb1, 0x27, 0x01, 0xf4, + 0xb0, 0x30, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x4d, 0xff, 0xeb, 0x04, 0xcb, 0x06, 0xef, 0x02, 0x26, 0x00, + 0xde, 0x00, 0x00, 0x01, 0x07, 0x00, 0x70, 0x00, 0xad, 0x01, 0x4a, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x11, 0x2f, 0x1b, 0xb1, 0x11, 0x1e, 0x3e, 0x59, 0xb0, 0x13, 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x16, 0xfe, + 0x4b, 0x03, 0xb0, 0x05, 0xad, 0x02, 0x26, 0x00, 0x5d, 0x00, 0x00, 0x01, 0x06, 0x00, 0x70, 0x23, 0x08, 0x00, 0x13, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0e, 0x2f, 0x1b, 0xb1, 0x0e, 0x1a, 0x3e, 0x59, 0xb0, 0x11, 0xdc, 0x30, 0x31, + 0x00, 0xff, 0xff, 0x00, 0x4d, 0xff, 0xeb, 0x04, 0xcb, 0x07, 0x07, 0x02, 0x26, 0x00, 0xde, 0x00, 0x00, 0x01, 0x07, + 0x00, 0x6a, 0x00, 0xdf, 0x01, 0x42, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x11, 0x2f, 0x1b, 0xb1, 0x11, + 0x1e, 0x3e, 0x59, 0xb1, 0x19, 0x04, 0xf4, 0xb0, 0x22, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x16, 0xfe, 0x4b, + 0x03, 0xb0, 0x05, 0xc5, 0x02, 0x26, 0x00, 0x5d, 0x00, 0x00, 0x01, 0x06, 0x00, 0x6a, 0x55, 0x00, 0x00, 0x17, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0f, 0x2f, 0x1b, 0xb1, 0x0f, 0x1a, 0x3e, 0x59, 0xb1, 0x17, 0x01, 0xf4, 0xb0, 0x20, + 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x4d, 0xff, 0xeb, 0x04, 0xcb, 0x07, 0x41, 0x02, 0x26, 0x00, 0xde, 0x00, + 0x00, 0x01, 0x07, 0x00, 0xa6, 0x01, 0x2f, 0x01, 0x42, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, + 0x1b, 0xb1, 0x01, 0x1e, 0x3e, 0x59, 0xb1, 0x14, 0x08, 0xf4, 0xb0, 0x18, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, + 0x16, 0xfe, 0x4b, 0x03, 0xd1, 0x05, 0xff, 0x02, 0x26, 0x00, 0x5d, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa6, 0x00, 0xa5, + 0x00, 0x00, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0f, 0x2f, 0x1b, 0xb1, 0x0f, 0x1a, 0x3e, 0x59, 0xb1, + 0x16, 0x09, 0xf4, 0xb0, 0x12, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x96, 0x00, 0x00, 0x04, 0xc8, 0x07, 0x07, + 0x02, 0x26, 0x00, 0xe1, 0x00, 0x00, 0x01, 0x07, 0x00, 0x6a, 0x01, 0x09, 0x01, 0x42, 0x00, 0x17, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1e, 0x3e, 0x59, 0xb1, 0x1a, 0x04, 0xf4, 0xb0, 0x23, 0xd0, 0x30, + 0x31, 0x00, 0xff, 0xff, 0x00, 0x67, 0x00, 0x00, 0x03, 0xbd, 0x05, 0xb1, 0x02, 0x26, 0x00, 0xf9, 0x00, 0x00, 0x01, + 0x06, 0x00, 0x6a, 0x64, 0xec, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x1a, + 0x3e, 0x59, 0xb1, 0x18, 0x01, 0xf4, 0xb0, 0x21, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0xb2, 0x00, 0x00, 0x06, + 0x30, 0x07, 0x07, 0x00, 0x26, 0x00, 0xe6, 0x0f, 0x00, 0x00, 0x27, 0x00, 0x2d, 0x04, 0xb9, 0x00, 0x00, 0x01, 0x07, + 0x00, 0x6a, 0x01, 0xd3, 0x01, 0x42, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, + 0x1e, 0x3e, 0x59, 0xb1, 0x1f, 0x04, 0xf4, 0xb0, 0x28, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x9d, 0x00, 0x00, + 0x05, 0x7f, 0x05, 0xb1, 0x00, 0x26, 0x00, 0xfe, 0x00, 0x00, 0x00, 0x27, 0x00, 0x8d, 0x04, 0x2a, 0x00, 0x00, 0x01, + 0x07, 0x00, 0x6a, 0x01, 0x6d, 0xff, 0xec, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, + 0x0a, 0x1a, 0x3e, 0x59, 0xb1, 0x1f, 0x01, 0xf4, 0xb0, 0x28, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x5f, 0xff, + 0xec, 0x03, 0xf0, 0x06, 0x00, 0x02, 0x06, 0x00, 0x48, 0x00, 0x00, 0xff, 0xff, 0x00, 0x1c, 0xfe, 0xa2, 0x05, 0x1d, + 0x05, 0xb0, 0x02, 0x26, 0x00, 0x25, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x05, 0x02, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x6d, 0xfe, 0xa2, 0x03, 0xea, 0x04, 0x4e, 0x02, 0x26, 0x00, 0x45, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x04, 0x4a, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x1c, 0x00, 0x00, 0x05, 0x1d, 0x07, 0xba, 0x02, 0x26, 0x00, 0x25, 0x00, 0x00, 0x01, + 0x07, 0x00, 0xab, 0x04, 0xee, 0x01, 0x46, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, + 0x04, 0x1e, 0x3e, 0x59, 0xb1, 0x0b, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x6d, 0xff, 0xec, 0x03, 0xea, 0x06, + 0x84, 0x02, 0x26, 0x00, 0x45, 0x00, 0x00, 0x01, 0x07, 0x00, 0xab, 0x04, 0x93, 0x00, 0x10, 0x00, 0x14, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x17, 0x2f, 0x1b, 0xb1, 0x17, 0x1a, 0x3e, 0x59, 0xb1, 0x29, 0x01, 0xf4, 0x30, 0x31, 0xff, + 0xff, 0x00, 0x1c, 0x00, 0x00, 0x05, 0x1d, 0x07, 0xc3, 0x02, 0x26, 0x00, 0x25, 0x00, 0x00, 0x01, 0x07, 0x02, 0x37, + 0x00, 0xc3, 0x01, 0x2e, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x1e, 0x3e, + 0x59, 0xb1, 0x0e, 0x0c, 0xf4, 0xb0, 0x14, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x6d, 0xff, 0xec, 0x04, 0xc0, + 0x06, 0x8e, 0x02, 0x26, 0x00, 0x45, 0x00, 0x00, 0x01, 0x06, 0x02, 0x37, 0x68, 0xf9, 0x00, 0x17, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x17, 0x2f, 0x1b, 0xb1, 0x17, 0x1a, 0x3e, 0x59, 0xb1, 0x2c, 0x08, 0xf4, 0xb0, 0x32, 0xd0, 0x30, + 0x31, 0x00, 0xff, 0xff, 0x00, 0x1c, 0x00, 0x00, 0x05, 0x1d, 0x07, 0xbf, 0x02, 0x26, 0x00, 0x25, 0x00, 0x00, 0x01, + 0x07, 0x02, 0x38, 0x00, 0xc7, 0x01, 0x3d, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, + 0x04, 0x1e, 0x3e, 0x59, 0xb1, 0x0e, 0x0c, 0xf4, 0xb0, 0x13, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0xff, 0xca, 0xff, + 0xec, 0x03, 0xea, 0x06, 0x89, 0x02, 0x26, 0x00, 0x45, 0x00, 0x00, 0x01, 0x06, 0x02, 0x38, 0x6c, 0x07, 0x00, 0x17, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x17, 0x2f, 0x1b, 0xb1, 0x17, 0x1a, 0x3e, 0x59, 0xb1, 0x2c, 0x08, 0xf4, 0xb0, + 0x31, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x1c, 0x00, 0x00, 0x05, 0x1d, 0x07, 0xea, 0x02, 0x26, 0x00, 0x25, + 0x00, 0x00, 0x01, 0x07, 0x02, 0x39, 0x00, 0xc8, 0x01, 0x1b, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, + 0x2f, 0x1b, 0xb1, 0x05, 0x1e, 0x3e, 0x59, 0xb1, 0x0c, 0x0c, 0xf4, 0xb0, 0x20, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, + 0x00, 0x6d, 0xff, 0xec, 0x04, 0x59, 0x06, 0xb5, 0x02, 0x26, 0x00, 0x45, 0x00, 0x00, 0x01, 0x06, 0x02, 0x39, 0x6d, + 0xe6, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x17, 0x2f, 0x1b, 0xb1, 0x17, 0x1a, 0x3e, 0x59, 0xb1, 0x2a, + 0x08, 0xf4, 0xb0, 0x30, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x1c, 0x00, 0x00, 0x05, 0x1d, 0x07, 0xda, 0x02, + 0x26, 0x00, 0x25, 0x00, 0x00, 0x01, 0x07, 0x02, 0x3a, 0x00, 0xc7, 0x01, 0x06, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x1e, 0x3e, 0x59, 0xb1, 0x0c, 0x0c, 0xf4, 0xb0, 0x15, 0xd0, 0x30, 0x31, + 0x00, 0xff, 0xff, 0x00, 0x6d, 0xff, 0xec, 0x03, 0xea, 0x06, 0xa5, 0x02, 0x26, 0x00, 0x45, 0x00, 0x00, 0x01, 0x06, + 0x02, 0x3a, 0x6c, 0xd1, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x17, 0x2f, 0x1b, 0xb1, 0x17, 0x1a, 0x3e, + 0x59, 0xb1, 0x2a, 0x08, 0xf4, 0xb0, 0x33, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x1c, 0xfe, 0xa2, 0x05, 0x1d, + 0x07, 0x36, 0x02, 0x26, 0x00, 0x25, 0x00, 0x00, 0x00, 0x27, 0x00, 0x9e, 0x00, 0xc9, 0x01, 0x36, 0x01, 0x07, 0x00, + 0xad, 0x05, 0x02, 0x00, 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1e, + 0x3e, 0x59, 0xb1, 0x0f, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x6d, 0xfe, 0xa2, 0x03, 0xea, 0x06, 0x00, 0x02, + 0x26, 0x00, 0x45, 0x00, 0x00, 0x00, 0x26, 0x00, 0x9e, 0x6e, 0x00, 0x01, 0x07, 0x00, 0xad, 0x04, 0x4a, 0x00, 0x00, + 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x17, 0x2f, 0x1b, 0xb1, 0x17, 0x1a, 0x3e, 0x59, 0xb1, 0x2d, 0x01, + 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x1c, 0x00, 0x00, 0x05, 0x1d, 0x07, 0xb7, 0x02, 0x26, 0x00, 0x25, 0x00, 0x00, + 0x01, 0x07, 0x02, 0x3c, 0x00, 0xea, 0x01, 0x2d, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, + 0xb1, 0x04, 0x1e, 0x3e, 0x59, 0xb1, 0x0e, 0x07, 0xf4, 0xb0, 0x1b, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x6d, + 0xff, 0xec, 0x03, 0xea, 0x06, 0x82, 0x02, 0x26, 0x00, 0x45, 0x00, 0x00, 0x01, 0x07, 0x02, 0x3c, 0x00, 0x8f, 0xff, + 0xf8, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x17, 0x2f, 0x1b, 0xb1, 0x17, 0x1a, 0x3e, 0x59, 0xb1, 0x2c, + 0x04, 0xf4, 0xb0, 0x39, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x1c, 0x00, 0x00, 0x05, 0x1d, 0x07, 0xb7, 0x02, + 0x26, 0x00, 0x25, 0x00, 0x00, 0x01, 0x07, 0x02, 0x35, 0x00, 0xea, 0x01, 0x2d, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1e, 0x3e, 0x59, 0xb1, 0x0e, 0x07, 0xf4, 0xb0, 0x1c, 0xd0, 0x30, 0x31, + 0x00, 0xff, 0xff, 0x00, 0x6d, 0xff, 0xec, 0x03, 0xea, 0x06, 0x82, 0x02, 0x26, 0x00, 0x45, 0x00, 0x00, 0x01, 0x07, + 0x02, 0x35, 0x00, 0x8f, 0xff, 0xf8, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x17, 0x2f, 0x1b, 0xb1, 0x17, + 0x1a, 0x3e, 0x59, 0xb1, 0x2c, 0x04, 0xf4, 0xb0, 0x3a, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x1c, 0x00, 0x00, + 0x05, 0x1d, 0x08, 0x40, 0x02, 0x26, 0x00, 0x25, 0x00, 0x00, 0x01, 0x07, 0x02, 0x3d, 0x00, 0xee, 0x01, 0x3d, 0x00, + 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1e, 0x3e, 0x59, 0xb1, 0x0e, 0x07, 0xf4, + 0xb0, 0x27, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x6d, 0xff, 0xec, 0x03, 0xea, 0x07, 0x0a, 0x02, 0x26, 0x00, + 0x45, 0x00, 0x00, 0x01, 0x07, 0x02, 0x3d, 0x00, 0x93, 0x00, 0x07, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x17, 0x2f, 0x1b, 0xb1, 0x17, 0x1a, 0x3e, 0x59, 0xb1, 0x2c, 0x04, 0xf4, 0xb0, 0x45, 0xd0, 0x30, 0x31, 0x00, 0xff, + 0xff, 0x00, 0x1c, 0x00, 0x00, 0x05, 0x1d, 0x08, 0x15, 0x02, 0x26, 0x00, 0x25, 0x00, 0x00, 0x01, 0x07, 0x02, 0x50, + 0x00, 0xee, 0x01, 0x45, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1e, 0x3e, + 0x59, 0xb1, 0x0e, 0x07, 0xf4, 0xb0, 0x1c, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x6d, 0xff, 0xec, 0x03, 0xea, + 0x06, 0xdf, 0x02, 0x26, 0x00, 0x45, 0x00, 0x00, 0x01, 0x07, 0x02, 0x50, 0x00, 0x93, 0x00, 0x0f, 0x00, 0x17, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x17, 0x2f, 0x1b, 0xb1, 0x17, 0x1a, 0x3e, 0x59, 0xb1, 0x2c, 0x04, 0xf4, 0xb0, 0x3a, + 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x1c, 0xfe, 0xa2, 0x05, 0x1d, 0x07, 0x0e, 0x02, 0x26, 0x00, 0x25, 0x00, + 0x00, 0x00, 0x27, 0x00, 0xa1, 0x00, 0xf4, 0x01, 0x37, 0x01, 0x07, 0x00, 0xad, 0x05, 0x02, 0x00, 0x00, 0x00, 0x13, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1e, 0x3e, 0x59, 0xb0, 0x0e, 0xdc, 0x30, 0x31, + 0x00, 0xff, 0xff, 0x00, 0x6d, 0xfe, 0xa2, 0x03, 0xea, 0x05, 0xd8, 0x02, 0x26, 0x00, 0x45, 0x00, 0x00, 0x00, 0x27, + 0x00, 0xa1, 0x00, 0x99, 0x00, 0x01, 0x01, 0x07, 0x00, 0xad, 0x04, 0x4a, 0x00, 0x00, 0x00, 0x13, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x17, 0x2f, 0x1b, 0xb1, 0x17, 0x1a, 0x3e, 0x59, 0xb0, 0x2c, 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, + 0x00, 0xa9, 0xfe, 0xac, 0x04, 0x46, 0x05, 0xb0, 0x02, 0x26, 0x00, 0x29, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x04, + 0xc0, 0x00, 0x0a, 0xff, 0xff, 0x00, 0x5d, 0xfe, 0xa2, 0x03, 0xf3, 0x04, 0x4e, 0x02, 0x26, 0x00, 0x49, 0x00, 0x00, + 0x00, 0x07, 0x00, 0xad, 0x04, 0x8c, 0x00, 0x00, 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, 0x04, 0x46, 0x07, 0xc6, 0x02, + 0x26, 0x00, 0x29, 0x00, 0x00, 0x01, 0x07, 0x00, 0xab, 0x04, 0xb9, 0x01, 0x52, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb1, 0x0c, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, + 0x5d, 0xff, 0xec, 0x03, 0xf3, 0x06, 0x84, 0x02, 0x26, 0x00, 0x49, 0x00, 0x00, 0x01, 0x07, 0x00, 0xab, 0x04, 0x83, + 0x00, 0x10, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, 0x3e, 0x59, 0xb1, + 0x1e, 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, 0x04, 0x46, 0x07, 0x2e, 0x02, 0x26, 0x00, 0x29, + 0x00, 0x00, 0x01, 0x07, 0x00, 0xa5, 0x00, 0x90, 0x01, 0x46, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, + 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb1, 0x0f, 0x04, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x5d, 0xff, 0xec, + 0x03, 0xf3, 0x05, 0xec, 0x02, 0x26, 0x00, 0x49, 0x00, 0x00, 0x01, 0x06, 0x00, 0xa5, 0x5a, 0x04, 0x00, 0x14, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, 0x3e, 0x59, 0xb1, 0x21, 0x01, 0xf4, 0x30, 0x31, + 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, 0x04, 0xe6, 0x07, 0xcf, 0x02, 0x26, 0x00, 0x29, 0x00, 0x00, 0x01, 0x07, 0x02, + 0x37, 0x00, 0x8e, 0x01, 0x3a, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1e, + 0x3e, 0x59, 0xb1, 0x0f, 0x0c, 0xf4, 0xb0, 0x15, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x5d, 0xff, 0xec, 0x04, + 0xb0, 0x06, 0x8e, 0x02, 0x26, 0x00, 0x49, 0x00, 0x00, 0x01, 0x06, 0x02, 0x37, 0x58, 0xf9, 0x00, 0x17, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, 0x3e, 0x59, 0xb1, 0x21, 0x08, 0xf4, 0xb0, 0x27, 0xd0, + 0x30, 0x31, 0x00, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x04, 0x46, 0x07, 0xcb, 0x02, 0x26, 0x00, 0x29, 0x00, 0x00, + 0x01, 0x07, 0x02, 0x38, 0x00, 0x92, 0x01, 0x49, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, + 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb1, 0x0f, 0x0c, 0xf4, 0xb0, 0x14, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0xff, 0xba, + 0xff, 0xec, 0x03, 0xf3, 0x06, 0x89, 0x02, 0x26, 0x00, 0x49, 0x00, 0x00, 0x01, 0x06, 0x02, 0x38, 0x5c, 0x07, 0x00, + 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, 0x3e, 0x59, 0xb1, 0x21, 0x08, 0xf4, + 0xb0, 0x26, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, 0x04, 0x7f, 0x07, 0xf6, 0x02, 0x26, 0x00, + 0x29, 0x00, 0x00, 0x01, 0x07, 0x02, 0x39, 0x00, 0x93, 0x01, 0x27, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb1, 0x0f, 0x0c, 0xf4, 0xb0, 0x13, 0xd0, 0x30, 0x31, 0x00, 0xff, + 0xff, 0x00, 0x5d, 0xff, 0xec, 0x04, 0x49, 0x06, 0xb5, 0x02, 0x26, 0x00, 0x49, 0x00, 0x00, 0x01, 0x06, 0x02, 0x39, + 0x5d, 0xe6, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, 0x3e, 0x59, 0xb1, + 0x1f, 0x08, 0xf4, 0xb0, 0x25, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, 0x04, 0x46, 0x07, 0xe6, + 0x02, 0x26, 0x00, 0x29, 0x00, 0x00, 0x01, 0x07, 0x02, 0x3a, 0x00, 0x92, 0x01, 0x12, 0x00, 0x17, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb1, 0x0f, 0x0c, 0xf4, 0xb0, 0x16, 0xd0, 0x30, + 0x31, 0x00, 0xff, 0xff, 0x00, 0x5d, 0xff, 0xec, 0x03, 0xf3, 0x06, 0xa5, 0x02, 0x26, 0x00, 0x49, 0x00, 0x00, 0x01, + 0x06, 0x02, 0x3a, 0x5c, 0xd1, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, + 0x3e, 0x59, 0xb1, 0x21, 0x08, 0xf4, 0xb0, 0x28, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0xa9, 0xfe, 0xac, 0x04, + 0x46, 0x07, 0x42, 0x02, 0x26, 0x00, 0x29, 0x00, 0x00, 0x00, 0x27, 0x00, 0x9e, 0x00, 0x94, 0x01, 0x42, 0x01, 0x07, + 0x00, 0xad, 0x04, 0xc0, 0x00, 0x0a, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, + 0x1e, 0x3e, 0x59, 0xb1, 0x10, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x5d, 0xfe, 0xa2, 0x03, 0xf3, 0x06, 0x00, + 0x02, 0x26, 0x00, 0x49, 0x00, 0x00, 0x00, 0x26, 0x00, 0x9e, 0x5e, 0x00, 0x01, 0x07, 0x00, 0xad, 0x04, 0x8c, 0x00, + 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, 0x3e, 0x59, 0xb1, 0x20, + 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0xb7, 0x00, 0x00, 0x01, 0xf8, 0x07, 0xc6, 0x02, 0x26, 0x00, 0x2d, 0x00, + 0x00, 0x01, 0x07, 0x00, 0xab, 0x03, 0x64, 0x01, 0x52, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, + 0x1b, 0xb1, 0x02, 0x1e, 0x3e, 0x59, 0xb1, 0x04, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x9b, 0x00, 0x00, 0x01, + 0xde, 0x06, 0x82, 0x02, 0x26, 0x00, 0x8d, 0x00, 0x00, 0x01, 0x07, 0x00, 0xab, 0x03, 0x4a, 0x00, 0x0e, 0x00, 0x14, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1a, 0x3e, 0x59, 0xb1, 0x04, 0x01, 0xf4, 0x30, + 0x31, 0xff, 0xff, 0x00, 0xa3, 0xfe, 0xab, 0x01, 0x7e, 0x05, 0xb0, 0x02, 0x26, 0x00, 0x2d, 0x00, 0x00, 0x00, 0x07, + 0x00, 0xad, 0x03, 0x6b, 0x00, 0x09, 0xff, 0xff, 0x00, 0x85, 0xfe, 0xac, 0x01, 0x68, 0x05, 0xc4, 0x02, 0x26, 0x00, + 0x4d, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x03, 0x4d, 0x00, 0x0a, 0xff, 0xff, 0x00, 0x76, 0xfe, 0xa2, 0x05, 0x09, + 0x05, 0xc4, 0x02, 0x26, 0x00, 0x33, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x05, 0x18, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x5b, 0xfe, 0xa2, 0x04, 0x34, 0x04, 0x4e, 0x02, 0x26, 0x00, 0x53, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x04, 0x9d, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x76, 0xff, 0xec, 0x05, 0x09, 0x07, 0xbc, 0x02, 0x26, 0x00, 0x33, 0x00, 0x00, 0x01, + 0x07, 0x00, 0xab, 0x05, 0x10, 0x01, 0x48, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, + 0x0d, 0x1e, 0x3e, 0x59, 0xb1, 0x2e, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x5b, 0xff, 0xec, 0x04, 0x34, 0x06, + 0x84, 0x02, 0x26, 0x00, 0x53, 0x00, 0x00, 0x01, 0x07, 0x00, 0xab, 0x04, 0x8d, 0x00, 0x10, 0x00, 0x14, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb1, 0x2a, 0x01, 0xf4, 0x30, 0x31, 0xff, + 0xff, 0x00, 0x76, 0xff, 0xec, 0x05, 0x3d, 0x07, 0xc5, 0x02, 0x26, 0x00, 0x33, 0x00, 0x00, 0x01, 0x07, 0x02, 0x37, + 0x00, 0xe5, 0x01, 0x30, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1e, 0x3e, + 0x59, 0xb1, 0x23, 0x0c, 0xf4, 0xb0, 0x29, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x5b, 0xff, 0xec, 0x04, 0xba, + 0x06, 0x8e, 0x02, 0x26, 0x00, 0x53, 0x00, 0x00, 0x01, 0x06, 0x02, 0x37, 0x62, 0xf9, 0x00, 0x17, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb1, 0x1f, 0x08, 0xf4, 0xb0, 0x25, 0xd0, 0x30, + 0x31, 0x00, 0xff, 0xff, 0x00, 0x47, 0xff, 0xec, 0x05, 0x09, 0x07, 0xc1, 0x02, 0x26, 0x00, 0x33, 0x00, 0x00, 0x01, + 0x07, 0x02, 0x38, 0x00, 0xe9, 0x01, 0x3f, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, + 0x0d, 0x1e, 0x3e, 0x59, 0xb1, 0x21, 0x0c, 0xf4, 0xb0, 0x28, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0xff, 0xc4, 0xff, + 0xec, 0x04, 0x34, 0x06, 0x89, 0x02, 0x26, 0x00, 0x53, 0x00, 0x00, 0x01, 0x06, 0x02, 0x38, 0x66, 0x07, 0x00, 0x17, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb1, 0x1d, 0x08, 0xf4, 0xb0, + 0x24, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x76, 0xff, 0xec, 0x05, 0x09, 0x07, 0xec, 0x02, 0x26, 0x00, 0x33, + 0x00, 0x00, 0x01, 0x07, 0x02, 0x39, 0x00, 0xea, 0x01, 0x1d, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, + 0x2f, 0x1b, 0xb1, 0x0d, 0x1e, 0x3e, 0x59, 0xb1, 0x21, 0x0c, 0xf4, 0xb0, 0x27, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, + 0x00, 0x5b, 0xff, 0xec, 0x04, 0x53, 0x06, 0xb5, 0x02, 0x26, 0x00, 0x53, 0x00, 0x00, 0x01, 0x06, 0x02, 0x39, 0x67, + 0xe6, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb1, 0x1d, + 0x08, 0xf4, 0xb0, 0x23, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x76, 0xff, 0xec, 0x05, 0x09, 0x07, 0xdc, 0x02, + 0x26, 0x00, 0x33, 0x00, 0x00, 0x01, 0x07, 0x02, 0x3a, 0x00, 0xe9, 0x01, 0x08, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1e, 0x3e, 0x59, 0xb1, 0x21, 0x0c, 0xf4, 0xb0, 0x2a, 0xd0, 0x30, 0x31, + 0x00, 0xff, 0xff, 0x00, 0x5b, 0xff, 0xec, 0x04, 0x34, 0x06, 0xa5, 0x02, 0x26, 0x00, 0x53, 0x00, 0x00, 0x01, 0x06, + 0x02, 0x3a, 0x66, 0xd1, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, + 0x59, 0xb1, 0x1d, 0x08, 0xf4, 0xb0, 0x26, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x76, 0xfe, 0xa2, 0x05, 0x09, + 0x07, 0x38, 0x02, 0x26, 0x00, 0x33, 0x00, 0x00, 0x00, 0x27, 0x00, 0x9e, 0x00, 0xeb, 0x01, 0x38, 0x01, 0x07, 0x00, + 0xad, 0x05, 0x18, 0x00, 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1e, + 0x3e, 0x59, 0xb1, 0x22, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x5b, 0xfe, 0xa2, 0x04, 0x34, 0x06, 0x00, 0x02, + 0x26, 0x00, 0x53, 0x00, 0x00, 0x00, 0x26, 0x00, 0x9e, 0x68, 0x00, 0x01, 0x07, 0x00, 0xad, 0x04, 0x9d, 0x00, 0x00, + 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb1, 0x1e, 0x01, + 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x65, 0xff, 0xec, 0x05, 0x9d, 0x07, 0x31, 0x02, 0x26, 0x00, 0x98, 0x00, 0x00, + 0x01, 0x07, 0x00, 0x75, 0x01, 0xdd, 0x01, 0x31, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, + 0xb1, 0x0d, 0x1e, 0x3e, 0x59, 0xb1, 0x28, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x5b, 0xff, 0xec, 0x04, 0xba, + 0x06, 0x00, 0x02, 0x26, 0x00, 0x99, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, 0x65, 0x00, 0x00, 0x00, 0x14, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb1, 0x26, 0x09, 0xf4, 0x30, 0x31, + 0xff, 0xff, 0x00, 0x65, 0xff, 0xec, 0x05, 0x9d, 0x07, 0x31, 0x02, 0x26, 0x00, 0x98, 0x00, 0x00, 0x01, 0x07, 0x00, + 0x44, 0x01, 0x4e, 0x01, 0x31, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1e, + 0x3e, 0x59, 0xb1, 0x27, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x5b, 0xff, 0xec, 0x04, 0xba, 0x06, 0x00, 0x02, + 0x26, 0x00, 0x99, 0x00, 0x00, 0x01, 0x07, 0x00, 0x44, 0x00, 0xd6, 0x00, 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb1, 0x25, 0x09, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, + 0x65, 0xff, 0xec, 0x05, 0x9d, 0x07, 0xb5, 0x02, 0x26, 0x00, 0x98, 0x00, 0x00, 0x01, 0x07, 0x00, 0xab, 0x05, 0x0c, + 0x01, 0x41, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1e, 0x3e, 0x59, 0xb1, + 0x34, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x5b, 0xff, 0xec, 0x04, 0xba, 0x06, 0x84, 0x02, 0x26, 0x00, 0x99, + 0x00, 0x00, 0x01, 0x07, 0x00, 0xab, 0x04, 0x94, 0x00, 0x10, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, + 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb1, 0x32, 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x65, 0xff, 0xec, + 0x05, 0x9d, 0x07, 0x1d, 0x02, 0x26, 0x00, 0x98, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa5, 0x00, 0xe3, 0x01, 0x35, 0x00, + 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1e, 0x3e, 0x59, 0xb1, 0x29, 0x04, 0xf4, + 0x30, 0x31, 0xff, 0xff, 0x00, 0x5b, 0xff, 0xec, 0x04, 0xba, 0x05, 0xec, 0x02, 0x26, 0x00, 0x99, 0x00, 0x00, 0x01, + 0x06, 0x00, 0xa5, 0x6b, 0x04, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, + 0x3e, 0x59, 0xb1, 0x27, 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x65, 0xfe, 0xa2, 0x05, 0x9d, 0x06, 0x37, 0x02, + 0x26, 0x00, 0x98, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x05, 0x09, 0x00, 0x00, 0xff, 0xff, 0x00, 0x5b, 0xfe, 0x99, + 0x04, 0xba, 0x04, 0xb0, 0x02, 0x26, 0x00, 0x99, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x04, 0x9b, 0xff, 0xf7, 0xff, + 0xff, 0x00, 0x8c, 0xfe, 0xa2, 0x04, 0xaa, 0x05, 0xb0, 0x02, 0x26, 0x00, 0x39, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, + 0x04, 0xee, 0x00, 0x00, 0xff, 0xff, 0x00, 0x88, 0xfe, 0xa2, 0x03, 0xdc, 0x04, 0x3a, 0x02, 0x26, 0x00, 0x59, 0x00, + 0x00, 0x00, 0x07, 0x00, 0xad, 0x04, 0x51, 0x00, 0x00, 0xff, 0xff, 0x00, 0x8c, 0xff, 0xec, 0x04, 0xaa, 0x07, 0xba, + 0x02, 0x26, 0x00, 0x39, 0x00, 0x00, 0x01, 0x07, 0x00, 0xab, 0x04, 0xe9, 0x01, 0x46, 0x00, 0x14, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1e, 0x3e, 0x59, 0xb1, 0x13, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, + 0x00, 0x88, 0xff, 0xec, 0x03, 0xdc, 0x06, 0x84, 0x02, 0x26, 0x00, 0x59, 0x00, 0x00, 0x01, 0x07, 0x00, 0xab, 0x04, + 0x85, 0x00, 0x10, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, 0xb1, 0x07, 0x1a, 0x3e, 0x59, + 0xb1, 0x11, 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x8c, 0xff, 0xec, 0x06, 0x1d, 0x07, 0x42, 0x02, 0x26, 0x00, + 0x9a, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, 0xd4, 0x01, 0x42, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x1a, 0x2f, 0x1b, 0xb1, 0x1a, 0x1e, 0x3e, 0x59, 0xb1, 0x1d, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x88, 0xff, + 0xec, 0x05, 0x0f, 0x05, 0xec, 0x02, 0x26, 0x00, 0x9b, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, 0x63, 0xff, 0xec, + 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x13, 0x2f, 0x1b, 0xb1, 0x13, 0x1a, 0x3e, 0x59, 0xb1, 0x1c, 0x09, + 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x8c, 0xff, 0xec, 0x06, 0x1d, 0x07, 0x42, 0x02, 0x26, 0x00, 0x9a, 0x00, 0x00, + 0x01, 0x07, 0x00, 0x44, 0x01, 0x45, 0x01, 0x42, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x12, 0x2f, 0x1b, + 0xb1, 0x12, 0x1e, 0x3e, 0x59, 0xb1, 0x1c, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x88, 0xff, 0xec, 0x05, 0x0f, + 0x05, 0xec, 0x02, 0x26, 0x00, 0x9b, 0x00, 0x00, 0x01, 0x07, 0x00, 0x44, 0x00, 0xd4, 0xff, 0xec, 0x00, 0x14, 0x00, + 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1a, 0x3e, 0x59, 0xb1, 0x1b, 0x09, 0xf4, 0x30, 0x31, + 0xff, 0xff, 0x00, 0x8c, 0xff, 0xec, 0x06, 0x1d, 0x07, 0xc6, 0x02, 0x26, 0x00, 0x9a, 0x00, 0x00, 0x01, 0x07, 0x00, + 0xab, 0x05, 0x03, 0x01, 0x52, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x1a, 0x2f, 0x1b, 0xb1, 0x1a, 0x1e, + 0x3e, 0x59, 0xb1, 0x29, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x88, 0xff, 0xec, 0x05, 0x0f, 0x06, 0x70, 0x02, + 0x26, 0x00, 0x9b, 0x00, 0x00, 0x01, 0x07, 0x00, 0xab, 0x04, 0x92, 0xff, 0xfc, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x13, 0x2f, 0x1b, 0xb1, 0x13, 0x1a, 0x3e, 0x59, 0xb1, 0x28, 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, + 0x8c, 0xff, 0xec, 0x06, 0x1d, 0x07, 0x2e, 0x02, 0x26, 0x00, 0x9a, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa5, 0x00, 0xda, + 0x01, 0x46, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x12, 0x2f, 0x1b, 0xb1, 0x12, 0x1e, 0x3e, 0x59, 0xb1, + 0x1e, 0x04, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x88, 0xff, 0xec, 0x05, 0x0f, 0x05, 0xd8, 0x02, 0x26, 0x00, 0x9b, + 0x00, 0x00, 0x01, 0x06, 0x00, 0xa5, 0x69, 0xf0, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x13, 0x2f, 0x1b, + 0xb1, 0x13, 0x1a, 0x3e, 0x59, 0xb1, 0x1d, 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x8c, 0xfe, 0x9a, 0x06, 0x1d, + 0x06, 0x02, 0x02, 0x26, 0x00, 0x9a, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x05, 0x09, 0xff, 0xf8, 0xff, 0xff, 0x00, + 0x88, 0xfe, 0xa2, 0x05, 0x0f, 0x04, 0x90, 0x02, 0x26, 0x00, 0x9b, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x04, 0x87, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x0f, 0xfe, 0xa2, 0x04, 0xbb, 0x05, 0xb0, 0x02, 0x26, 0x00, 0x3d, 0x00, 0x00, 0x00, + 0x07, 0x00, 0xad, 0x04, 0xbb, 0x00, 0x00, 0xff, 0xff, 0x00, 0x16, 0xfe, 0x05, 0x03, 0xb0, 0x04, 0x3a, 0x02, 0x26, + 0x00, 0x5d, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x05, 0x1c, 0xff, 0x63, 0xff, 0xff, 0x00, 0x0f, 0x00, 0x00, 0x04, + 0xbb, 0x07, 0xba, 0x02, 0x26, 0x00, 0x3d, 0x00, 0x00, 0x01, 0x07, 0x00, 0xab, 0x04, 0xb7, 0x01, 0x46, 0x00, 0x14, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1e, 0x3e, 0x59, 0xb1, 0x09, 0x08, 0xf4, 0x30, + 0x31, 0xff, 0xff, 0x00, 0x16, 0xfe, 0x4b, 0x03, 0xb0, 0x06, 0x84, 0x02, 0x26, 0x00, 0x5d, 0x00, 0x00, 0x01, 0x07, + 0x00, 0xab, 0x04, 0x4a, 0x00, 0x10, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0f, 0x2f, 0x1b, 0xb1, 0x0f, + 0x1a, 0x3e, 0x59, 0xb1, 0x10, 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x0f, 0x00, 0x00, 0x04, 0xbb, 0x07, 0x22, + 0x02, 0x26, 0x00, 0x3d, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa5, 0x00, 0x8e, 0x01, 0x3a, 0x00, 0x14, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x1e, 0x3e, 0x59, 0xb1, 0x0c, 0x04, 0xf4, 0x30, 0x31, 0xff, 0xff, + 0x00, 0x16, 0xfe, 0x4b, 0x03, 0xb0, 0x05, 0xec, 0x02, 0x26, 0x00, 0x5d, 0x00, 0x00, 0x01, 0x06, 0x00, 0xa5, 0x21, + 0x04, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x1a, 0x3e, 0x59, 0xb1, 0x13, + 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x5f, 0xfe, 0xcd, 0x04, 0xac, 0x06, 0x00, 0x00, 0x26, 0x00, 0x48, 0x00, + 0x00, 0x00, 0x27, 0x02, 0x26, 0x01, 0xa1, 0x02, 0x47, 0x01, 0x07, 0x00, 0x43, 0x00, 0x9f, 0xff, 0x64, 0x00, 0x08, + 0x00, 0xb2, 0x2f, 0x1e, 0x01, 0x5d, 0x30, 0x31, 0xff, 0xff, 0x00, 0x31, 0xfe, 0x99, 0x04, 0x97, 0x05, 0xb0, 0x02, + 0x26, 0x00, 0x38, 0x00, 0x00, 0x00, 0x07, 0x02, 0x51, 0x02, 0x3f, 0x00, 0x00, 0xff, 0xff, 0x00, 0x28, 0xfe, 0x99, + 0x03, 0xb0, 0x04, 0x3a, 0x02, 0x26, 0x00, 0xf6, 0x00, 0x00, 0x00, 0x07, 0x02, 0x51, 0x01, 0xc6, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x96, 0xfe, 0x99, 0x04, 0xc8, 0x05, 0xb0, 0x02, 0x26, 0x00, 0xe1, 0x00, 0x00, 0x00, 0x07, 0x02, 0x51, + 0x02, 0xfe, 0x00, 0x00, 0xff, 0xff, 0x00, 0x67, 0xfe, 0x99, 0x03, 0xbd, 0x04, 0x3b, 0x02, 0x26, 0x00, 0xf9, 0x00, + 0x00, 0x00, 0x07, 0x02, 0x51, 0x01, 0xf5, 0x00, 0x00, 0xff, 0xff, 0x00, 0xb1, 0xfe, 0x99, 0x04, 0x30, 0x05, 0xb0, + 0x02, 0x26, 0x00, 0xb1, 0x00, 0x00, 0x00, 0x07, 0x02, 0x51, 0x00, 0xef, 0x00, 0x00, 0xff, 0xff, 0x00, 0x9a, 0xfe, + 0x99, 0x03, 0x47, 0x04, 0x3a, 0x02, 0x26, 0x00, 0xec, 0x00, 0x00, 0x00, 0x07, 0x02, 0x51, 0x00, 0xd5, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x3f, 0xfe, 0x55, 0x05, 0xbd, 0x05, 0xc3, 0x02, 0x26, 0x01, 0x4c, 0x00, 0x00, 0x00, 0x07, 0x02, + 0x51, 0x03, 0x06, 0xff, 0xbc, 0xff, 0xff, 0xff, 0xde, 0xfe, 0x59, 0x04, 0x63, 0x04, 0x4e, 0x02, 0x26, 0x01, 0x4d, + 0x00, 0x00, 0x00, 0x07, 0x02, 0x51, 0x02, 0x01, 0xff, 0xc0, 0xff, 0xff, 0x00, 0x8c, 0x00, 0x00, 0x03, 0xdf, 0x06, + 0x00, 0x02, 0x06, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x00, 0x00, 0x04, 0xb1, 0x05, 0xb0, 0x00, 0x12, + 0x00, 0x1b, 0x00, 0x64, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0f, 0x2f, 0x1b, 0xb1, 0x0f, 0x1e, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x12, 0x3e, 0x59, 0xb2, 0x02, 0x0a, 0x0f, 0x11, 0x12, 0x39, + 0xb0, 0x02, 0x2f, 0xb2, 0x0e, 0x0f, 0x02, 0x11, 0x12, 0x39, 0xb0, 0x0e, 0x2f, 0xb1, 0x0b, 0x01, 0xb0, 0x0a, 0x2b, + 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x01, 0xd0, 0xb0, 0x0e, 0x10, 0xb0, 0x11, 0xd0, 0xb0, 0x02, 0x10, 0xb1, + 0x13, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0a, 0x10, 0xb1, 0x14, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x23, 0x15, 0x21, 0x16, 0x04, 0x15, 0x14, 0x04, 0x07, + 0x21, 0x11, 0x23, 0x35, 0x33, 0x35, 0x33, 0x15, 0x33, 0x03, 0x11, 0x21, 0x32, 0x36, 0x35, 0x34, 0x26, 0x27, 0x02, + 0x50, 0xed, 0x01, 0x6a, 0xe4, 0x01, 0x00, 0xfe, 0xfe, 0xdf, 0xfd, 0xd3, 0xcf, 0xcf, 0xc0, 0xed, 0xed, 0x01, 0x5f, + 0x8f, 0x9f, 0x99, 0x8d, 0x04, 0x50, 0xf2, 0x03, 0xe4, 0xc4, 0xc5, 0xea, 0x04, 0x04, 0x50, 0x97, 0xc9, 0xc9, 0xfd, + 0xd9, 0xfd, 0xdd, 0x98, 0x80, 0x7b, 0x8e, 0x02, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x00, 0x00, 0x04, 0xb1, 0x05, 0xb0, + 0x00, 0x12, 0x00, 0x1b, 0x00, 0x64, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x1e, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x12, 0x3e, 0x59, 0xb2, 0x02, 0x0a, 0x10, 0x11, + 0x12, 0x39, 0xb0, 0x02, 0x2f, 0xb2, 0x11, 0x02, 0x10, 0x11, 0x12, 0x39, 0xb0, 0x11, 0x2f, 0xb1, 0x01, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0b, 0xd0, 0xb0, 0x11, 0x10, 0xb0, 0x0e, 0xd0, 0xb0, 0x02, + 0x10, 0xb1, 0x13, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x0a, 0x10, 0xb1, 0x14, 0x01, + 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x23, 0x15, 0x21, 0x16, 0x04, 0x15, 0x14, + 0x04, 0x07, 0x21, 0x11, 0x23, 0x35, 0x33, 0x35, 0x33, 0x15, 0x33, 0x03, 0x11, 0x21, 0x32, 0x36, 0x35, 0x34, 0x26, + 0x27, 0x02, 0x50, 0xed, 0x01, 0x6a, 0xe4, 0x01, 0x00, 0xfe, 0xfe, 0xdf, 0xfd, 0xd3, 0xcf, 0xcf, 0xc0, 0xed, 0xed, + 0x01, 0x5f, 0x8f, 0x9f, 0x99, 0x8d, 0x04, 0x50, 0xf2, 0x03, 0xe4, 0xc4, 0xc5, 0xea, 0x04, 0x04, 0x50, 0x97, 0xc9, + 0xc9, 0xfd, 0xd9, 0xfd, 0xdd, 0x98, 0x80, 0x7b, 0x8e, 0x02, 0x00, 0x00, 0x01, 0x00, 0x03, 0x00, 0x00, 0x04, 0x30, + 0x05, 0xb0, 0x00, 0x0d, 0x00, 0x50, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1e, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb2, 0x0d, 0x08, 0x02, 0x11, + 0x12, 0x39, 0xb0, 0x0d, 0x2f, 0xb2, 0x7a, 0x0d, 0x01, 0x5d, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x04, 0xd0, 0xb0, 0x0d, 0x10, 0xb0, 0x06, 0xd0, 0xb0, 0x08, 0x10, 0xb1, 0x0a, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, 0x11, 0x23, 0x11, 0x23, 0x35, 0x33, 0x11, + 0x21, 0x15, 0x21, 0x11, 0x21, 0x02, 0x7f, 0xfe, 0xf3, 0xc1, 0xae, 0xae, 0x03, 0x7f, 0xfd, 0x42, 0x01, 0x0d, 0x02, + 0xac, 0xfd, 0x54, 0x02, 0xac, 0x97, 0x02, 0x6d, 0x9e, 0xfe, 0x31, 0x00, 0x00, 0x01, 0xff, 0xfc, 0x00, 0x00, 0x03, + 0x47, 0x04, 0x3a, 0x00, 0x0d, 0x00, 0x4b, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, + 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb2, 0x0d, 0x08, 0x02, + 0x11, 0x12, 0x39, 0xb0, 0x0d, 0x2f, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, + 0x04, 0xd0, 0xb0, 0x0d, 0x10, 0xb0, 0x06, 0xd0, 0xb0, 0x08, 0x10, 0xb1, 0x0a, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, + 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x21, 0x11, 0x23, 0x11, 0x23, 0x35, 0x33, 0x11, 0x21, 0x15, 0x21, 0x11, + 0x21, 0x02, 0x78, 0xfe, 0xdc, 0xba, 0x9e, 0x9e, 0x02, 0xad, 0xfe, 0x0d, 0x01, 0x24, 0x01, 0xdf, 0xfe, 0x21, 0x01, + 0xdf, 0x97, 0x01, 0xc4, 0x99, 0xfe, 0xd5, 0x00, 0x01, 0xff, 0xf7, 0x00, 0x00, 0x05, 0x31, 0x05, 0xb0, 0x00, 0x14, + 0x00, 0x80, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, + 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x13, 0x2f, 0x1b, 0xb1, 0x13, 0x12, 0x3e, 0x59, 0xb2, 0x0e, + 0x08, 0x02, 0x11, 0x12, 0x39, 0xb0, 0x0e, 0x2f, 0xb2, 0x2f, 0x0e, 0x01, 0x5d, 0xb2, 0xcf, 0x0e, 0x01, 0x5d, 0xb1, + 0x01, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x07, 0x08, 0x02, 0x11, 0x12, 0x39, 0xb0, + 0x07, 0x2f, 0xb1, 0x04, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x07, 0x10, 0xb0, 0x0a, + 0xd0, 0xb0, 0x04, 0x10, 0xb0, 0x0c, 0xd0, 0xb2, 0x12, 0x01, 0x0e, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x23, 0x11, + 0x23, 0x11, 0x23, 0x35, 0x33, 0x35, 0x33, 0x15, 0x33, 0x15, 0x23, 0x11, 0x33, 0x01, 0x33, 0x01, 0x01, 0x23, 0x02, + 0x37, 0xb1, 0xc0, 0xcf, 0xcf, 0xc0, 0xed, 0xed, 0x96, 0x01, 0xfd, 0xef, 0xfd, 0xd4, 0x02, 0x55, 0xeb, 0x02, 0x8e, + 0xfd, 0x72, 0x04, 0x37, 0x97, 0xe2, 0xe2, 0x97, 0xfe, 0xf7, 0x02, 0x82, 0xfd, 0x3e, 0xfd, 0x12, 0x00, 0x00, 0x01, + 0xff, 0xbf, 0x00, 0x00, 0x04, 0x28, 0x06, 0x00, 0x00, 0x14, 0x00, 0x76, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, + 0x2f, 0x1b, 0xb1, 0x08, 0x20, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x10, 0x2f, 0x1b, 0xb1, 0x10, 0x1a, 0x3e, + 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x13, 0x2f, 0x1b, 0xb1, 0x13, 0x12, 0x3e, 0x59, 0xb2, 0x0e, 0x10, 0x02, 0x11, 0x12, 0x39, 0xb0, 0x0e, 0x2f, 0xb1, + 0x01, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x07, 0x08, 0x10, 0x11, 0x12, 0x39, 0xb0, + 0x07, 0x2f, 0xb1, 0x04, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x07, 0x10, 0xb0, 0x0a, + 0xd0, 0xb0, 0x04, 0x10, 0xb0, 0x0c, 0xd0, 0xb2, 0x12, 0x01, 0x0e, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x23, 0x11, + 0x23, 0x11, 0x23, 0x35, 0x33, 0x35, 0x33, 0x15, 0x33, 0x15, 0x23, 0x11, 0x33, 0x01, 0x33, 0x01, 0x01, 0x23, 0x01, + 0xe0, 0x80, 0xba, 0xe7, 0xe7, 0xba, 0xdb, 0xdb, 0x7e, 0x01, 0x3b, 0xdb, 0xfe, 0x86, 0x01, 0xae, 0xdb, 0x01, 0xf5, + 0xfe, 0x0b, 0x04, 0xc1, 0x97, 0xa8, 0xa8, 0x97, 0xfd, 0xcd, 0x01, 0xac, 0xfe, 0x13, 0xfd, 0xb3, 0x00, 0x00, 0x01, + 0x00, 0x0f, 0x00, 0x00, 0x04, 0xbb, 0x05, 0xb0, 0x00, 0x0e, 0x00, 0x57, 0xb2, 0x0a, 0x0f, 0x10, 0x11, 0x12, 0x39, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, + 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, + 0x3e, 0x59, 0xb2, 0x06, 0x08, 0x02, 0x11, 0x12, 0x39, 0xb0, 0x06, 0x2f, 0xb1, 0x05, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x00, 0xd0, 0xb2, 0x0a, 0x08, 0x02, 0x11, 0x12, 0x39, 0xb0, 0x06, 0x10, 0xb0, + 0x0e, 0xd0, 0x30, 0x31, 0x01, 0x23, 0x11, 0x23, 0x11, 0x23, 0x35, 0x33, 0x01, 0x33, 0x01, 0x01, 0x33, 0x01, 0x33, + 0x03, 0xa6, 0xe1, 0xc0, 0xdb, 0x94, 0xfe, 0x51, 0xdc, 0x01, 0x7a, 0x01, 0x7c, 0xda, 0xfe, 0x51, 0x9a, 0x02, 0x09, + 0xfd, 0xf7, 0x02, 0x09, 0x97, 0x03, 0x10, 0xfd, 0x25, 0x02, 0xdb, 0xfc, 0xf0, 0x00, 0x01, 0x00, 0x2e, 0xfe, 0x60, + 0x03, 0xdf, 0x04, 0x3a, 0x00, 0x0e, 0x00, 0x64, 0xb2, 0x0a, 0x0f, 0x10, 0x11, 0x12, 0x39, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, + 0x0b, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x14, 0x3e, 0x59, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x00, 0x2f, 0x1b, 0xb1, 0x00, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, + 0xb1, 0x04, 0x12, 0x3e, 0x59, 0xb1, 0x06, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x0a, + 0x0b, 0x00, 0x11, 0x12, 0x39, 0xb0, 0x0d, 0xd0, 0xb0, 0x0e, 0xd0, 0x30, 0x31, 0x05, 0x23, 0x11, 0x23, 0x11, 0x23, + 0x35, 0x33, 0x01, 0x33, 0x01, 0x01, 0x33, 0x01, 0x33, 0x03, 0x4a, 0xe6, 0xba, 0xdc, 0xbf, 0xfe, 0xa1, 0xbd, 0x01, + 0x1f, 0x01, 0x18, 0xbd, 0xfe, 0xa3, 0xc8, 0x0b, 0xfe, 0x6b, 0x01, 0x95, 0x97, 0x03, 0xae, 0xfc, 0xda, 0x03, 0x26, + 0xfc, 0x52, 0x00, 0x01, 0x00, 0x39, 0x00, 0x00, 0x04, 0xce, 0x05, 0xb0, 0x00, 0x11, 0x00, 0x64, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0e, 0x2f, 0x1b, + 0xb1, 0x0e, 0x1e, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x12, 0x3e, 0x59, 0xb2, 0x11, 0x0b, 0x02, 0x11, 0x12, 0x39, + 0xb0, 0x11, 0x2f, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x04, 0x0b, 0x02, + 0x11, 0x12, 0x39, 0xb0, 0x07, 0xd0, 0xb0, 0x11, 0x10, 0xb0, 0x09, 0xd0, 0xb2, 0x0d, 0x0b, 0x02, 0x11, 0x12, 0x39, + 0x30, 0x31, 0x01, 0x23, 0x01, 0x23, 0x01, 0x01, 0x23, 0x01, 0x23, 0x35, 0x33, 0x01, 0x33, 0x01, 0x01, 0x33, 0x01, + 0x33, 0x03, 0xc4, 0xa4, 0x01, 0xae, 0xe4, 0xfe, 0x9a, 0xfe, 0x98, 0xe3, 0x01, 0xaf, 0xa0, 0x91, 0xfe, 0x6b, 0xe1, + 0x01, 0x5f, 0x01, 0x5d, 0xe2, 0xfe, 0x6b, 0x96, 0x02, 0x9e, 0xfd, 0x62, 0x02, 0x38, 0xfd, 0xc8, 0x02, 0x9e, 0x97, + 0x02, 0x7b, 0xfd, 0xd2, 0x02, 0x2e, 0xfd, 0x85, 0x00, 0x00, 0x01, 0x00, 0x29, 0x00, 0x00, 0x03, 0xca, 0x04, 0x3a, + 0x00, 0x11, 0x00, 0x64, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1a, 0x3e, 0x59, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x0e, 0x2f, 0x1b, 0xb1, 0x0e, 0x1a, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, + 0x1b, 0xb1, 0x02, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x12, 0x3e, 0x59, + 0xb2, 0x11, 0x0e, 0x02, 0x11, 0x12, 0x39, 0xb0, 0x11, 0x2f, 0xb1, 0x00, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb2, 0x04, 0x0e, 0x02, 0x11, 0x12, 0x39, 0xb0, 0x07, 0xd0, 0xb0, 0x11, 0x10, 0xb0, 0x09, 0xd0, + 0xb2, 0x0d, 0x0e, 0x02, 0x11, 0x12, 0x39, 0x30, 0x31, 0x01, 0x23, 0x01, 0x23, 0x03, 0x03, 0x23, 0x01, 0x23, 0x35, + 0x33, 0x01, 0x33, 0x13, 0x13, 0x33, 0x01, 0x33, 0x03, 0x3c, 0xb3, 0x01, 0x41, 0xd6, 0xfa, 0xfa, 0xd7, 0x01, 0x41, + 0xaa, 0x9e, 0xfe, 0xd6, 0xd6, 0xed, 0xf0, 0xd8, 0xfe, 0xd6, 0xa7, 0x01, 0xe1, 0xfe, 0x1f, 0x01, 0x95, 0xfe, 0x6b, + 0x01, 0xe1, 0x97, 0x01, 0xc2, 0xfe, 0x75, 0x01, 0x8b, 0xfe, 0x3e, 0x00, 0xff, 0xff, 0x00, 0x63, 0xff, 0xec, 0x03, + 0xec, 0x04, 0x4d, 0x02, 0x06, 0x00, 0xbf, 0x00, 0x00, 0xff, 0xff, 0x00, 0x12, 0x00, 0x00, 0x04, 0x2f, 0x05, 0xb0, + 0x02, 0x26, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x07, 0x02, 0x26, 0xff, 0x83, 0xfe, 0x7f, 0xff, 0xff, 0x00, 0x91, 0x02, + 0x8b, 0x05, 0xc9, 0x03, 0x22, 0x00, 0x46, 0x01, 0xaf, 0x84, 0x00, 0x66, 0x66, 0x40, 0x00, 0xff, 0xff, 0x00, 0x5d, + 0x00, 0x00, 0x04, 0x33, 0x05, 0xc4, 0x02, 0x06, 0x00, 0x16, 0x00, 0x00, 0xff, 0xff, 0x00, 0x5e, 0xff, 0xec, 0x03, + 0xf9, 0x05, 0xc4, 0x02, 0x06, 0x00, 0x17, 0x00, 0x00, 0xff, 0xff, 0x00, 0x35, 0x00, 0x00, 0x04, 0x50, 0x05, 0xb0, + 0x02, 0x06, 0x00, 0x18, 0x00, 0x00, 0xff, 0xff, 0x00, 0x9a, 0xff, 0xec, 0x04, 0x2d, 0x05, 0xb0, 0x02, 0x06, 0x00, + 0x19, 0x00, 0x00, 0xff, 0xff, 0x00, 0x98, 0xff, 0xec, 0x04, 0x30, 0x05, 0xb1, 0x00, 0x06, 0x00, 0x1a, 0x14, 0x00, + 0xff, 0xff, 0x00, 0x84, 0xff, 0xec, 0x04, 0x22, 0x05, 0xc4, 0x00, 0x06, 0x00, 0x1c, 0x14, 0x00, 0xff, 0xff, 0x00, + 0x64, 0xff, 0xff, 0x03, 0xf8, 0x05, 0xc4, 0x00, 0x06, 0x00, 0x1d, 0x00, 0x00, 0xff, 0xff, 0x00, 0x87, 0xff, 0xec, + 0x04, 0x1e, 0x05, 0xc4, 0x00, 0x06, 0x00, 0x14, 0x14, 0x00, 0xff, 0xff, 0x00, 0x7a, 0xff, 0xec, 0x04, 0xdc, 0x07, + 0x57, 0x02, 0x26, 0x00, 0x2b, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, 0xbe, 0x01, 0x57, 0x00, 0x14, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1e, 0x3e, 0x59, 0xb1, 0x22, 0x08, 0xf4, 0x30, 0x31, 0xff, + 0xff, 0x00, 0x60, 0xfe, 0x56, 0x03, 0xf2, 0x06, 0x00, 0x02, 0x26, 0x00, 0x4b, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, + 0x01, 0x4b, 0x00, 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1a, 0x3e, + 0x59, 0xb1, 0x27, 0x09, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, 0x05, 0x08, 0x07, 0x36, 0x02, 0x26, + 0x00, 0x32, 0x00, 0x00, 0x01, 0x07, 0x00, 0x44, 0x01, 0x66, 0x01, 0x36, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb1, 0x0b, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x8c, + 0x00, 0x00, 0x03, 0xdf, 0x06, 0x00, 0x02, 0x26, 0x00, 0x52, 0x00, 0x00, 0x01, 0x07, 0x00, 0x44, 0x00, 0xcc, 0x00, + 0x00, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1a, 0x3e, 0x59, 0xb1, 0x13, + 0x09, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x1c, 0x00, 0x00, 0x05, 0x1d, 0x07, 0x20, 0x02, 0x26, 0x00, 0x25, 0x00, + 0x00, 0x01, 0x07, 0x00, 0xac, 0x04, 0x6d, 0x01, 0x32, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, + 0x1b, 0xb1, 0x04, 0x1e, 0x3e, 0x59, 0xb1, 0x0c, 0x08, 0xf4, 0xb0, 0x10, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, + 0x39, 0xff, 0xec, 0x03, 0xea, 0x05, 0xeb, 0x02, 0x26, 0x00, 0x45, 0x00, 0x00, 0x01, 0x07, 0x00, 0xac, 0x04, 0x12, + 0xff, 0xfd, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x17, 0x2f, 0x1b, 0xb1, 0x17, 0x1a, 0x3e, 0x59, 0xb1, + 0x2a, 0x09, 0xf4, 0xb0, 0x2e, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x5f, 0x00, 0x00, 0x04, 0x46, 0x07, 0x2c, + 0x02, 0x26, 0x00, 0x29, 0x00, 0x00, 0x01, 0x07, 0x00, 0xac, 0x04, 0x38, 0x01, 0x3e, 0x00, 0x17, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb1, 0x0d, 0x08, 0xf4, 0xb0, 0x11, 0xd0, 0x30, + 0x31, 0x00, 0xff, 0xff, 0x00, 0x29, 0xff, 0xec, 0x03, 0xf3, 0x05, 0xeb, 0x02, 0x26, 0x00, 0x49, 0x00, 0x00, 0x01, + 0x07, 0x00, 0xac, 0x04, 0x02, 0xff, 0xfd, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, 0x1b, 0xb1, + 0x08, 0x1a, 0x3e, 0x59, 0xb1, 0x1f, 0x09, 0xf4, 0xb0, 0x23, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0xff, 0x0a, 0x00, + 0x00, 0x01, 0xea, 0x07, 0x2c, 0x02, 0x26, 0x00, 0x2d, 0x00, 0x00, 0x01, 0x07, 0x00, 0xac, 0x02, 0xe3, 0x01, 0x3e, + 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1e, 0x3e, 0x59, 0xb1, 0x05, 0x08, + 0xf4, 0xb0, 0x09, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0xfe, 0xf0, 0x00, 0x00, 0x01, 0xd0, 0x05, 0xe9, 0x02, 0x26, + 0x00, 0x8d, 0x00, 0x00, 0x01, 0x07, 0x00, 0xac, 0x02, 0xc9, 0xff, 0xfb, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1a, 0x3e, 0x59, 0xb1, 0x05, 0x09, 0xf4, 0xb0, 0x09, 0xd0, 0x30, 0x31, 0x00, + 0xff, 0xff, 0x00, 0x76, 0xff, 0xec, 0x05, 0x09, 0x07, 0x22, 0x02, 0x26, 0x00, 0x33, 0x00, 0x00, 0x01, 0x07, 0x00, + 0xac, 0x04, 0x8f, 0x01, 0x34, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, 0x0d, 0x1e, + 0x3e, 0x59, 0xb1, 0x21, 0x08, 0xf4, 0xb0, 0x25, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x33, 0xff, 0xec, 0x04, + 0x34, 0x05, 0xeb, 0x02, 0x26, 0x00, 0x53, 0x00, 0x00, 0x01, 0x07, 0x00, 0xac, 0x04, 0x0c, 0xff, 0xfd, 0x00, 0x17, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1a, 0x3e, 0x59, 0xb1, 0x1d, 0x09, 0xf4, 0xb0, + 0x21, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x55, 0x00, 0x00, 0x04, 0xc9, 0x07, 0x20, 0x02, 0x26, 0x00, 0x36, + 0x00, 0x00, 0x01, 0x07, 0x00, 0xac, 0x04, 0x2e, 0x01, 0x32, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x04, + 0x2f, 0x1b, 0xb1, 0x04, 0x1e, 0x3e, 0x59, 0xb1, 0x19, 0x08, 0xf4, 0xb0, 0x1d, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, + 0xff, 0x8b, 0x00, 0x00, 0x02, 0x97, 0x05, 0xeb, 0x02, 0x26, 0x00, 0x56, 0x00, 0x00, 0x01, 0x07, 0x00, 0xac, 0x03, + 0x64, 0xff, 0xfd, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0b, 0x2f, 0x1b, 0xb1, 0x0b, 0x1a, 0x3e, 0x59, + 0xb1, 0x0f, 0x09, 0xf4, 0xb0, 0x13, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x8c, 0xff, 0xec, 0x04, 0xaa, 0x07, + 0x20, 0x02, 0x26, 0x00, 0x39, 0x00, 0x00, 0x01, 0x07, 0x00, 0xac, 0x04, 0x68, 0x01, 0x32, 0x00, 0x17, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x1e, 0x3e, 0x59, 0xb1, 0x14, 0x08, 0xf4, 0xb0, 0x18, 0xd0, + 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x2b, 0xff, 0xec, 0x03, 0xdc, 0x05, 0xeb, 0x02, 0x26, 0x00, 0x59, 0x00, 0x00, + 0x01, 0x07, 0x00, 0xac, 0x04, 0x04, 0xff, 0xfd, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x07, 0x2f, 0x1b, + 0xb1, 0x07, 0x1a, 0x3e, 0x59, 0xb1, 0x12, 0x09, 0xf4, 0xb0, 0x16, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0xfe, 0xd6, + 0x00, 0x00, 0x04, 0xd2, 0x06, 0x3f, 0x00, 0x26, 0x00, 0xd0, 0x64, 0x00, 0x00, 0x07, 0x00, 0xae, 0xfe, 0x1f, 0x00, + 0x00, 0xff, 0xff, 0x00, 0xa9, 0xfe, 0xac, 0x04, 0x88, 0x05, 0xb0, 0x02, 0x26, 0x00, 0x26, 0x00, 0x00, 0x00, 0x07, + 0x00, 0xad, 0x04, 0xba, 0x00, 0x0a, 0xff, 0xff, 0x00, 0x8c, 0xfe, 0x99, 0x04, 0x20, 0x06, 0x00, 0x02, 0x26, 0x00, + 0x46, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x04, 0xab, 0xff, 0xf7, 0xff, 0xff, 0x00, 0xa9, 0xfe, 0xac, 0x04, 0xc6, + 0x05, 0xb0, 0x02, 0x26, 0x00, 0x28, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x04, 0xb9, 0x00, 0x0a, 0xff, 0xff, 0x00, + 0x5f, 0xfe, 0xa2, 0x03, 0xf0, 0x06, 0x00, 0x02, 0x26, 0x00, 0x48, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x04, 0xbd, + 0x00, 0x00, 0xff, 0xff, 0x00, 0xa9, 0xfe, 0x09, 0x04, 0xc6, 0x05, 0xb0, 0x02, 0x26, 0x00, 0x28, 0x00, 0x00, 0x01, + 0x07, 0x01, 0xba, 0x01, 0x65, 0xfe, 0xaa, 0x00, 0x08, 0x00, 0xb2, 0x00, 0x1a, 0x01, 0x5d, 0x30, 0x31, 0xff, 0xff, + 0x00, 0x5f, 0xfd, 0xff, 0x03, 0xf0, 0x06, 0x00, 0x02, 0x26, 0x00, 0x48, 0x00, 0x00, 0x00, 0x07, 0x01, 0xba, 0x01, + 0x69, 0xfe, 0xa0, 0xff, 0xff, 0x00, 0xa9, 0xfe, 0xac, 0x05, 0x08, 0x05, 0xb0, 0x02, 0x26, 0x00, 0x2c, 0x00, 0x00, + 0x00, 0x07, 0x00, 0xad, 0x05, 0x1f, 0x00, 0x0a, 0xff, 0xff, 0x00, 0x8c, 0xfe, 0xac, 0x03, 0xdf, 0x06, 0x00, 0x02, + 0x26, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x04, 0xa1, 0x00, 0x0a, 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, + 0x05, 0x05, 0x07, 0x30, 0x02, 0x26, 0x00, 0x2f, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, 0x7b, 0x01, 0x30, 0x00, + 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x1e, 0x3e, 0x59, 0xb1, 0x0e, 0x08, 0xf4, + 0x30, 0x31, 0xff, 0xff, 0x00, 0x8d, 0x00, 0x00, 0x04, 0x0c, 0x07, 0x41, 0x02, 0x26, 0x00, 0x4f, 0x00, 0x00, 0x01, + 0x07, 0x00, 0x75, 0x01, 0x44, 0x01, 0x41, 0x00, 0x09, 0x00, 0xb0, 0x05, 0x2f, 0xb0, 0x0f, 0xdc, 0x30, 0x31, 0x00, + 0xff, 0xff, 0x00, 0xa9, 0xfe, 0xfb, 0x05, 0x05, 0x05, 0xb0, 0x02, 0x26, 0x00, 0x2f, 0x00, 0x00, 0x00, 0x07, 0x00, + 0xad, 0x04, 0xe8, 0x00, 0x59, 0xff, 0xff, 0x00, 0x8d, 0xfe, 0xe8, 0x04, 0x0c, 0x06, 0x00, 0x02, 0x26, 0x00, 0x4f, + 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x04, 0x65, 0x00, 0x46, 0xff, 0xff, 0x00, 0xa9, 0xfe, 0xac, 0x04, 0x1c, 0x05, + 0xb0, 0x02, 0x26, 0x00, 0x30, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x04, 0xc0, 0x00, 0x0a, 0xff, 0xff, 0x00, 0x86, + 0xfe, 0xac, 0x01, 0x61, 0x06, 0x00, 0x02, 0x26, 0x00, 0x50, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x03, 0x4e, 0x00, + 0x0a, 0xff, 0xff, 0x00, 0xa9, 0xfe, 0xac, 0x06, 0x52, 0x05, 0xb0, 0x02, 0x26, 0x00, 0x31, 0x00, 0x00, 0x00, 0x07, + 0x00, 0xad, 0x05, 0xd2, 0x00, 0x0a, 0xff, 0xff, 0x00, 0x8b, 0xfe, 0xac, 0x06, 0x78, 0x04, 0x4e, 0x02, 0x26, 0x00, + 0x51, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x05, 0xd6, 0x00, 0x0a, 0xff, 0xff, 0x00, 0xa9, 0xfe, 0xac, 0x05, 0x08, + 0x05, 0xb0, 0x02, 0x26, 0x00, 0x32, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x05, 0x24, 0x00, 0x0a, 0xff, 0xff, 0x00, + 0x8c, 0xfe, 0xac, 0x03, 0xdf, 0x04, 0x4e, 0x02, 0x26, 0x00, 0x52, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x04, 0x87, + 0x00, 0x0a, 0xff, 0xff, 0x00, 0x76, 0xff, 0xec, 0x05, 0x09, 0x07, 0xe6, 0x02, 0x26, 0x00, 0x33, 0x00, 0x00, 0x01, + 0x07, 0x02, 0x36, 0x05, 0x0b, 0x01, 0x53, 0x00, 0x2a, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0d, 0x2f, 0x1b, 0xb1, + 0x0d, 0x1e, 0x3e, 0x59, 0xb0, 0x23, 0xdc, 0xb2, 0x7f, 0x23, 0x01, 0x71, 0xb2, 0xef, 0x23, 0x01, 0x71, 0xb2, 0x4f, + 0x23, 0x01, 0x71, 0xb2, 0x2f, 0x23, 0x01, 0x71, 0xb0, 0x37, 0xd0, 0x30, 0x31, 0xff, 0xff, 0x00, 0xa9, 0x00, 0x00, + 0x04, 0xc0, 0x07, 0x42, 0x02, 0x26, 0x00, 0x34, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, 0x7c, 0x01, 0x42, 0x00, + 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, 0xb1, 0x03, 0x1e, 0x3e, 0x59, 0xb1, 0x16, 0x08, 0xf4, + 0x30, 0x31, 0xff, 0xff, 0x00, 0x8c, 0xfe, 0x60, 0x04, 0x1e, 0x05, 0xf7, 0x02, 0x26, 0x00, 0x54, 0x00, 0x00, 0x01, + 0x07, 0x00, 0x75, 0x01, 0x93, 0xff, 0xf7, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0c, 0x2f, 0x1b, 0xb1, + 0x0c, 0x1a, 0x3e, 0x59, 0xb1, 0x1d, 0x09, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0xa8, 0xfe, 0xac, 0x04, 0xc9, 0x05, + 0xb0, 0x02, 0x26, 0x00, 0x36, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x04, 0xb7, 0x00, 0x0a, 0xff, 0xff, 0x00, 0x82, + 0xfe, 0xac, 0x02, 0x97, 0x04, 0x4e, 0x02, 0x26, 0x00, 0x56, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x03, 0x4a, 0x00, + 0x0a, 0xff, 0xff, 0x00, 0x50, 0xfe, 0xa2, 0x04, 0x72, 0x05, 0xc4, 0x02, 0x26, 0x00, 0x37, 0x00, 0x00, 0x00, 0x07, + 0x00, 0xad, 0x04, 0xc9, 0x00, 0x00, 0xff, 0xff, 0x00, 0x5f, 0xfe, 0x9a, 0x03, 0xbb, 0x04, 0x4e, 0x02, 0x26, 0x00, + 0x57, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x04, 0x87, 0xff, 0xf8, 0xff, 0xff, 0x00, 0x31, 0xfe, 0xa2, 0x04, 0x97, + 0x05, 0xb0, 0x02, 0x26, 0x00, 0x38, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x04, 0xba, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x09, 0xfe, 0xa2, 0x02, 0x56, 0x05, 0x40, 0x02, 0x26, 0x00, 0x58, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x04, 0x19, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x8c, 0xff, 0xec, 0x04, 0xaa, 0x07, 0xe4, 0x02, 0x26, 0x00, 0x39, 0x00, 0x00, 0x01, + 0x07, 0x02, 0x36, 0x04, 0xe4, 0x01, 0x51, 0x00, 0x16, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x12, 0x2f, 0x1b, 0xb1, + 0x12, 0x1e, 0x3e, 0x59, 0xb0, 0x16, 0xdc, 0xb0, 0x2a, 0xd0, 0x30, 0x31, 0xff, 0xff, 0x00, 0x1c, 0x00, 0x00, 0x04, + 0xfd, 0x07, 0x2e, 0x02, 0x26, 0x00, 0x3a, 0x00, 0x00, 0x01, 0x07, 0x00, 0xa5, 0x00, 0xb4, 0x01, 0x46, 0x00, 0x14, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1e, 0x3e, 0x59, 0xb1, 0x0a, 0x04, 0xf4, 0x30, + 0x31, 0xff, 0xff, 0x00, 0x21, 0x00, 0x00, 0x03, 0xba, 0x05, 0xe3, 0x02, 0x26, 0x00, 0x5a, 0x00, 0x00, 0x01, 0x06, + 0x00, 0xa5, 0x1d, 0xfb, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x01, 0x2f, 0x1b, 0xb1, 0x01, 0x1a, 0x3e, + 0x59, 0xb1, 0x0a, 0x01, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x1c, 0xfe, 0xac, 0x04, 0xfd, 0x05, 0xb0, 0x02, 0x26, + 0x00, 0x3a, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x04, 0xe4, 0x00, 0x0a, 0xff, 0xff, 0x00, 0x21, 0xfe, 0xac, 0x03, + 0xba, 0x04, 0x3a, 0x02, 0x26, 0x00, 0x5a, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x04, 0x4d, 0x00, 0x0a, 0xff, 0xff, + 0x00, 0x3d, 0xfe, 0xac, 0x06, 0xed, 0x05, 0xb0, 0x02, 0x26, 0x00, 0x3b, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x05, + 0xef, 0x00, 0x0a, 0xff, 0xff, 0x00, 0x2b, 0xfe, 0xac, 0x05, 0xd3, 0x04, 0x3a, 0x02, 0x26, 0x00, 0x5b, 0x00, 0x00, + 0x00, 0x07, 0x00, 0xad, 0x05, 0x53, 0x00, 0x0a, 0xff, 0xff, 0x00, 0x56, 0xfe, 0xac, 0x04, 0x7a, 0x05, 0xb0, 0x02, + 0x26, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x04, 0xba, 0x00, 0x0a, 0xff, 0xff, 0x00, 0x58, 0xfe, 0xac, + 0x03, 0xb3, 0x04, 0x3a, 0x02, 0x26, 0x00, 0x5e, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x04, 0x62, 0x00, 0x0a, 0xff, + 0xff, 0xfe, 0x32, 0xff, 0xec, 0x05, 0x4f, 0x05, 0xd6, 0x00, 0x26, 0x00, 0x33, 0x46, 0x00, 0x00, 0x07, 0x01, 0x71, + 0xfd, 0xc3, 0x00, 0x00, 0xff, 0xff, 0x00, 0x13, 0x00, 0x00, 0x04, 0x70, 0x05, 0x1c, 0x02, 0x26, 0x02, 0x33, 0x00, + 0x00, 0x00, 0x07, 0x00, 0xae, 0xff, 0xdc, 0xfe, 0xdd, 0xff, 0xff, 0xff, 0x63, 0x00, 0x00, 0x03, 0xea, 0x05, 0x1f, + 0x00, 0x26, 0x02, 0x28, 0x3c, 0x00, 0x00, 0x07, 0x00, 0xae, 0xfe, 0xac, 0xfe, 0xe0, 0xff, 0xff, 0xff, 0x80, 0x00, + 0x00, 0x04, 0x94, 0x05, 0x1c, 0x00, 0x26, 0x01, 0xe4, 0x3c, 0x00, 0x00, 0x07, 0x00, 0xae, 0xfe, 0xc9, 0xfe, 0xdd, + 0xff, 0xff, 0xff, 0x84, 0x00, 0x00, 0x01, 0x8d, 0x05, 0x1e, 0x00, 0x26, 0x01, 0xe3, 0x3c, 0x00, 0x00, 0x07, 0x00, + 0xae, 0xfe, 0xcd, 0xfe, 0xdf, 0xff, 0xff, 0xff, 0xd5, 0xff, 0xf0, 0x04, 0x64, 0x05, 0x1c, 0x00, 0x26, 0x01, 0xdd, + 0x0a, 0x00, 0x00, 0x07, 0x00, 0xae, 0xff, 0x1e, 0xfe, 0xdd, 0xff, 0xff, 0xff, 0x1b, 0x00, 0x00, 0x04, 0x58, 0x05, + 0x1c, 0x00, 0x26, 0x01, 0xd3, 0x3c, 0x00, 0x00, 0x07, 0x00, 0xae, 0xfe, 0x64, 0xfe, 0xdd, 0xff, 0xff, 0xff, 0xee, + 0x00, 0x00, 0x04, 0x88, 0x05, 0x1b, 0x00, 0x26, 0x01, 0xf3, 0x0a, 0x00, 0x00, 0x07, 0x00, 0xae, 0xff, 0x37, 0xfe, + 0xdc, 0xff, 0xff, 0x00, 0x13, 0x00, 0x00, 0x04, 0x70, 0x04, 0x8d, 0x02, 0x06, 0x02, 0x33, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x8a, 0x00, 0x00, 0x03, 0xef, 0x04, 0x8d, 0x02, 0x06, 0x02, 0x32, 0x00, 0x00, 0xff, 0xff, 0x00, 0x8a, 0x00, + 0x00, 0x03, 0xae, 0x04, 0x8d, 0x02, 0x06, 0x02, 0x28, 0x00, 0x00, 0xff, 0xff, 0x00, 0x47, 0x00, 0x00, 0x03, 0xe0, + 0x04, 0x8d, 0x02, 0x06, 0x01, 0xd2, 0x00, 0x00, 0xff, 0xff, 0x00, 0x8a, 0x00, 0x00, 0x04, 0x58, 0x04, 0x8d, 0x02, + 0x06, 0x01, 0xe4, 0x00, 0x00, 0xff, 0xff, 0x00, 0x97, 0x00, 0x00, 0x01, 0x51, 0x04, 0x8d, 0x02, 0x06, 0x01, 0xe3, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x8a, 0x00, 0x00, 0x04, 0x57, 0x04, 0x8d, 0x02, 0x06, 0x01, 0xe1, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x8a, 0x00, 0x00, 0x05, 0x77, 0x04, 0x8d, 0x02, 0x06, 0x01, 0xdf, 0x00, 0x00, 0xff, 0xff, 0x00, 0x8a, + 0x00, 0x00, 0x04, 0x58, 0x04, 0x8d, 0x02, 0x06, 0x01, 0xde, 0x00, 0x00, 0xff, 0xff, 0x00, 0x60, 0xff, 0xf0, 0x04, + 0x5a, 0x04, 0x9d, 0x02, 0x06, 0x01, 0xdd, 0x00, 0x00, 0xff, 0xff, 0x00, 0x8a, 0x00, 0x00, 0x04, 0x1b, 0x04, 0x8d, + 0x02, 0x06, 0x01, 0xdc, 0x00, 0x00, 0xff, 0xff, 0x00, 0x28, 0x00, 0x00, 0x03, 0xfd, 0x04, 0x8d, 0x02, 0x06, 0x01, + 0xd8, 0x00, 0x00, 0xff, 0xff, 0x00, 0x0d, 0x00, 0x00, 0x04, 0x1c, 0x04, 0x8d, 0x02, 0x06, 0x01, 0xd3, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x26, 0x00, 0x00, 0x04, 0x31, 0x04, 0x8d, 0x02, 0x06, 0x01, 0xd4, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xb3, 0x00, 0x00, 0x02, 0x3c, 0x05, 0xe3, 0x02, 0x26, 0x01, 0xe3, 0x00, 0x00, 0x01, 0x07, 0x00, 0x6a, 0xff, 0x4e, + 0x00, 0x1e, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1c, 0x3e, 0x59, 0xb1, + 0x0b, 0x02, 0xf4, 0xb0, 0x14, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x0d, 0x00, 0x00, 0x04, 0x1c, 0x05, 0xe3, + 0x02, 0x26, 0x01, 0xd3, 0x00, 0x00, 0x01, 0x06, 0x00, 0x6a, 0x6d, 0x1e, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, + 0xb0, 0x08, 0x2f, 0x1b, 0xb1, 0x08, 0x1c, 0x3e, 0x59, 0xb1, 0x10, 0x02, 0xf4, 0xb0, 0x19, 0xd0, 0x30, 0x31, 0x00, + 0xff, 0xff, 0x00, 0x8a, 0x00, 0x00, 0x03, 0xae, 0x05, 0xe3, 0x02, 0x26, 0x02, 0x28, 0x00, 0x00, 0x01, 0x06, 0x00, + 0x6a, 0x71, 0x1e, 0x00, 0x17, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x1c, 0x3e, 0x59, + 0xb1, 0x13, 0x02, 0xf4, 0xb0, 0x1c, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x8a, 0x00, 0x00, 0x03, 0x85, 0x06, + 0x1e, 0x02, 0x26, 0x01, 0xea, 0x00, 0x00, 0x01, 0x07, 0x00, 0x75, 0x01, 0x34, 0x00, 0x1e, 0x00, 0x14, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x04, 0x2f, 0x1b, 0xb1, 0x04, 0x1c, 0x3e, 0x59, 0xb1, 0x08, 0x06, 0xf4, 0x30, 0x31, 0xff, + 0xff, 0x00, 0x43, 0xff, 0xf0, 0x03, 0xdd, 0x04, 0x9d, 0x02, 0x06, 0x01, 0xd9, 0x00, 0x00, 0xff, 0xff, 0x00, 0x97, + 0x00, 0x00, 0x01, 0x51, 0x04, 0x8d, 0x02, 0x06, 0x01, 0xe3, 0x00, 0x00, 0xff, 0xff, 0xff, 0xb3, 0x00, 0x00, 0x02, + 0x3c, 0x05, 0xe3, 0x02, 0x26, 0x01, 0xe3, 0x00, 0x00, 0x01, 0x07, 0x00, 0x6a, 0xff, 0x4e, 0x00, 0x1e, 0x00, 0x17, + 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1c, 0x3e, 0x59, 0xb1, 0x0b, 0x02, 0xf4, 0xb0, + 0x14, 0xd0, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x2b, 0xff, 0xf0, 0x03, 0x4d, 0x04, 0x8d, 0x02, 0x06, 0x01, 0xe2, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x8a, 0x00, 0x00, 0x04, 0x57, 0x06, 0x1e, 0x02, 0x26, 0x01, 0xe1, 0x00, 0x00, 0x01, + 0x07, 0x00, 0x75, 0x01, 0x25, 0x00, 0x1e, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, + 0x05, 0x1c, 0x3e, 0x59, 0xb1, 0x0f, 0x06, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x22, 0xff, 0xec, 0x04, 0x0b, 0x05, + 0xf6, 0x02, 0x26, 0x02, 0x01, 0x00, 0x00, 0x01, 0x06, 0x00, 0xa1, 0x67, 0x1f, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x02, 0x2f, 0x1b, 0xb1, 0x02, 0x1c, 0x3e, 0x59, 0xb1, 0x14, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, + 0x13, 0x00, 0x00, 0x04, 0x70, 0x04, 0x8d, 0x02, 0x06, 0x02, 0x33, 0x00, 0x00, 0xff, 0xff, 0x00, 0x8a, 0x00, 0x00, + 0x03, 0xef, 0x04, 0x8d, 0x02, 0x06, 0x02, 0x32, 0x00, 0x00, 0xff, 0xff, 0x00, 0x8a, 0x00, 0x00, 0x03, 0x85, 0x04, + 0x8d, 0x02, 0x06, 0x01, 0xea, 0x00, 0x00, 0xff, 0xff, 0x00, 0x8a, 0x00, 0x00, 0x03, 0xae, 0x04, 0x8d, 0x02, 0x06, + 0x02, 0x28, 0x00, 0x00, 0xff, 0xff, 0x00, 0x8a, 0x00, 0x00, 0x04, 0x61, 0x05, 0xf6, 0x02, 0x26, 0x01, 0xfe, 0x00, + 0x00, 0x01, 0x07, 0x00, 0xa1, 0x00, 0xc9, 0x00, 0x1f, 0x00, 0x14, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, + 0x1b, 0xb1, 0x08, 0x1c, 0x3e, 0x59, 0xb1, 0x0d, 0x08, 0xf4, 0x30, 0x31, 0xff, 0xff, 0x00, 0x8a, 0x00, 0x00, 0x05, + 0x77, 0x04, 0x8d, 0x02, 0x06, 0x01, 0xdf, 0x00, 0x00, 0xff, 0xff, 0x00, 0x8a, 0x00, 0x00, 0x04, 0x58, 0x04, 0x8d, + 0x02, 0x06, 0x01, 0xe4, 0x00, 0x00, 0xff, 0xff, 0x00, 0x60, 0xff, 0xf0, 0x04, 0x5a, 0x04, 0x9d, 0x02, 0x06, 0x01, + 0xdd, 0x00, 0x00, 0xff, 0xff, 0x00, 0x8a, 0x00, 0x00, 0x04, 0x44, 0x04, 0x8d, 0x02, 0x06, 0x01, 0xef, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x8a, 0x00, 0x00, 0x04, 0x1b, 0x04, 0x8d, 0x02, 0x06, 0x01, 0xdc, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x60, 0xff, 0xf0, 0x04, 0x30, 0x04, 0x9d, 0x02, 0x06, 0x02, 0x31, 0x00, 0x00, 0xff, 0xff, 0x00, 0x28, 0x00, 0x00, + 0x03, 0xfd, 0x04, 0x8d, 0x02, 0x06, 0x01, 0xd8, 0x00, 0x00, 0xff, 0xff, 0x00, 0x26, 0x00, 0x00, 0x04, 0x31, 0x04, + 0x8d, 0x02, 0x06, 0x01, 0xd4, 0x00, 0x00, 0x00, 0x01, 0x00, 0x47, 0xfe, 0x50, 0x03, 0xd4, 0x04, 0x9d, 0x00, 0x29, + 0x00, 0x9d, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x0a, 0x2f, 0x1b, 0xb1, 0x0a, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, + 0x58, 0xb0, 0x19, 0x2f, 0x1b, 0xb1, 0x19, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x18, 0x2f, 0x1b, 0xb1, + 0x18, 0x14, 0x3e, 0x59, 0xb0, 0x0a, 0x10, 0xb1, 0x03, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, + 0xb2, 0x06, 0x0a, 0x19, 0x11, 0x12, 0x39, 0xb2, 0x27, 0x19, 0x0a, 0x11, 0x12, 0x39, 0x7c, 0xb0, 0x27, 0x2f, 0x18, + 0xb2, 0xf0, 0x27, 0x01, 0x5d, 0xb2, 0x00, 0x27, 0x01, 0x71, 0xb2, 0xa0, 0x27, 0x01, 0x5d, 0xb4, 0x60, 0x27, 0x70, + 0x27, 0x02, 0x5d, 0xb2, 0x30, 0x27, 0x01, 0x71, 0xb4, 0x60, 0x27, 0x70, 0x27, 0x02, 0x71, 0xb1, 0x26, 0x01, 0xb0, + 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb2, 0x10, 0x26, 0x27, 0x11, 0x12, 0x39, 0xb0, 0x19, 0x10, 0xb0, + 0x16, 0xd0, 0xb2, 0x1d, 0x19, 0x0a, 0x11, 0x12, 0x39, 0xb0, 0x19, 0x10, 0xb1, 0x20, 0x01, 0xb0, 0x0a, 0x2b, 0x58, + 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x23, 0x34, 0x36, 0x33, 0x32, + 0x16, 0x15, 0x14, 0x06, 0x07, 0x16, 0x16, 0x15, 0x14, 0x06, 0x07, 0x11, 0x23, 0x11, 0x26, 0x26, 0x35, 0x33, 0x16, + 0x16, 0x33, 0x32, 0x36, 0x35, 0x34, 0x25, 0x23, 0x35, 0x33, 0x36, 0x03, 0x08, 0x8a, 0x7d, 0x6e, 0x81, 0xba, 0xed, + 0xbc, 0xd3, 0xee, 0x6e, 0x67, 0x76, 0x71, 0xcb, 0xaf, 0xba, 0xa3, 0xb6, 0xb9, 0x05, 0x83, 0x79, 0x88, 0x92, 0xfe, + 0xff, 0x9d, 0x9c, 0xef, 0x03, 0x50, 0x54, 0x5d, 0x58, 0x4f, 0x8e, 0xb5, 0xa8, 0x96, 0x56, 0x8d, 0x29, 0x24, 0x92, + 0x5b, 0x8c, 0xaf, 0x12, 0xfe, 0x5b, 0x01, 0xa7, 0x14, 0xad, 0x88, 0x56, 0x60, 0x60, 0x58, 0xc1, 0x05, 0x98, 0x05, + 0x00, 0x01, 0x00, 0x8a, 0xfe, 0x99, 0x04, 0xfa, 0x04, 0x8d, 0x00, 0x0f, 0x00, 0x5f, 0x00, 0xb0, 0x01, 0x2f, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x09, 0x2f, 0x1b, 0xb1, 0x09, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, + 0x1b, 0xb1, 0x03, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x06, 0x2f, 0x1b, 0xb1, 0x06, 0x12, 0x3e, 0x59, + 0xb2, 0x0b, 0x03, 0x09, 0x11, 0x12, 0x39, 0x7c, 0xb0, 0x0b, 0x2f, 0x18, 0xb2, 0xa0, 0x0b, 0x01, 0x5d, 0xb1, 0x04, + 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x09, 0x10, 0xb0, 0x0c, 0xd0, 0xb0, 0x03, 0x10, + 0xb1, 0x0e, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0x30, 0x31, 0x01, 0x23, 0x11, 0x23, 0x11, + 0x21, 0x11, 0x23, 0x11, 0x33, 0x11, 0x21, 0x11, 0x33, 0x11, 0x33, 0x04, 0xfa, 0xba, 0xa1, 0xfd, 0xa4, 0xb9, 0xb9, + 0x02, 0x5c, 0xb9, 0xa2, 0xfe, 0x99, 0x01, 0x67, 0x01, 0xf2, 0xfe, 0x0e, 0x04, 0x8d, 0xfd, 0xfd, 0x02, 0x03, 0xfc, + 0x0c, 0x00, 0x00, 0x01, 0x00, 0x60, 0xfe, 0x56, 0x04, 0x30, 0x04, 0x9d, 0x00, 0x1f, 0x00, 0x5a, 0x00, 0xb0, 0x00, + 0x45, 0x58, 0xb0, 0x0e, 0x2f, 0x1b, 0xb1, 0x0e, 0x1c, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x03, 0x2f, 0x1b, + 0xb1, 0x03, 0x12, 0x3e, 0x59, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x05, 0x2f, 0x1b, 0xb1, 0x05, 0x14, 0x3e, 0x59, 0xb0, + 0x03, 0x10, 0xb0, 0x06, 0xd0, 0xb0, 0x0e, 0x10, 0xb0, 0x12, 0xd0, 0xb0, 0x0e, 0x10, 0xb1, 0x15, 0x01, 0xb0, 0x0a, + 0x2b, 0x58, 0x21, 0xd8, 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb1, 0x1c, 0x01, 0xb0, 0x0a, 0x2b, 0x58, 0x21, 0xd8, + 0x1b, 0xf4, 0x59, 0xb0, 0x03, 0x10, 0xb0, 0x1f, 0xd0, 0x30, 0x31, 0x01, 0x06, 0x06, 0x07, 0x11, 0x23, 0x11, 0x26, + 0x02, 0x35, 0x35, 0x34, 0x36, 0x36, 0x33, 0x32, 0x16, 0x17, 0x23, 0x26, 0x26, 0x23, 0x22, 0x06, 0x07, 0x15, 0x14, + 0x16, 0x33, 0x32, 0x36, 0x37, 0x04, 0x30, 0x14, 0xcb, 0xa9, 0xba, 0xb7, 0xd7, 0x7b, 0xe7, 0x98, 0xcc, 0xf7, 0x13, + 0xb9, 0x12, 0x8d, 0x7e, 0x99, 0xa7, 0x01, 0x9f, 0x97, 0x87, 0x8d, 0x14, 0x01, 0x79, 0xa8, 0xc7, 0x14, 0xfe, 0x60, + 0x01, 0xa2, 0x1e, 0x01, 0x1e, 0xe3, 0x61, 0xa4, 0xf9, 0x88, 0xd3, 0xbb, 0x82, 0x74, 0xcb, 0xbd, 0x6a, 0xbd, 0xcf, + 0x6f, 0x83, 0xff, 0xff, 0x00, 0x0d, 0x00, 0x00, 0x04, 0x1c, 0x04, 0x8d, 0x02, 0x06, 0x01, 0xd3, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x02, 0xfe, 0x51, 0x05, 0x6b, 0x04, 0x9d, 0x02, 0x26, 0x02, 0x17, 0x00, 0x00, 0x00, 0x07, 0x02, 0x51, + 0x02, 0xbc, 0xff, 0xb8, 0xff, 0xff, 0x00, 0x8a, 0x00, 0x00, 0x04, 0x61, 0x05, 0xcb, 0x02, 0x26, 0x01, 0xfe, 0x00, + 0x00, 0x01, 0x07, 0x00, 0x70, 0x00, 0x9c, 0x00, 0x26, 0x00, 0x13, 0x00, 0xb0, 0x00, 0x45, 0x58, 0xb0, 0x08, 0x2f, + 0x1b, 0xb1, 0x08, 0x1c, 0x3e, 0x59, 0xb0, 0x0b, 0xdc, 0x30, 0x31, 0x00, 0xff, 0xff, 0x00, 0x22, 0xff, 0xec, 0x04, + 0x0b, 0x05, 0xcb, 0x02, 0x26, 0x02, 0x01, 0x00, 0x00, 0x01, 0x06, 0x00, 0x70, 0x3a, 0x26, 0x00, 0x13, 0x00, 0xb0, + 0x00, 0x45, 0x58, 0xb0, 0x11, 0x2f, 0x1b, 0xb1, 0x11, 0x1c, 0x3e, 0x59, 0xb0, 0x13, 0xdc, 0x30, 0x31, 0x00, 0xff, + 0xff, 0x00, 0x60, 0x00, 0x00, 0x05, 0x06, 0x04, 0x8d, 0x02, 0x06, 0x01, 0xf1, 0x00, 0x00, 0xff, 0xff, 0x00, 0x97, + 0xff, 0xf0, 0x05, 0x35, 0x04, 0x8d, 0x00, 0x26, 0x01, 0xe3, 0x00, 0x00, 0x00, 0x07, 0x01, 0xe2, 0x01, 0xe8, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x09, 0x00, 0x00, 0x05, 0xf1, 0x06, 0x00, 0x02, 0x26, 0x02, 0x73, 0x00, 0x00, 0x00, 0x07, + 0x00, 0x75, 0x02, 0x9e, 0x00, 0x00, 0xff, 0xff, 0x00, 0x60, 0xff, 0xc7, 0x04, 0x5a, 0x06, 0x1e, 0x02, 0x26, 0x02, + 0x75, 0x00, 0x00, 0x00, 0x07, 0x00, 0x75, 0x01, 0x7d, 0x00, 0x1e, 0xff, 0xff, 0x00, 0x43, 0xfd, 0xff, 0x03, 0xdd, + 0x04, 0x9d, 0x02, 0x26, 0x01, 0xd9, 0x00, 0x00, 0x00, 0x07, 0x01, 0xba, 0x01, 0x29, 0xfe, 0xa0, 0xff, 0xff, 0x00, + 0x31, 0x00, 0x00, 0x05, 0xf1, 0x06, 0x1e, 0x02, 0x26, 0x01, 0xd5, 0x00, 0x00, 0x00, 0x07, 0x00, 0x44, 0x01, 0xa2, + 0x00, 0x1e, 0xff, 0xff, 0x00, 0x31, 0x00, 0x00, 0x05, 0xf1, 0x06, 0x1e, 0x02, 0x26, 0x01, 0xd5, 0x00, 0x00, 0x00, + 0x07, 0x00, 0x75, 0x02, 0x31, 0x00, 0x1e, 0xff, 0xff, 0x00, 0x31, 0x00, 0x00, 0x05, 0xf1, 0x05, 0xe3, 0x02, 0x26, + 0x01, 0xd5, 0x00, 0x00, 0x00, 0x07, 0x00, 0x6a, 0x01, 0x6b, 0x00, 0x1e, 0xff, 0xff, 0x00, 0x0d, 0x00, 0x00, 0x04, + 0x1c, 0x06, 0x1e, 0x02, 0x26, 0x01, 0xd3, 0x00, 0x00, 0x00, 0x07, 0x00, 0x44, 0x00, 0xa4, 0x00, 0x1e, 0xff, 0xff, + 0x00, 0x1c, 0xfe, 0x4f, 0x05, 0x1d, 0x05, 0xb0, 0x02, 0x26, 0x00, 0x25, 0x00, 0x00, 0x00, 0x07, 0x00, 0xa4, 0x01, + 0x7c, 0x00, 0x00, 0xff, 0xff, 0x00, 0x6d, 0xfe, 0x4f, 0x03, 0xea, 0x04, 0x4e, 0x02, 0x26, 0x00, 0x45, 0x00, 0x00, + 0x00, 0x07, 0x00, 0xa4, 0x00, 0xc4, 0x00, 0x00, 0xff, 0xff, 0x00, 0xa9, 0xfe, 0x59, 0x04, 0x46, 0x05, 0xb0, 0x02, + 0x26, 0x00, 0x29, 0x00, 0x00, 0x00, 0x07, 0x00, 0xa4, 0x01, 0x3a, 0x00, 0x0a, 0xff, 0xff, 0x00, 0x5d, 0xfe, 0x4f, + 0x03, 0xf3, 0x04, 0x4e, 0x02, 0x26, 0x00, 0x49, 0x00, 0x00, 0x00, 0x07, 0x00, 0xa4, 0x01, 0x06, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x13, 0xfe, 0x4f, 0x04, 0x70, 0x04, 0x8d, 0x02, 0x26, 0x02, 0x33, 0x00, 0x00, 0x00, 0x07, 0x00, 0xa4, + 0x01, 0x1e, 0x00, 0x00, 0xff, 0xff, 0x00, 0x8a, 0xfe, 0x57, 0x03, 0xae, 0x04, 0x8d, 0x02, 0x26, 0x02, 0x28, 0x00, + 0x00, 0x00, 0x07, 0x00, 0xa4, 0x00, 0xe7, 0x00, 0x08, 0xff, 0xff, 0x00, 0x85, 0xfe, 0xac, 0x01, 0x60, 0x04, 0x3a, + 0x02, 0x26, 0x00, 0x8d, 0x00, 0x00, 0x00, 0x07, 0x00, 0xad, 0x03, 0x4d, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x1a, 0x01, + 0x3e, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x01, 0x00, 0x06, 0x00, 0x2f, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x07, 0x00, 0x35, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x06, 0x00, 0x2f, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, + 0x00, 0x06, 0x00, 0x2f, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x13, 0x00, 0x3c, 0x00, 0x01, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x0e, 0x00, 0x4f, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x20, + 0x00, 0x5d, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x06, 0x00, 0x7d, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x0b, 0x00, 0x0a, 0x00, 0x83, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x13, 0x00, 0x8d, + 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x2e, 0x00, 0xa0, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x0e, 0x00, 0x2a, 0x00, 0xce, 0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x00, 0x00, 0x5e, 0x00, 0xf8, 0x00, 0x03, + 0x00, 0x01, 0x04, 0x09, 0x00, 0x01, 0x00, 0x0c, 0x01, 0x56, 0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x02, 0x00, + 0x0e, 0x01, 0x62, 0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x03, 0x00, 0x0c, 0x01, 0x56, 0x00, 0x03, 0x00, 0x01, + 0x04, 0x09, 0x00, 0x04, 0x00, 0x0c, 0x01, 0x56, 0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x05, 0x00, 0x26, 0x01, + 0x70, 0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x06, 0x00, 0x1c, 0x01, 0x96, 0x00, 0x03, 0x00, 0x01, 0x04, 0x09, + 0x00, 0x07, 0x00, 0x40, 0x01, 0xb2, 0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x09, 0x00, 0x0c, 0x01, 0xf2, 0x00, + 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x0b, 0x00, 0x14, 0x01, 0xfe, 0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x0c, + 0x00, 0x26, 0x02, 0x12, 0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x0d, 0x00, 0x5c, 0x02, 0x38, 0x00, 0x03, 0x00, + 0x01, 0x04, 0x09, 0x00, 0x0e, 0x00, 0x54, 0x02, 0x94, 0x43, 0x6f, 0x70, 0x79, 0x72, 0x69, 0x67, 0x68, 0x74, 0x20, + 0x32, 0x30, 0x31, 0x31, 0x20, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x20, 0x49, 0x6e, 0x63, 0x2e, 0x20, 0x41, 0x6c, + 0x6c, 0x20, 0x52, 0x69, 0x67, 0x68, 0x74, 0x73, 0x20, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x2e, 0x52, + 0x6f, 0x62, 0x6f, 0x74, 0x6f, 0x52, 0x65, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x20, 0x32, 0x2e, 0x31, 0x33, 0x37, 0x3b, 0x20, 0x32, 0x30, 0x31, 0x37, 0x52, 0x6f, 0x62, 0x6f, 0x74, 0x6f, 0x2d, + 0x52, 0x65, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x52, 0x6f, 0x62, 0x6f, 0x74, 0x6f, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, + 0x74, 0x72, 0x61, 0x64, 0x65, 0x6d, 0x61, 0x72, 0x6b, 0x20, 0x6f, 0x66, 0x20, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2e, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x43, 0x68, + 0x72, 0x69, 0x73, 0x74, 0x69, 0x61, 0x6e, 0x20, 0x52, 0x6f, 0x62, 0x65, 0x72, 0x74, 0x73, 0x6f, 0x6e, 0x4c, 0x69, + 0x63, 0x65, 0x6e, 0x73, 0x65, 0x64, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x41, 0x70, + 0x61, 0x63, 0x68, 0x65, 0x20, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x2c, 0x20, 0x56, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, 0x20, 0x32, 0x2e, 0x30, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x61, 0x70, + 0x61, 0x63, 0x68, 0x65, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x6c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x73, 0x2f, 0x4c, + 0x49, 0x43, 0x45, 0x4e, 0x53, 0x45, 0x2d, 0x32, 0x2e, 0x30, 0x00, 0x43, 0x00, 0x6f, 0x00, 0x70, 0x00, 0x79, 0x00, + 0x72, 0x00, 0x69, 0x00, 0x67, 0x00, 0x68, 0x00, 0x74, 0x00, 0x20, 0x00, 0x32, 0x00, 0x30, 0x00, 0x31, 0x00, 0x31, + 0x00, 0x20, 0x00, 0x47, 0x00, 0x6f, 0x00, 0x6f, 0x00, 0x67, 0x00, 0x6c, 0x00, 0x65, 0x00, 0x20, 0x00, 0x49, 0x00, + 0x6e, 0x00, 0x63, 0x00, 0x2e, 0x00, 0x20, 0x00, 0x41, 0x00, 0x6c, 0x00, 0x6c, 0x00, 0x20, 0x00, 0x52, 0x00, 0x69, + 0x00, 0x67, 0x00, 0x68, 0x00, 0x74, 0x00, 0x73, 0x00, 0x20, 0x00, 0x52, 0x00, 0x65, 0x00, 0x73, 0x00, 0x65, 0x00, + 0x72, 0x00, 0x76, 0x00, 0x65, 0x00, 0x64, 0x00, 0x2e, 0x00, 0x52, 0x00, 0x6f, 0x00, 0x62, 0x00, 0x6f, 0x00, 0x74, + 0x00, 0x6f, 0x00, 0x52, 0x00, 0x65, 0x00, 0x67, 0x00, 0x75, 0x00, 0x6c, 0x00, 0x61, 0x00, 0x72, 0x00, 0x56, 0x00, + 0x65, 0x00, 0x72, 0x00, 0x73, 0x00, 0x69, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x20, 0x00, 0x32, 0x00, 0x2e, 0x00, 0x31, + 0x00, 0x33, 0x00, 0x37, 0x00, 0x3b, 0x00, 0x20, 0x00, 0x32, 0x00, 0x30, 0x00, 0x31, 0x00, 0x37, 0x00, 0x52, 0x00, + 0x6f, 0x00, 0x62, 0x00, 0x6f, 0x00, 0x74, 0x00, 0x6f, 0x00, 0x2d, 0x00, 0x52, 0x00, 0x65, 0x00, 0x67, 0x00, 0x75, + 0x00, 0x6c, 0x00, 0x61, 0x00, 0x72, 0x00, 0x52, 0x00, 0x6f, 0x00, 0x62, 0x00, 0x6f, 0x00, 0x74, 0x00, 0x6f, 0x00, + 0x20, 0x00, 0x69, 0x00, 0x73, 0x00, 0x20, 0x00, 0x61, 0x00, 0x20, 0x00, 0x74, 0x00, 0x72, 0x00, 0x61, 0x00, 0x64, + 0x00, 0x65, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x72, 0x00, 0x6b, 0x00, 0x20, 0x00, 0x6f, 0x00, 0x66, 0x00, 0x20, 0x00, + 0x47, 0x00, 0x6f, 0x00, 0x6f, 0x00, 0x67, 0x00, 0x6c, 0x00, 0x65, 0x00, 0x2e, 0x00, 0x47, 0x00, 0x6f, 0x00, 0x6f, + 0x00, 0x67, 0x00, 0x6c, 0x00, 0x65, 0x00, 0x47, 0x00, 0x6f, 0x00, 0x6f, 0x00, 0x67, 0x00, 0x6c, 0x00, 0x65, 0x00, + 0x2e, 0x00, 0x63, 0x00, 0x6f, 0x00, 0x6d, 0x00, 0x43, 0x00, 0x68, 0x00, 0x72, 0x00, 0x69, 0x00, 0x73, 0x00, 0x74, + 0x00, 0x69, 0x00, 0x61, 0x00, 0x6e, 0x00, 0x20, 0x00, 0x52, 0x00, 0x6f, 0x00, 0x62, 0x00, 0x65, 0x00, 0x72, 0x00, + 0x74, 0x00, 0x73, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x4c, 0x00, 0x69, 0x00, 0x63, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x73, + 0x00, 0x65, 0x00, 0x64, 0x00, 0x20, 0x00, 0x75, 0x00, 0x6e, 0x00, 0x64, 0x00, 0x65, 0x00, 0x72, 0x00, 0x20, 0x00, + 0x74, 0x00, 0x68, 0x00, 0x65, 0x00, 0x20, 0x00, 0x41, 0x00, 0x70, 0x00, 0x61, 0x00, 0x63, 0x00, 0x68, 0x00, 0x65, + 0x00, 0x20, 0x00, 0x4c, 0x00, 0x69, 0x00, 0x63, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x73, 0x00, 0x65, 0x00, 0x2c, 0x00, + 0x20, 0x00, 0x56, 0x00, 0x65, 0x00, 0x72, 0x00, 0x73, 0x00, 0x69, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x20, 0x00, 0x32, + 0x00, 0x2e, 0x00, 0x30, 0x00, 0x68, 0x00, 0x74, 0x00, 0x74, 0x00, 0x70, 0x00, 0x3a, 0x00, 0x2f, 0x00, 0x2f, 0x00, + 0x77, 0x00, 0x77, 0x00, 0x77, 0x00, 0x2e, 0x00, 0x61, 0x00, 0x70, 0x00, 0x61, 0x00, 0x63, 0x00, 0x68, 0x00, 0x65, + 0x00, 0x2e, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x67, 0x00, 0x2f, 0x00, 0x6c, 0x00, 0x69, 0x00, 0x63, 0x00, 0x65, 0x00, + 0x6e, 0x00, 0x73, 0x00, 0x65, 0x00, 0x73, 0x00, 0x2f, 0x00, 0x4c, 0x00, 0x49, 0x00, 0x43, 0x00, 0x45, 0x00, 0x4e, + 0x00, 0x53, 0x00, 0x45, 0x00, 0x2d, 0x00, 0x32, 0x00, 0x2e, 0x00, 0x30, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0x6a, 0x00, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x08, 0x00, 0x02, 0xff, 0xff, 0x00, + 0x0f, 0x00, 0x01, 0x00, 0x02, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x28, 0x00, 0x02, 0x00, 0x59, + 0x00, 0x25, 0x00, 0x3e, 0x00, 0x01, 0x00, 0x45, 0x00, 0x5e, 0x00, 0x01, 0x00, 0x79, 0x00, 0x79, 0x00, 0x01, 0x00, + 0x81, 0x00, 0x81, 0x00, 0x01, 0x00, 0x83, 0x00, 0x83, 0x00, 0x01, 0x00, 0x86, 0x00, 0x86, 0x00, 0x01, 0x00, 0x89, + 0x00, 0x89, 0x00, 0x01, 0x00, 0x8b, 0x00, 0x96, 0x00, 0x01, 0x00, 0x98, 0x00, 0x9d, 0x00, 0x01, 0x00, 0xa4, 0x00, + 0xa4, 0x00, 0x01, 0x00, 0xa8, 0x00, 0xad, 0x00, 0x03, 0x00, 0xb1, 0x00, 0xb1, 0x00, 0x01, 0x00, 0xba, 0x00, 0xbb, + 0x00, 0x01, 0x00, 0xbf, 0x00, 0xbf, 0x00, 0x01, 0x00, 0xc1, 0x00, 0xc1, 0x00, 0x01, 0x00, 0xc3, 0x00, 0xc3, 0x00, + 0x01, 0x00, 0xc7, 0x00, 0xc7, 0x00, 0x01, 0x00, 0xcb, 0x00, 0xcb, 0x00, 0x01, 0x00, 0xcd, 0x00, 0xce, 0x00, 0x01, + 0x00, 0xd0, 0x00, 0xd1, 0x00, 0x01, 0x00, 0xd3, 0x00, 0xd3, 0x00, 0x01, 0x00, 0xda, 0x00, 0xde, 0x00, 0x01, 0x00, + 0xe1, 0x00, 0xe1, 0x00, 0x01, 0x00, 0xe5, 0x00, 0xe5, 0x00, 0x01, 0x00, 0xe7, 0x00, 0xe9, 0x00, 0x01, 0x00, 0xeb, + 0x00, 0xfb, 0x00, 0x01, 0x00, 0xfd, 0x00, 0xfd, 0x00, 0x01, 0x00, 0xff, 0x01, 0x01, 0x00, 0x01, 0x01, 0x03, 0x01, + 0x03, 0x00, 0x01, 0x01, 0x08, 0x01, 0x09, 0x00, 0x01, 0x01, 0x16, 0x01, 0x1a, 0x00, 0x01, 0x01, 0x1c, 0x01, 0x1c, + 0x00, 0x01, 0x01, 0x20, 0x01, 0x22, 0x00, 0x01, 0x01, 0x24, 0x01, 0x25, 0x00, 0x03, 0x01, 0x2a, 0x01, 0x2b, 0x00, + 0x01, 0x01, 0x33, 0x01, 0x34, 0x00, 0x01, 0x01, 0x36, 0x01, 0x36, 0x00, 0x01, 0x01, 0x3b, 0x01, 0x3c, 0x00, 0x01, + 0x01, 0x41, 0x01, 0x44, 0x00, 0x01, 0x01, 0x47, 0x01, 0x48, 0x00, 0x01, 0x01, 0x4b, 0x01, 0x4d, 0x00, 0x01, 0x01, + 0x51, 0x01, 0x51, 0x00, 0x01, 0x01, 0x54, 0x01, 0x58, 0x00, 0x01, 0x01, 0x5d, 0x01, 0x5e, 0x00, 0x01, 0x01, 0x62, + 0x01, 0x62, 0x00, 0x01, 0x01, 0x64, 0x01, 0x64, 0x00, 0x01, 0x01, 0x68, 0x01, 0x68, 0x00, 0x01, 0x01, 0x6a, 0x01, + 0x6c, 0x00, 0x01, 0x01, 0x6e, 0x01, 0x6e, 0x00, 0x01, 0x01, 0x70, 0x01, 0x70, 0x00, 0x01, 0x01, 0xba, 0x01, 0xba, + 0x00, 0x03, 0x01, 0xbb, 0x01, 0xc1, 0x00, 0x02, 0x01, 0xd2, 0x01, 0xe6, 0x00, 0x01, 0x01, 0xea, 0x01, 0xea, 0x00, + 0x01, 0x01, 0xf3, 0x01, 0xf3, 0x00, 0x01, 0x01, 0xf5, 0x01, 0xf5, 0x00, 0x01, 0x01, 0xfc, 0x01, 0xfe, 0x00, 0x01, + 0x02, 0x00, 0x02, 0x01, 0x00, 0x01, 0x02, 0x03, 0x02, 0x03, 0x00, 0x01, 0x02, 0x07, 0x02, 0x07, 0x00, 0x01, 0x02, + 0x09, 0x02, 0x0b, 0x00, 0x01, 0x02, 0x11, 0x02, 0x11, 0x00, 0x01, 0x02, 0x16, 0x02, 0x18, 0x00, 0x01, 0x02, 0x1a, + 0x02, 0x1a, 0x00, 0x01, 0x02, 0x28, 0x02, 0x28, 0x00, 0x01, 0x02, 0x2b, 0x02, 0x2b, 0x00, 0x01, 0x02, 0x2d, 0x02, + 0x2d, 0x00, 0x01, 0x02, 0x30, 0x02, 0x33, 0x00, 0x01, 0x02, 0x5f, 0x02, 0x63, 0x00, 0x01, 0x02, 0x7a, 0x02, 0xe2, + 0x00, 0x01, 0x02, 0xe5, 0x03, 0x8b, 0x00, 0x01, 0x03, 0x8d, 0x03, 0xa4, 0x00, 0x01, 0x03, 0xa6, 0x03, 0xb2, 0x00, + 0x01, 0x03, 0xb4, 0x03, 0xbd, 0x00, 0x01, 0x03, 0xbf, 0x03, 0xda, 0x00, 0x01, 0x03, 0xde, 0x03, 0xde, 0x00, 0x01, + 0x03, 0xe0, 0x03, 0xe7, 0x00, 0x01, 0x03, 0xe9, 0x03, 0xeb, 0x00, 0x01, 0x03, 0xee, 0x03, 0xf2, 0x00, 0x01, 0x03, + 0xf4, 0x04, 0x7c, 0x00, 0x01, 0x04, 0x7f, 0x04, 0x7f, 0x00, 0x01, 0x04, 0x82, 0x04, 0x83, 0x00, 0x01, 0x04, 0x85, + 0x04, 0x86, 0x00, 0x01, 0x04, 0x88, 0x04, 0x8b, 0x00, 0x01, 0x04, 0x95, 0x04, 0xd0, 0x00, 0x01, 0x04, 0xd2, 0x04, + 0xf1, 0x00, 0x01, 0x04, 0xf3, 0x04, 0xfa, 0x00, 0x01, 0x04, 0xfc, 0x04, 0xfd, 0x00, 0x01, 0x05, 0x07, 0x05, 0x0d, + 0x00, 0x01, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x01, 0x00, 0x0e, 0x00, + 0xa8, 0x00, 0xa8, 0x00, 0xa9, 0x00, 0xa9, 0x00, 0xaa, 0x00, 0xaa, 0x00, 0xab, 0x00, 0xab, 0x00, 0xac, 0x00, 0xac, + 0x01, 0x24, 0x01, 0x25, 0x01, 0x26, 0x01, 0x27, 0x00, 0x01, 0x00, 0x05, 0x00, 0x79, 0x00, 0xa4, 0x00, 0xad, 0x00, + 0xad, 0x01, 0xba, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x32, 0x00, 0x4c, 0x00, 0x04, 0x44, 0x46, + 0x4c, 0x54, 0x00, 0x1a, 0x63, 0x79, 0x72, 0x6c, 0x00, 0x1a, 0x67, 0x72, 0x65, 0x6b, 0x00, 0x1a, 0x6c, 0x61, 0x74, + 0x6e, 0x00, 0x1a, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, + 0x63, 0x70, 0x73, 0x70, 0x00, 0x0e, 0x6b, 0x65, 0x72, 0x6e, 0x00, 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x02, 0x00, 0x06, 0x02, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, + 0x00, 0x01, 0x00, 0x0a, 0x00, 0x05, 0x00, 0x24, 0x00, 0x48, 0x00, 0x01, 0x00, 0xfa, 0x00, 0x08, 0x00, 0x0a, 0x00, + 0x14, 0x00, 0x15, 0x00, 0x16, 0x00, 0x17, 0x00, 0x18, 0x00, 0x19, 0x00, 0x1a, 0x00, 0x1b, 0x00, 0x1c, 0x00, 0x1d, + 0x00, 0x25, 0x00, 0x26, 0x00, 0x27, 0x00, 0x28, 0x00, 0x29, 0x00, 0x2a, 0x00, 0x2b, 0x00, 0x2c, 0x00, 0x2d, 0x00, + 0x2e, 0x00, 0x2f, 0x00, 0x30, 0x00, 0x31, 0x00, 0x32, 0x00, 0x33, 0x00, 0x34, 0x00, 0x35, 0x00, 0x36, 0x00, 0x37, + 0x00, 0x38, 0x00, 0x39, 0x00, 0x3a, 0x00, 0x3b, 0x00, 0x3c, 0x00, 0x3d, 0x00, 0x3e, 0x00, 0x65, 0x00, 0x67, 0x00, + 0x81, 0x00, 0x83, 0x00, 0x84, 0x00, 0x8c, 0x00, 0x8f, 0x00, 0x91, 0x00, 0x93, 0x00, 0xb1, 0x00, 0xb2, 0x00, 0xb3, + 0x00, 0xb4, 0x00, 0xb5, 0x00, 0xb6, 0x00, 0xb7, 0x00, 0xb8, 0x00, 0xb9, 0x00, 0xba, 0x00, 0xd2, 0x00, 0xd3, 0x00, + 0xd4, 0x00, 0xd5, 0x00, 0xd6, 0x00, 0xd7, 0x00, 0xd8, 0x00, 0xd9, 0x00, 0xda, 0x00, 0xdb, 0x00, 0xdc, 0x00, 0xdd, + 0x00, 0xde, 0x00, 0xdf, 0x00, 0xe0, 0x00, 0xe1, 0x00, 0xe2, 0x00, 0xe3, 0x00, 0xe4, 0x00, 0xe5, 0x00, 0xe6, 0x00, + 0xe7, 0x00, 0xe8, 0x00, 0xe9, 0x01, 0x2f, 0x01, 0x33, 0x01, 0x35, 0x01, 0x37, 0x01, 0x39, 0x01, 0x3b, 0x01, 0x41, + 0x01, 0x43, 0x01, 0x45, 0x01, 0x49, 0x01, 0x4b, 0x01, 0x4c, 0x01, 0x58, 0x01, 0x59, 0x01, 0x97, 0x01, 0x9d, 0x01, + 0xa2, 0x01, 0xa5, 0x02, 0x7a, 0x02, 0x7b, 0x02, 0x7d, 0x02, 0x7f, 0x02, 0x80, 0x02, 0x81, 0x02, 0x82, 0x02, 0x83, + 0x02, 0x84, 0x02, 0x85, 0x02, 0x86, 0x02, 0x87, 0x02, 0x88, 0x02, 0x89, 0x02, 0x8a, 0x02, 0x8b, 0x02, 0x8c, 0x02, + 0x8d, 0x02, 0x8e, 0x02, 0x8f, 0x02, 0x90, 0x02, 0x91, 0x02, 0x92, 0x02, 0x93, 0x02, 0x94, 0x02, 0x95, 0x02, 0x96, + 0x02, 0x97, 0x02, 0x98, 0x02, 0x99, 0x02, 0xb6, 0x02, 0xb8, 0x02, 0xba, 0x02, 0xbc, 0x02, 0xbe, 0x02, 0xc0, 0x02, + 0xc2, 0x02, 0xc4, 0x02, 0xc6, 0x02, 0xc8, 0x02, 0xca, 0x02, 0xcc, 0x02, 0xce, 0x02, 0xd0, 0x02, 0xd2, 0x02, 0xd4, + 0x02, 0xd6, 0x02, 0xd8, 0x02, 0xda, 0x02, 0xdc, 0x02, 0xde, 0x02, 0xe0, 0x02, 0xe2, 0x02, 0xe3, 0x02, 0xe5, 0x02, + 0xe7, 0x02, 0xe9, 0x02, 0xeb, 0x02, 0xed, 0x02, 0xef, 0x02, 0xf1, 0x02, 0xf3, 0x02, 0xf5, 0x02, 0xf8, 0x02, 0xfa, + 0x02, 0xfc, 0x02, 0xfe, 0x03, 0x00, 0x03, 0x02, 0x03, 0x04, 0x03, 0x06, 0x03, 0x08, 0x03, 0x0a, 0x03, 0x0c, 0x03, + 0x0e, 0x03, 0x10, 0x03, 0x12, 0x03, 0x14, 0x03, 0x16, 0x03, 0x18, 0x03, 0x1a, 0x03, 0x1c, 0x03, 0x1e, 0x03, 0x20, + 0x03, 0x22, 0x03, 0x24, 0x03, 0x25, 0x03, 0x27, 0x03, 0x29, 0x03, 0x2b, 0x03, 0x2d, 0x03, 0x86, 0x03, 0x87, 0x03, + 0x88, 0x03, 0x89, 0x03, 0x8a, 0x03, 0x8b, 0x03, 0x8c, 0x03, 0x8e, 0x03, 0x8f, 0x03, 0x90, 0x03, 0x91, 0x03, 0x92, + 0x03, 0x93, 0x03, 0x94, 0x03, 0x95, 0x03, 0x96, 0x03, 0x97, 0x03, 0x98, 0x03, 0x99, 0x03, 0x9a, 0x03, 0x9b, 0x03, + 0x9c, 0x03, 0x9d, 0x03, 0xad, 0x03, 0xae, 0x03, 0xaf, 0x03, 0xb0, 0x03, 0xb1, 0x03, 0xb2, 0x03, 0xb3, 0x03, 0xb4, + 0x03, 0xb5, 0x03, 0xb6, 0x03, 0xb7, 0x03, 0xb8, 0x03, 0xb9, 0x03, 0xba, 0x03, 0xbb, 0x03, 0xbc, 0x03, 0xbd, 0x03, + 0xbe, 0x03, 0xbf, 0x03, 0xc0, 0x03, 0xc1, 0x03, 0xc2, 0x03, 0xd3, 0x03, 0xd5, 0x03, 0xd7, 0x03, 0xd9, 0x03, 0xee, + 0x03, 0xf0, 0x03, 0xf2, 0x04, 0x07, 0x04, 0x0d, 0x04, 0x13, 0x04, 0x7d, 0x04, 0x82, 0x04, 0x86, 0x05, 0x07, 0x05, + 0x09, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x0a, 0x3a, 0x18, 0x00, 0x01, 0x03, 0xf2, 0x00, 0x04, 0x00, 0x00, + 0x01, 0xf4, 0x07, 0xce, 0x34, 0xc6, 0x34, 0xc6, 0x07, 0xfc, 0x08, 0x5e, 0x36, 0xfe, 0x37, 0xae, 0x34, 0xcc, 0x39, + 0xcc, 0x37, 0x7a, 0x08, 0x64, 0x38, 0x18, 0x38, 0x18, 0x37, 0xb8, 0x38, 0x02, 0x38, 0x18, 0x38, 0x18, 0x39, 0xcc, + 0x38, 0x44, 0x0c, 0x02, 0x0c, 0xd0, 0x38, 0x8a, 0x39, 0x58, 0x39, 0x94, 0x34, 0xde, 0x36, 0x84, 0x39, 0xb2, 0x0d, + 0x46, 0x37, 0x5c, 0x38, 0x66, 0x35, 0x8c, 0x0d, 0x8c, 0x38, 0x3a, 0x0e, 0xc2, 0x38, 0x3a, 0x38, 0x3a, 0x37, 0x88, + 0x38, 0x66, 0x38, 0x7c, 0x0f, 0xc4, 0x39, 0x76, 0x10, 0x26, 0x35, 0x3c, 0x39, 0x76, 0x10, 0x40, 0x38, 0x66, 0x39, + 0xcc, 0x10, 0x86, 0x35, 0xc6, 0x36, 0xfe, 0x39, 0xcc, 0x36, 0xfe, 0x11, 0x08, 0x12, 0x06, 0x13, 0x08, 0x13, 0xea, + 0x14, 0x8c, 0x39, 0x76, 0x14, 0x92, 0x14, 0x9c, 0x38, 0x3a, 0x17, 0x86, 0x19, 0x78, 0x1a, 0x6a, 0x1b, 0x70, 0x1b, + 0x86, 0x1b, 0x8c, 0x1b, 0x92, 0x1e, 0x8c, 0x1e, 0x92, 0x1e, 0xcc, 0x1f, 0x02, 0x1f, 0x8c, 0x35, 0xa0, 0x35, 0xa0, + 0x21, 0xbe, 0x38, 0x18, 0x22, 0x60, 0x23, 0x5e, 0x34, 0xde, 0x25, 0xc0, 0x38, 0x18, 0x38, 0x18, 0x35, 0x42, 0x38, + 0x18, 0x38, 0x18, 0x38, 0x18, 0x26, 0x96, 0x35, 0xa0, 0x38, 0x18, 0x35, 0xa0, 0x28, 0x40, 0x29, 0x06, 0x29, 0x98, + 0x29, 0xfa, 0x2a, 0xe0, 0x35, 0x96, 0x2b, 0x6e, 0x35, 0x3c, 0x33, 0x46, 0x2b, 0x98, 0x2d, 0x72, 0x38, 0x66, 0x31, + 0x00, 0x31, 0x3a, 0x33, 0x24, 0x33, 0x24, 0x38, 0x66, 0x32, 0x70, 0x32, 0xfa, 0x33, 0x24, 0x33, 0x24, 0x33, 0x24, + 0x36, 0xfe, 0x37, 0x88, 0x39, 0x58, 0x39, 0x76, 0x33, 0x46, 0x38, 0x66, 0x35, 0xc6, 0x35, 0x96, 0x34, 0xde, 0x35, + 0x3c, 0x37, 0xb8, 0x37, 0xb8, 0x37, 0xb8, 0x38, 0x18, 0x34, 0xde, 0x35, 0x3c, 0x38, 0x18, 0x38, 0x18, 0x39, 0xcc, + 0x35, 0x96, 0x34, 0xde, 0x35, 0x3c, 0x34, 0xc6, 0x33, 0x70, 0x34, 0xc6, 0x34, 0xc6, 0x34, 0xc6, 0x3a, 0x08, 0x34, + 0x12, 0x34, 0x60, 0x3a, 0x02, 0x34, 0xbc, 0x39, 0xea, 0x39, 0xf0, 0x3a, 0x02, 0x39, 0xf0, 0x39, 0xea, 0x39, 0xea, + 0x39, 0xea, 0x39, 0xea, 0x34, 0xae, 0x39, 0xf0, 0x34, 0xcc, 0x39, 0xcc, 0x39, 0xcc, 0x39, 0xcc, 0x39, 0xcc, 0x38, + 0x8a, 0x36, 0xfe, 0x36, 0xfe, 0x36, 0xfe, 0x36, 0xfe, 0x36, 0xfe, 0x36, 0xfe, 0x36, 0xfe, 0x34, 0xcc, 0x37, 0x7a, + 0x37, 0x7a, 0x37, 0x7a, 0x37, 0x7a, 0x38, 0x18, 0x38, 0x18, 0x38, 0x18, 0x38, 0x18, 0x38, 0x18, 0x39, 0xcc, 0x39, + 0xcc, 0x39, 0xcc, 0x39, 0xcc, 0x39, 0xcc, 0x36, 0x84, 0x37, 0x5c, 0x37, 0x5c, 0x37, 0x5c, 0x37, 0x5c, 0x37, 0x5c, + 0x37, 0x5c, 0x37, 0x5c, 0x35, 0x8c, 0x35, 0x8c, 0x35, 0x8c, 0x35, 0x8c, 0x38, 0x3a, 0x37, 0x88, 0x37, 0x88, 0x37, + 0x88, 0x37, 0x88, 0x37, 0x88, 0x39, 0x76, 0x39, 0x76, 0x36, 0xfe, 0x37, 0x5c, 0x36, 0xfe, 0x37, 0x5c, 0x36, 0xfe, + 0x37, 0x5c, 0x34, 0xcc, 0x34, 0xcc, 0x34, 0xcc, 0x34, 0xcc, 0x39, 0xcc, 0x37, 0x7a, 0x35, 0x8c, 0x37, 0x7a, 0x35, + 0x8c, 0x37, 0x7a, 0x35, 0x8c, 0x37, 0x7a, 0x35, 0x8c, 0x37, 0x7a, 0x35, 0x8c, 0x38, 0x18, 0x38, 0x3a, 0x38, 0x18, + 0x38, 0x18, 0x38, 0x18, 0x38, 0x18, 0x38, 0x18, 0x37, 0xb8, 0x38, 0x02, 0x38, 0x02, 0x38, 0x02, 0x38, 0x02, 0x38, + 0x18, 0x38, 0x3a, 0x38, 0x18, 0x38, 0x3a, 0x38, 0x18, 0x38, 0x3a, 0x38, 0x3a, 0x39, 0xcc, 0x37, 0x88, 0x39, 0xcc, + 0x37, 0x88, 0x39, 0xcc, 0x37, 0x88, 0x38, 0x7c, 0x38, 0x7c, 0x38, 0x7c, 0x38, 0x8a, 0x38, 0x8a, 0x38, 0x8a, 0x39, + 0x94, 0x36, 0x84, 0x39, 0x76, 0x36, 0x84, 0x39, 0xb2, 0x39, 0xb2, 0x39, 0xb2, 0x3a, 0x02, 0x3a, 0x02, 0x3a, 0x08, + 0x39, 0xf0, 0x39, 0xf0, 0x39, 0xf0, 0x39, 0xf0, 0x39, 0xf0, 0x39, 0xf0, 0x39, 0xf0, 0x3a, 0x02, 0x3a, 0x02, 0x3a, + 0x02, 0x3a, 0x02, 0x3a, 0x02, 0x39, 0xf0, 0x39, 0xf0, 0x39, 0xf0, 0x3a, 0x02, 0x39, 0xea, 0x34, 0xbc, 0x34, 0xbc, + 0x34, 0xbc, 0x34, 0xbc, 0x3a, 0x02, 0x3a, 0x02, 0x3a, 0x02, 0x3a, 0x08, 0x36, 0xfe, 0x37, 0x7a, 0x38, 0x18, 0x38, + 0x18, 0x39, 0xcc, 0x36, 0x84, 0x36, 0xfe, 0x37, 0xae, 0x37, 0x7a, 0x39, 0xb2, 0x38, 0x18, 0x38, 0x18, 0x37, 0xb8, + 0x38, 0x18, 0x38, 0x18, 0x39, 0xcc, 0x38, 0x44, 0x38, 0x8a, 0x36, 0x84, 0x34, 0xde, 0x38, 0x18, 0x36, 0x84, 0x38, + 0x3a, 0x37, 0x88, 0x39, 0x76, 0x37, 0x88, 0x37, 0x7a, 0x35, 0xc6, 0x38, 0x18, 0x38, 0x18, 0x37, 0xb8, 0x37, 0xb8, + 0x35, 0x42, 0x36, 0xfe, 0x37, 0xae, 0x35, 0xc6, 0x37, 0x7a, 0x38, 0x18, 0x38, 0x18, 0x39, 0xcc, 0x38, 0x44, 0x34, + 0xcc, 0x38, 0x8a, 0x34, 0xde, 0x37, 0x5c, 0x35, 0x8c, 0x37, 0x88, 0x38, 0x66, 0x39, 0x76, 0x35, 0x3c, 0x35, 0x8c, + 0x35, 0x96, 0x39, 0x76, 0x39, 0x94, 0x39, 0x94, 0x39, 0x94, 0x36, 0x84, 0x39, 0x76, 0x34, 0xc6, 0x34, 0xc6, 0x34, + 0xc6, 0x38, 0x18, 0x38, 0x3a, 0x36, 0xfe, 0x37, 0x5c, 0x37, 0x7a, 0x35, 0x8c, 0x39, 0x58, 0x39, 0x76, 0x34, 0xcc, + 0x36, 0x84, 0x39, 0x76, 0x38, 0x18, 0x34, 0xde, 0x35, 0x3c, 0x38, 0x18, 0x36, 0xfe, 0x37, 0x5c, 0x36, 0xfe, 0x37, + 0x5c, 0x37, 0x7a, 0x35, 0x8c, 0x35, 0x8c, 0x35, 0x8c, 0x34, 0xde, 0x35, 0x3c, 0x39, 0xcc, 0x37, 0x88, 0x37, 0x88, + 0x38, 0x66, 0x35, 0x42, 0x39, 0x76, 0x35, 0x42, 0x39, 0x76, 0x35, 0x42, 0x39, 0x76, 0x36, 0xfe, 0x37, 0x5c, 0x36, + 0xfe, 0x37, 0x5c, 0x36, 0xfe, 0x37, 0x5c, 0x36, 0xfe, 0x37, 0x5c, 0x36, 0xfe, 0x37, 0x5c, 0x36, 0xfe, 0x37, 0x5c, + 0x36, 0xfe, 0x37, 0x5c, 0x36, 0xfe, 0x37, 0x5c, 0x36, 0xfe, 0x37, 0x5c, 0x36, 0xfe, 0x37, 0x5c, 0x36, 0xfe, 0x37, + 0x5c, 0x36, 0xfe, 0x37, 0x5c, 0x37, 0x7a, 0x35, 0x8c, 0x37, 0x7a, 0x35, 0x8c, 0x37, 0x7a, 0x35, 0x8c, 0x37, 0x7a, + 0x35, 0x8c, 0x37, 0x7a, 0x35, 0x8c, 0x37, 0x7a, 0x35, 0x8c, 0x37, 0x7a, 0x35, 0x8c, 0x37, 0x7a, 0x35, 0x8c, 0x38, + 0x18, 0x38, 0x18, 0x39, 0xcc, 0x37, 0x88, 0x39, 0xcc, 0x37, 0x88, 0x39, 0xcc, 0x37, 0x88, 0x39, 0xcc, 0x37, 0x88, + 0x39, 0xcc, 0x37, 0x88, 0x39, 0xcc, 0x37, 0x88, 0x39, 0xcc, 0x37, 0x88, 0x37, 0x88, 0x36, 0x84, 0x39, 0x76, 0x36, + 0x84, 0x39, 0x76, 0x36, 0x84, 0x39, 0x76, 0x38, 0x8a, 0x35, 0xc6, 0x35, 0x96, 0x38, 0x3a, 0x35, 0xa0, 0x35, 0xc6, + 0x37, 0xb8, 0x36, 0x84, 0x38, 0x18, 0x38, 0x3a, 0x36, 0xfe, 0x37, 0x5c, 0x37, 0x7a, 0x38, 0x18, 0x39, 0xcc, 0x37, + 0x88, 0x38, 0x7c, 0x37, 0xae, 0x38, 0x66, 0x39, 0xcc, 0x39, 0xcc, 0x38, 0x18, 0x38, 0x3a, 0x37, 0xb8, 0x37, 0xb8, + 0x38, 0x02, 0x38, 0x18, 0x38, 0x3a, 0x38, 0x18, 0x38, 0x3a, 0x39, 0xcc, 0x38, 0x44, 0x38, 0x66, 0x38, 0x7c, 0x38, + 0x8a, 0x39, 0x58, 0x39, 0x76, 0x39, 0x58, 0x39, 0x76, 0x39, 0x94, 0x39, 0xb2, 0x39, 0xcc, 0x39, 0xf0, 0x3a, 0x02, + 0x39, 0xf0, 0x39, 0xea, 0x3a, 0x08, 0x39, 0xea, 0x39, 0xf0, 0x3a, 0x02, 0x3a, 0x08, 0x00, 0x02, 0x00, 0xa4, 0x00, + 0x04, 0x00, 0x04, 0x00, 0x00, 0x00, 0x06, 0x00, 0x06, 0x00, 0x01, 0x00, 0x0b, 0x00, 0x0c, 0x00, 0x02, 0x00, 0x13, + 0x00, 0x13, 0x00, 0x04, 0x00, 0x25, 0x00, 0x2a, 0x00, 0x05, 0x00, 0x2c, 0x00, 0x2d, 0x00, 0x0b, 0x00, 0x2f, 0x00, + 0x36, 0x00, 0x0d, 0x00, 0x38, 0x00, 0x38, 0x00, 0x15, 0x00, 0x3a, 0x00, 0x3f, 0x00, 0x16, 0x00, 0x45, 0x00, 0x46, + 0x00, 0x1c, 0x00, 0x49, 0x00, 0x4a, 0x00, 0x1e, 0x00, 0x4c, 0x00, 0x4c, 0x00, 0x20, 0x00, 0x4f, 0x00, 0x4f, 0x00, + 0x21, 0x00, 0x51, 0x00, 0x54, 0x00, 0x22, 0x00, 0x56, 0x00, 0x56, 0x00, 0x26, 0x00, 0x58, 0x00, 0x58, 0x00, 0x27, + 0x00, 0x5a, 0x00, 0x5d, 0x00, 0x28, 0x00, 0x5f, 0x00, 0x5f, 0x00, 0x2c, 0x00, 0x8a, 0x00, 0x8a, 0x00, 0x2d, 0x00, + 0x96, 0x00, 0x96, 0x00, 0x2e, 0x00, 0x9d, 0x00, 0x9d, 0x00, 0x2f, 0x00, 0xb1, 0x00, 0xb5, 0x00, 0x30, 0x00, 0xb7, + 0x00, 0xb9, 0x00, 0x35, 0x00, 0xbb, 0x00, 0xbb, 0x00, 0x38, 0x00, 0xbd, 0x00, 0xbe, 0x00, 0x39, 0x00, 0xc0, 0x00, + 0xc1, 0x00, 0x3b, 0x00, 0xc3, 0x00, 0xc5, 0x00, 0x3d, 0x00, 0xc7, 0x00, 0xce, 0x00, 0x40, 0x00, 0xd2, 0x00, 0xd2, + 0x00, 0x48, 0x00, 0xd4, 0x00, 0xde, 0x00, 0x49, 0x00, 0xe0, 0x00, 0xef, 0x00, 0x54, 0x00, 0xf1, 0x00, 0xf1, 0x00, + 0x64, 0x00, 0xf6, 0x00, 0xf8, 0x00, 0x65, 0x00, 0xfb, 0x00, 0xfc, 0x00, 0x68, 0x00, 0xfe, 0x01, 0x00, 0x00, 0x6a, + 0x01, 0x03, 0x01, 0x05, 0x00, 0x6d, 0x01, 0x0a, 0x01, 0x0a, 0x00, 0x70, 0x01, 0x0d, 0x01, 0x0d, 0x00, 0x71, 0x01, + 0x18, 0x01, 0x1a, 0x00, 0x72, 0x01, 0x22, 0x01, 0x22, 0x00, 0x75, 0x01, 0x2e, 0x01, 0x30, 0x00, 0x76, 0x01, 0x33, + 0x01, 0x35, 0x00, 0x79, 0x01, 0x37, 0x01, 0x37, 0x00, 0x7c, 0x01, 0x39, 0x01, 0x39, 0x00, 0x7d, 0x01, 0x3b, 0x01, + 0x3b, 0x00, 0x7e, 0x01, 0x43, 0x01, 0x44, 0x00, 0x7f, 0x01, 0x54, 0x01, 0x54, 0x00, 0x81, 0x01, 0x56, 0x01, 0x56, + 0x00, 0x82, 0x01, 0x58, 0x01, 0x58, 0x00, 0x83, 0x01, 0x5c, 0x01, 0x5e, 0x00, 0x84, 0x01, 0x84, 0x01, 0x85, 0x00, + 0x87, 0x01, 0x87, 0x01, 0x89, 0x00, 0x89, 0x01, 0xd8, 0x01, 0xd8, 0x00, 0x8c, 0x01, 0xda, 0x01, 0xdb, 0x00, 0x8d, + 0x01, 0xdd, 0x01, 0xdd, 0x00, 0x8f, 0x01, 0xe0, 0x01, 0xe1, 0x00, 0x90, 0x01, 0xeb, 0x01, 0xed, 0x00, 0x92, 0x01, + 0xff, 0x01, 0xff, 0x00, 0x95, 0x02, 0x0e, 0x02, 0x10, 0x00, 0x96, 0x02, 0x30, 0x02, 0x30, 0x00, 0x99, 0x02, 0x33, + 0x02, 0x33, 0x00, 0x9a, 0x02, 0x45, 0x02, 0x45, 0x00, 0x9b, 0x02, 0x47, 0x02, 0x48, 0x00, 0x9c, 0x02, 0x7a, 0x02, + 0x7b, 0x00, 0x9e, 0x02, 0x7d, 0x02, 0x7d, 0x00, 0xa0, 0x02, 0x7f, 0x02, 0x94, 0x00, 0xa1, 0x02, 0x99, 0x02, 0xa0, + 0x00, 0xb7, 0x02, 0xa2, 0x02, 0xa5, 0x00, 0xbf, 0x02, 0xaa, 0x02, 0xaf, 0x00, 0xc3, 0x02, 0xb4, 0x02, 0xbc, 0x00, + 0xc9, 0x02, 0xbe, 0x02, 0xbe, 0x00, 0xd2, 0x02, 0xc0, 0x02, 0xc0, 0x00, 0xd3, 0x02, 0xc2, 0x02, 0xc2, 0x00, 0xd4, + 0x02, 0xc4, 0x02, 0xc4, 0x00, 0xd5, 0x02, 0xc6, 0x02, 0xcf, 0x00, 0xd6, 0x02, 0xd8, 0x02, 0xda, 0x00, 0xe0, 0x02, + 0xdc, 0x02, 0xdc, 0x00, 0xe3, 0x02, 0xde, 0x02, 0xde, 0x00, 0xe4, 0x02, 0xe0, 0x02, 0xe0, 0x00, 0xe5, 0x02, 0xe2, + 0x02, 0xe2, 0x00, 0xe6, 0x02, 0xe7, 0x02, 0xe7, 0x00, 0xe7, 0x02, 0xe9, 0x02, 0xe9, 0x00, 0xe8, 0x02, 0xeb, 0x02, + 0xeb, 0x00, 0xe9, 0x02, 0xed, 0x02, 0xed, 0x00, 0xea, 0x02, 0xef, 0x02, 0xef, 0x00, 0xeb, 0x02, 0xf1, 0x02, 0xfd, + 0x00, 0xec, 0x02, 0xff, 0x02, 0xff, 0x00, 0xf9, 0x03, 0x01, 0x03, 0x01, 0x00, 0xfa, 0x03, 0x03, 0x03, 0x03, 0x00, + 0xfb, 0x03, 0x0e, 0x03, 0x0e, 0x00, 0xfc, 0x03, 0x10, 0x03, 0x10, 0x00, 0xfd, 0x03, 0x12, 0x03, 0x12, 0x00, 0xfe, + 0x03, 0x20, 0x03, 0x20, 0x00, 0xff, 0x03, 0x22, 0x03, 0x25, 0x01, 0x00, 0x03, 0x27, 0x03, 0x27, 0x01, 0x04, 0x03, + 0x29, 0x03, 0x29, 0x01, 0x05, 0x03, 0x2f, 0x03, 0x38, 0x01, 0x06, 0x03, 0x43, 0x03, 0x47, 0x01, 0x10, 0x03, 0x4d, + 0x03, 0x4f, 0x01, 0x15, 0x03, 0x54, 0x03, 0x54, 0x01, 0x18, 0x03, 0x65, 0x03, 0x69, 0x01, 0x19, 0x03, 0x6d, 0x03, + 0x6f, 0x01, 0x1e, 0x03, 0x78, 0x03, 0x78, 0x01, 0x21, 0x03, 0x86, 0x03, 0x8b, 0x01, 0x22, 0x03, 0x8e, 0x03, 0x9d, + 0x01, 0x28, 0x03, 0xa0, 0x03, 0xa0, 0x01, 0x38, 0x03, 0xa4, 0x03, 0xa4, 0x01, 0x39, 0x03, 0xa6, 0x03, 0xa6, 0x01, + 0x3a, 0x03, 0xaa, 0x03, 0xaa, 0x01, 0x3b, 0x03, 0xad, 0x03, 0xae, 0x01, 0x3c, 0x03, 0xb0, 0x03, 0xb1, 0x01, 0x3e, + 0x03, 0xb3, 0x03, 0xb9, 0x01, 0x40, 0x03, 0xbb, 0x03, 0xbd, 0x01, 0x47, 0x03, 0xbf, 0x03, 0xc4, 0x01, 0x4a, 0x03, + 0xc6, 0x03, 0xc7, 0x01, 0x50, 0x03, 0xc9, 0x03, 0xcc, 0x01, 0x52, 0x03, 0xd2, 0x03, 0xd3, 0x01, 0x56, 0x03, 0xd5, + 0x03, 0xd5, 0x01, 0x58, 0x03, 0xd7, 0x03, 0xd7, 0x01, 0x59, 0x03, 0xd9, 0x03, 0xdc, 0x01, 0x5a, 0x03, 0xdf, 0x03, + 0xe4, 0x01, 0x5e, 0x03, 0xe6, 0x03, 0xe6, 0x01, 0x64, 0x03, 0xea, 0x03, 0xeb, 0x01, 0x65, 0x03, 0xf0, 0x03, 0xf0, + 0x01, 0x67, 0x03, 0xf2, 0x03, 0xfb, 0x01, 0x68, 0x03, 0xfe, 0x03, 0xff, 0x01, 0x72, 0x04, 0x01, 0x04, 0x04, 0x01, + 0x74, 0x04, 0x0b, 0x04, 0x0c, 0x01, 0x78, 0x04, 0x10, 0x04, 0x10, 0x01, 0x7a, 0x04, 0x12, 0x04, 0x18, 0x01, 0x7b, + 0x04, 0x1e, 0x04, 0x46, 0x01, 0x82, 0x04, 0x48, 0x04, 0x48, 0x01, 0xab, 0x04, 0x4a, 0x04, 0x57, 0x01, 0xac, 0x04, + 0x5f, 0x04, 0x5f, 0x01, 0xba, 0x04, 0x70, 0x04, 0x75, 0x01, 0xbb, 0x04, 0x77, 0x04, 0x77, 0x01, 0xc1, 0x04, 0x7b, + 0x04, 0x7c, 0x01, 0xc2, 0x04, 0x7f, 0x04, 0x7f, 0x01, 0xc4, 0x04, 0x81, 0x04, 0x82, 0x01, 0xc5, 0x04, 0x84, 0x04, + 0x84, 0x01, 0xc7, 0x04, 0x86, 0x04, 0x86, 0x01, 0xc8, 0x04, 0x97, 0x04, 0x9b, 0x01, 0xc9, 0x04, 0x9d, 0x04, 0x9d, + 0x01, 0xce, 0x04, 0x9f, 0x04, 0xa0, 0x01, 0xcf, 0x04, 0xa2, 0x04, 0xa2, 0x01, 0xd1, 0x04, 0xa6, 0x04, 0xa8, 0x01, + 0xd2, 0x04, 0xaa, 0x04, 0xaa, 0x01, 0xd5, 0x04, 0xac, 0x04, 0xae, 0x01, 0xd6, 0x04, 0xb0, 0x04, 0xb0, 0x01, 0xd9, + 0x04, 0xb2, 0x04, 0xb2, 0x01, 0xda, 0x04, 0xb4, 0x04, 0xba, 0x01, 0xdb, 0x04, 0xbc, 0x04, 0xbc, 0x01, 0xe2, 0x04, + 0xbf, 0x04, 0xbf, 0x01, 0xe3, 0x04, 0xc2, 0x04, 0xc6, 0x01, 0xe4, 0x04, 0xc8, 0x04, 0xc8, 0x01, 0xe9, 0x04, 0xca, + 0x04, 0xcb, 0x01, 0xea, 0x04, 0xcf, 0x04, 0xcf, 0x01, 0xec, 0x04, 0xd2, 0x04, 0xd2, 0x01, 0xed, 0x04, 0xd8, 0x04, + 0xd8, 0x01, 0xee, 0x04, 0xdd, 0x04, 0xdd, 0x01, 0xef, 0x04, 0xe8, 0x04, 0xe8, 0x01, 0xf0, 0x04, 0xea, 0x04, 0xea, + 0x01, 0xf1, 0x04, 0xf1, 0x04, 0xf1, 0x01, 0xf2, 0x04, 0xf5, 0x04, 0xf5, 0x01, 0xf3, 0x00, 0x0b, 0x00, 0x38, 0xff, + 0xd8, 0x00, 0xd2, 0xff, 0xd8, 0x00, 0xd6, 0xff, 0xd8, 0x01, 0x39, 0xff, 0xd8, 0x01, 0x45, 0xff, 0xd8, 0x03, 0x0e, + 0xff, 0xd8, 0x03, 0x10, 0xff, 0xd8, 0x03, 0x12, 0xff, 0xd8, 0x03, 0xc1, 0xff, 0xd8, 0x04, 0x77, 0xff, 0xd8, 0x04, + 0xbf, 0xff, 0xd8, 0x00, 0x18, 0x00, 0x3a, 0x00, 0x14, 0x00, 0x3b, 0x00, 0x12, 0x00, 0x3d, 0x00, 0x16, 0x01, 0x19, + 0x00, 0x14, 0x02, 0x99, 0x00, 0x16, 0x03, 0x20, 0x00, 0x12, 0x03, 0x22, 0x00, 0x16, 0x03, 0x24, 0x00, 0x16, 0x03, + 0x8b, 0x00, 0x16, 0x03, 0x9a, 0x00, 0x16, 0x03, 0x9d, 0x00, 0x16, 0x03, 0xd3, 0x00, 0x12, 0x03, 0xd5, 0x00, 0x12, + 0x03, 0xd7, 0x00, 0x12, 0x03, 0xd9, 0x00, 0x16, 0x03, 0xea, 0x00, 0x14, 0x03, 0xf2, 0x00, 0x16, 0x04, 0x70, 0x00, + 0x16, 0x04, 0x72, 0x00, 0x16, 0x04, 0x74, 0x00, 0x16, 0x04, 0x86, 0x00, 0x16, 0x04, 0xc2, 0x00, 0x14, 0x04, 0xc4, + 0x00, 0x14, 0x04, 0xc6, 0x00, 0x12, 0x00, 0x01, 0x00, 0x13, 0xff, 0x20, 0x00, 0xe7, 0x00, 0x10, 0xff, 0x16, 0x00, + 0x12, 0xff, 0x16, 0x00, 0x25, 0xff, 0x56, 0x00, 0x2e, 0xfe, 0xf8, 0x00, 0x38, 0x00, 0x14, 0x00, 0x45, 0xff, 0xde, + 0x00, 0x47, 0xff, 0xeb, 0x00, 0x48, 0xff, 0xeb, 0x00, 0x49, 0xff, 0xeb, 0x00, 0x4b, 0xff, 0xeb, 0x00, 0x53, 0xff, + 0xeb, 0x00, 0x55, 0xff, 0xeb, 0x00, 0x56, 0xff, 0xe6, 0x00, 0x59, 0xff, 0xea, 0x00, 0x5a, 0xff, 0xe8, 0x00, 0x5d, + 0xff, 0xe8, 0x00, 0x94, 0xff, 0xeb, 0x00, 0x99, 0xff, 0xeb, 0x00, 0x9b, 0xff, 0xea, 0x00, 0xb2, 0xff, 0x56, 0x00, + 0xb4, 0xff, 0x56, 0x00, 0xbb, 0xff, 0xeb, 0x00, 0xbd, 0xff, 0xe8, 0x00, 0xc8, 0xff, 0xeb, 0x00, 0xc9, 0xff, 0xeb, + 0x00, 0xcb, 0xff, 0xea, 0x00, 0xd2, 0x00, 0x14, 0x00, 0xd6, 0x00, 0x14, 0x00, 0xf7, 0xff, 0xeb, 0x01, 0x03, 0xff, + 0xeb, 0x01, 0x0d, 0xff, 0x56, 0x01, 0x18, 0xff, 0xeb, 0x01, 0x1a, 0xff, 0xe8, 0x01, 0x1e, 0xff, 0xeb, 0x01, 0x22, + 0xff, 0xeb, 0x01, 0x39, 0x00, 0x14, 0x01, 0x42, 0xff, 0xeb, 0x01, 0x45, 0x00, 0x14, 0x01, 0x60, 0xff, 0xeb, 0x01, + 0x61, 0xff, 0xeb, 0x01, 0x6b, 0xff, 0xeb, 0x01, 0x86, 0xff, 0x16, 0x01, 0x8a, 0xff, 0x16, 0x01, 0x8e, 0xff, 0x16, + 0x01, 0x8f, 0xff, 0x16, 0x01, 0xeb, 0xff, 0xc0, 0x01, 0xed, 0xff, 0xc0, 0x02, 0x33, 0xff, 0xc0, 0x02, 0x7f, 0xff, + 0x56, 0x02, 0x80, 0xff, 0x56, 0x02, 0x81, 0xff, 0x56, 0x02, 0x82, 0xff, 0x56, 0x02, 0x83, 0xff, 0x56, 0x02, 0x84, + 0xff, 0x56, 0x02, 0x85, 0xff, 0x56, 0x02, 0x9a, 0xff, 0xde, 0x02, 0x9b, 0xff, 0xde, 0x02, 0x9c, 0xff, 0xde, 0x02, + 0x9d, 0xff, 0xde, 0x02, 0x9e, 0xff, 0xde, 0x02, 0x9f, 0xff, 0xde, 0x02, 0xa0, 0xff, 0xde, 0x02, 0xa1, 0xff, 0xeb, + 0x02, 0xa2, 0xff, 0xeb, 0x02, 0xa3, 0xff, 0xeb, 0x02, 0xa4, 0xff, 0xeb, 0x02, 0xa5, 0xff, 0xeb, 0x02, 0xab, 0xff, + 0xeb, 0x02, 0xac, 0xff, 0xeb, 0x02, 0xad, 0xff, 0xeb, 0x02, 0xae, 0xff, 0xeb, 0x02, 0xaf, 0xff, 0xeb, 0x02, 0xb0, + 0xff, 0xea, 0x02, 0xb1, 0xff, 0xea, 0x02, 0xb2, 0xff, 0xea, 0x02, 0xb3, 0xff, 0xea, 0x02, 0xb4, 0xff, 0xe8, 0x02, + 0xb5, 0xff, 0xe8, 0x02, 0xb6, 0xff, 0x56, 0x02, 0xb7, 0xff, 0xde, 0x02, 0xb8, 0xff, 0x56, 0x02, 0xb9, 0xff, 0xde, + 0x02, 0xba, 0xff, 0x56, 0x02, 0xbb, 0xff, 0xde, 0x02, 0xbd, 0xff, 0xeb, 0x02, 0xbf, 0xff, 0xeb, 0x02, 0xc1, 0xff, + 0xeb, 0x02, 0xc3, 0xff, 0xeb, 0x02, 0xc5, 0xff, 0xeb, 0x02, 0xc7, 0xff, 0xeb, 0x02, 0xc9, 0xff, 0xeb, 0x02, 0xcb, + 0xff, 0xeb, 0x02, 0xcd, 0xff, 0xeb, 0x02, 0xcf, 0xff, 0xeb, 0x02, 0xd1, 0xff, 0xeb, 0x02, 0xd3, 0xff, 0xeb, 0x02, + 0xd5, 0xff, 0xeb, 0x02, 0xd7, 0xff, 0xeb, 0x02, 0xe5, 0xfe, 0xf8, 0x02, 0xf9, 0xff, 0xeb, 0x02, 0xfb, 0xff, 0xeb, + 0x02, 0xfd, 0xff, 0xeb, 0x03, 0x0e, 0x00, 0x14, 0x03, 0x10, 0x00, 0x14, 0x03, 0x12, 0x00, 0x14, 0x03, 0x15, 0xff, + 0xea, 0x03, 0x17, 0xff, 0xea, 0x03, 0x19, 0xff, 0xea, 0x03, 0x1b, 0xff, 0xea, 0x03, 0x1d, 0xff, 0xea, 0x03, 0x1f, + 0xff, 0xea, 0x03, 0x23, 0xff, 0xe8, 0x03, 0x32, 0xff, 0xc0, 0x03, 0x33, 0xff, 0xc0, 0x03, 0x34, 0xff, 0xc0, 0x03, + 0x35, 0xff, 0xc0, 0x03, 0x36, 0xff, 0xc0, 0x03, 0x37, 0xff, 0xc0, 0x03, 0x38, 0xff, 0xc0, 0x03, 0x4d, 0xff, 0xc0, + 0x03, 0x4e, 0xff, 0xc0, 0x03, 0x4f, 0xff, 0xc0, 0x03, 0x86, 0xff, 0x56, 0x03, 0x8e, 0xff, 0x56, 0x03, 0x9e, 0xff, + 0xeb, 0x03, 0xa2, 0xff, 0xea, 0x03, 0xa4, 0xff, 0xeb, 0x03, 0xa6, 0xff, 0xe8, 0x03, 0xa9, 0xff, 0xea, 0x03, 0xaa, + 0xff, 0xeb, 0x03, 0xab, 0xff, 0xea, 0x03, 0xb2, 0xfe, 0xf8, 0x03, 0xb6, 0xff, 0x56, 0x03, 0xc1, 0x00, 0x14, 0x03, + 0xc3, 0xff, 0xde, 0x03, 0xc4, 0xff, 0xeb, 0x03, 0xc6, 0xff, 0xeb, 0x03, 0xc8, 0xff, 0xeb, 0x03, 0xc9, 0xff, 0xe8, + 0x03, 0xcb, 0xff, 0xeb, 0x03, 0xd2, 0xff, 0xe8, 0x03, 0xda, 0xff, 0xe8, 0x03, 0xe2, 0xff, 0x56, 0x03, 0xe3, 0xff, + 0xde, 0x03, 0xe6, 0xff, 0xeb, 0x03, 0xeb, 0xff, 0xe8, 0x03, 0xec, 0xff, 0xeb, 0x03, 0xf1, 0xff, 0xeb, 0x03, 0xf3, + 0xff, 0xe8, 0x03, 0xf8, 0xff, 0x56, 0x03, 0xf9, 0xff, 0xde, 0x03, 0xfa, 0xff, 0x56, 0x03, 0xfb, 0xff, 0xde, 0x03, + 0xff, 0xff, 0xeb, 0x04, 0x01, 0xff, 0xeb, 0x04, 0x02, 0xff, 0xeb, 0x04, 0x0c, 0xff, 0xeb, 0x04, 0x0e, 0xff, 0xeb, + 0x04, 0x10, 0xff, 0xeb, 0x04, 0x14, 0xff, 0xe8, 0x04, 0x16, 0xff, 0xe8, 0x04, 0x18, 0xff, 0xe8, 0x04, 0x1d, 0xff, + 0xeb, 0x04, 0x1e, 0xff, 0x56, 0x04, 0x1f, 0xff, 0xde, 0x04, 0x20, 0xff, 0x56, 0x04, 0x21, 0xff, 0xde, 0x04, 0x22, + 0xff, 0x56, 0x04, 0x23, 0xff, 0xde, 0x04, 0x24, 0xff, 0x56, 0x04, 0x25, 0xff, 0xde, 0x04, 0x26, 0xff, 0x56, 0x04, + 0x27, 0xff, 0xde, 0x04, 0x28, 0xff, 0x56, 0x04, 0x29, 0xff, 0xde, 0x04, 0x2a, 0xff, 0x56, 0x04, 0x2b, 0xff, 0xde, + 0x04, 0x2c, 0xff, 0x56, 0x04, 0x2d, 0xff, 0xde, 0x04, 0x2e, 0xff, 0x56, 0x04, 0x2f, 0xff, 0xde, 0x04, 0x30, 0xff, + 0x56, 0x04, 0x31, 0xff, 0xde, 0x04, 0x32, 0xff, 0x56, 0x04, 0x33, 0xff, 0xde, 0x04, 0x34, 0xff, 0x56, 0x04, 0x35, + 0xff, 0xde, 0x04, 0x37, 0xff, 0xeb, 0x04, 0x39, 0xff, 0xeb, 0x04, 0x3b, 0xff, 0xeb, 0x04, 0x3d, 0xff, 0xeb, 0x04, + 0x3f, 0xff, 0xeb, 0x04, 0x41, 0xff, 0xeb, 0x04, 0x43, 0xff, 0xeb, 0x04, 0x45, 0xff, 0xeb, 0x04, 0x4b, 0xff, 0xeb, + 0x04, 0x4d, 0xff, 0xeb, 0x04, 0x4f, 0xff, 0xeb, 0x04, 0x51, 0xff, 0xeb, 0x04, 0x53, 0xff, 0xeb, 0x04, 0x55, 0xff, + 0xeb, 0x04, 0x57, 0xff, 0xeb, 0x04, 0x59, 0xff, 0xeb, 0x04, 0x5b, 0xff, 0xeb, 0x04, 0x5d, 0xff, 0xeb, 0x04, 0x5f, + 0xff, 0xeb, 0x04, 0x61, 0xff, 0xeb, 0x04, 0x63, 0xff, 0xea, 0x04, 0x65, 0xff, 0xea, 0x04, 0x67, 0xff, 0xea, 0x04, + 0x69, 0xff, 0xea, 0x04, 0x6b, 0xff, 0xea, 0x04, 0x6d, 0xff, 0xea, 0x04, 0x6f, 0xff, 0xea, 0x04, 0x71, 0xff, 0xe8, + 0x04, 0x73, 0xff, 0xe8, 0x04, 0x75, 0xff, 0xe8, 0x04, 0x77, 0x00, 0x14, 0x04, 0x99, 0xff, 0x56, 0x04, 0x9a, 0xff, + 0xde, 0x04, 0x9c, 0xff, 0xeb, 0x04, 0xa0, 0xff, 0xeb, 0x04, 0xa4, 0xff, 0xea, 0x04, 0xa9, 0xff, 0xeb, 0x04, 0xab, + 0xff, 0xeb, 0x04, 0xbf, 0x00, 0x14, 0x04, 0xc3, 0xff, 0xe8, 0x04, 0xc5, 0xff, 0xe8, 0x04, 0xcb, 0xff, 0xc0, 0x04, + 0xd2, 0xff, 0xc0, 0x04, 0xea, 0xff, 0xc0, 0x00, 0x33, 0x00, 0x38, 0xff, 0xd5, 0x00, 0x3a, 0xff, 0xe4, 0x00, 0x3b, + 0xff, 0xec, 0x00, 0x3d, 0xff, 0xdd, 0x00, 0xd2, 0xff, 0xd5, 0x00, 0xd6, 0xff, 0xd5, 0x01, 0x19, 0xff, 0xe4, 0x01, + 0x39, 0xff, 0xd5, 0x01, 0x45, 0xff, 0xd5, 0x01, 0xeb, 0x00, 0x0e, 0x01, 0xed, 0x00, 0x0e, 0x02, 0x33, 0x00, 0x0e, + 0x02, 0x99, 0xff, 0xdd, 0x03, 0x0e, 0xff, 0xd5, 0x03, 0x10, 0xff, 0xd5, 0x03, 0x12, 0xff, 0xd5, 0x03, 0x20, 0xff, + 0xec, 0x03, 0x22, 0xff, 0xdd, 0x03, 0x24, 0xff, 0xdd, 0x03, 0x32, 0x00, 0x0e, 0x03, 0x33, 0x00, 0x0e, 0x03, 0x34, + 0x00, 0x0e, 0x03, 0x35, 0x00, 0x0e, 0x03, 0x36, 0x00, 0x0e, 0x03, 0x37, 0x00, 0x0e, 0x03, 0x38, 0x00, 0x0e, 0x03, + 0x4d, 0x00, 0x0e, 0x03, 0x4e, 0x00, 0x0e, 0x03, 0x4f, 0x00, 0x0e, 0x03, 0x8b, 0xff, 0xdd, 0x03, 0x9a, 0xff, 0xdd, + 0x03, 0x9d, 0xff, 0xdd, 0x03, 0xc1, 0xff, 0xd5, 0x03, 0xd3, 0xff, 0xec, 0x03, 0xd5, 0xff, 0xec, 0x03, 0xd7, 0xff, + 0xec, 0x03, 0xd9, 0xff, 0xdd, 0x03, 0xea, 0xff, 0xe4, 0x03, 0xf2, 0xff, 0xdd, 0x04, 0x70, 0xff, 0xdd, 0x04, 0x72, + 0xff, 0xdd, 0x04, 0x74, 0xff, 0xdd, 0x04, 0x77, 0xff, 0xd5, 0x04, 0x86, 0xff, 0xdd, 0x04, 0xbf, 0xff, 0xd5, 0x04, + 0xc2, 0xff, 0xe4, 0x04, 0xc4, 0xff, 0xe4, 0x04, 0xc6, 0xff, 0xec, 0x04, 0xcb, 0x00, 0x0e, 0x04, 0xd2, 0x00, 0x0e, + 0x04, 0xea, 0x00, 0x0e, 0x00, 0x1d, 0x00, 0x38, 0xff, 0xb0, 0x00, 0x3a, 0xff, 0xed, 0x00, 0x3d, 0xff, 0xd0, 0x00, + 0xd2, 0xff, 0xb0, 0x00, 0xd6, 0xff, 0xb0, 0x01, 0x19, 0xff, 0xed, 0x01, 0x39, 0xff, 0xb0, 0x01, 0x45, 0xff, 0xb0, + 0x02, 0x99, 0xff, 0xd0, 0x03, 0x0e, 0xff, 0xb0, 0x03, 0x10, 0xff, 0xb0, 0x03, 0x12, 0xff, 0xb0, 0x03, 0x22, 0xff, + 0xd0, 0x03, 0x24, 0xff, 0xd0, 0x03, 0x8b, 0xff, 0xd0, 0x03, 0x9a, 0xff, 0xd0, 0x03, 0x9d, 0xff, 0xd0, 0x03, 0xc1, + 0xff, 0xb0, 0x03, 0xd9, 0xff, 0xd0, 0x03, 0xea, 0xff, 0xed, 0x03, 0xf2, 0xff, 0xd0, 0x04, 0x70, 0xff, 0xd0, 0x04, + 0x72, 0xff, 0xd0, 0x04, 0x74, 0xff, 0xd0, 0x04, 0x77, 0xff, 0xb0, 0x04, 0x86, 0xff, 0xd0, 0x04, 0xbf, 0xff, 0xb0, + 0x04, 0xc2, 0xff, 0xed, 0x04, 0xc4, 0xff, 0xed, 0x00, 0x11, 0x00, 0x2e, 0xff, 0xee, 0x00, 0x39, 0xff, 0xee, 0x02, + 0x95, 0xff, 0xee, 0x02, 0x96, 0xff, 0xee, 0x02, 0x97, 0xff, 0xee, 0x02, 0x98, 0xff, 0xee, 0x02, 0xe5, 0xff, 0xee, + 0x03, 0x14, 0xff, 0xee, 0x03, 0x16, 0xff, 0xee, 0x03, 0x18, 0xff, 0xee, 0x03, 0x1a, 0xff, 0xee, 0x03, 0x1c, 0xff, + 0xee, 0x03, 0x1e, 0xff, 0xee, 0x03, 0xb2, 0xff, 0xee, 0x04, 0x62, 0xff, 0xee, 0x04, 0x64, 0xff, 0xee, 0x04, 0xc1, + 0xff, 0xee, 0x00, 0x4d, 0x00, 0x06, 0x00, 0x10, 0x00, 0x0b, 0x00, 0x10, 0x00, 0x0d, 0x00, 0x14, 0x00, 0x41, 0x00, + 0x12, 0x00, 0x47, 0xff, 0xe8, 0x00, 0x48, 0xff, 0xe8, 0x00, 0x49, 0xff, 0xe8, 0x00, 0x4b, 0xff, 0xe8, 0x00, 0x55, + 0xff, 0xe8, 0x00, 0x61, 0x00, 0x13, 0x00, 0x94, 0xff, 0xe8, 0x00, 0x99, 0xff, 0xe8, 0x00, 0xbb, 0xff, 0xe8, 0x00, + 0xc8, 0xff, 0xe8, 0x00, 0xc9, 0xff, 0xe8, 0x00, 0xf7, 0xff, 0xe8, 0x01, 0x03, 0xff, 0xe8, 0x01, 0x1e, 0xff, 0xe8, + 0x01, 0x22, 0xff, 0xe8, 0x01, 0x42, 0xff, 0xe8, 0x01, 0x60, 0xff, 0xe8, 0x01, 0x61, 0xff, 0xe8, 0x01, 0x6b, 0xff, + 0xe8, 0x01, 0x84, 0x00, 0x10, 0x01, 0x85, 0x00, 0x10, 0x01, 0x87, 0x00, 0x10, 0x01, 0x88, 0x00, 0x10, 0x01, 0x89, + 0x00, 0x10, 0x02, 0xa1, 0xff, 0xe8, 0x02, 0xa2, 0xff, 0xe8, 0x02, 0xa3, 0xff, 0xe8, 0x02, 0xa4, 0xff, 0xe8, 0x02, + 0xa5, 0xff, 0xe8, 0x02, 0xbd, 0xff, 0xe8, 0x02, 0xbf, 0xff, 0xe8, 0x02, 0xc1, 0xff, 0xe8, 0x02, 0xc3, 0xff, 0xe8, + 0x02, 0xc5, 0xff, 0xe8, 0x02, 0xc7, 0xff, 0xe8, 0x02, 0xc9, 0xff, 0xe8, 0x02, 0xcb, 0xff, 0xe8, 0x02, 0xcd, 0xff, + 0xe8, 0x02, 0xcf, 0xff, 0xe8, 0x02, 0xd1, 0xff, 0xe8, 0x02, 0xd3, 0xff, 0xe8, 0x02, 0xd5, 0xff, 0xe8, 0x02, 0xd7, + 0xff, 0xe8, 0x03, 0x9e, 0xff, 0xe8, 0x03, 0xc4, 0xff, 0xe8, 0x03, 0xc8, 0xff, 0xe8, 0x03, 0xcb, 0xff, 0xe8, 0x03, + 0xdb, 0x00, 0x10, 0x03, 0xdc, 0x00, 0x10, 0x03, 0xdf, 0x00, 0x10, 0x03, 0xe6, 0xff, 0xe8, 0x03, 0xec, 0xff, 0xe8, + 0x03, 0xf1, 0xff, 0xe8, 0x03, 0xff, 0xff, 0xe8, 0x04, 0x01, 0xff, 0xe8, 0x04, 0x02, 0xff, 0xe8, 0x04, 0x0e, 0xff, + 0xe8, 0x04, 0x1d, 0xff, 0xe8, 0x04, 0x37, 0xff, 0xe8, 0x04, 0x39, 0xff, 0xe8, 0x04, 0x3b, 0xff, 0xe8, 0x04, 0x3d, + 0xff, 0xe8, 0x04, 0x3f, 0xff, 0xe8, 0x04, 0x41, 0xff, 0xe8, 0x04, 0x43, 0xff, 0xe8, 0x04, 0x45, 0xff, 0xe8, 0x04, + 0x59, 0xff, 0xe8, 0x04, 0x5b, 0xff, 0xe8, 0x04, 0x5d, 0xff, 0xe8, 0x04, 0x61, 0xff, 0xe8, 0x04, 0x9c, 0xff, 0xe8, + 0x04, 0xa9, 0xff, 0xe8, 0x04, 0xab, 0xff, 0xe8, 0x00, 0x40, 0x00, 0x47, 0xff, 0xec, 0x00, 0x48, 0xff, 0xec, 0x00, + 0x49, 0xff, 0xec, 0x00, 0x4b, 0xff, 0xec, 0x00, 0x55, 0xff, 0xec, 0x00, 0x94, 0xff, 0xec, 0x00, 0x99, 0xff, 0xec, + 0x00, 0xbb, 0xff, 0xec, 0x00, 0xc8, 0xff, 0xec, 0x00, 0xc9, 0xff, 0xec, 0x00, 0xf7, 0xff, 0xec, 0x01, 0x03, 0xff, + 0xec, 0x01, 0x1e, 0xff, 0xec, 0x01, 0x22, 0xff, 0xec, 0x01, 0x42, 0xff, 0xec, 0x01, 0x60, 0xff, 0xec, 0x01, 0x61, + 0xff, 0xec, 0x01, 0x6b, 0xff, 0xec, 0x02, 0xa1, 0xff, 0xec, 0x02, 0xa2, 0xff, 0xec, 0x02, 0xa3, 0xff, 0xec, 0x02, + 0xa4, 0xff, 0xec, 0x02, 0xa5, 0xff, 0xec, 0x02, 0xbd, 0xff, 0xec, 0x02, 0xbf, 0xff, 0xec, 0x02, 0xc1, 0xff, 0xec, + 0x02, 0xc3, 0xff, 0xec, 0x02, 0xc5, 0xff, 0xec, 0x02, 0xc7, 0xff, 0xec, 0x02, 0xc9, 0xff, 0xec, 0x02, 0xcb, 0xff, + 0xec, 0x02, 0xcd, 0xff, 0xec, 0x02, 0xcf, 0xff, 0xec, 0x02, 0xd1, 0xff, 0xec, 0x02, 0xd3, 0xff, 0xec, 0x02, 0xd5, + 0xff, 0xec, 0x02, 0xd7, 0xff, 0xec, 0x03, 0x9e, 0xff, 0xec, 0x03, 0xc4, 0xff, 0xec, 0x03, 0xc8, 0xff, 0xec, 0x03, + 0xcb, 0xff, 0xec, 0x03, 0xe6, 0xff, 0xec, 0x03, 0xec, 0xff, 0xec, 0x03, 0xf1, 0xff, 0xec, 0x03, 0xff, 0xff, 0xec, + 0x04, 0x01, 0xff, 0xec, 0x04, 0x02, 0xff, 0xec, 0x04, 0x0e, 0xff, 0xec, 0x04, 0x1d, 0xff, 0xec, 0x04, 0x37, 0xff, + 0xec, 0x04, 0x39, 0xff, 0xec, 0x04, 0x3b, 0xff, 0xec, 0x04, 0x3d, 0xff, 0xec, 0x04, 0x3f, 0xff, 0xec, 0x04, 0x41, + 0xff, 0xec, 0x04, 0x43, 0xff, 0xec, 0x04, 0x45, 0xff, 0xec, 0x04, 0x59, 0xff, 0xec, 0x04, 0x5b, 0xff, 0xec, 0x04, + 0x5d, 0xff, 0xec, 0x04, 0x61, 0xff, 0xec, 0x04, 0x9c, 0xff, 0xec, 0x04, 0xa9, 0xff, 0xec, 0x04, 0xab, 0xff, 0xec, + 0x00, 0x18, 0x00, 0x53, 0xff, 0xec, 0x01, 0x18, 0xff, 0xec, 0x02, 0xab, 0xff, 0xec, 0x02, 0xac, 0xff, 0xec, 0x02, + 0xad, 0xff, 0xec, 0x02, 0xae, 0xff, 0xec, 0x02, 0xaf, 0xff, 0xec, 0x02, 0xf9, 0xff, 0xec, 0x02, 0xfb, 0xff, 0xec, + 0x02, 0xfd, 0xff, 0xec, 0x03, 0xa4, 0xff, 0xec, 0x03, 0xaa, 0xff, 0xec, 0x03, 0xc6, 0xff, 0xec, 0x04, 0x0c, 0xff, + 0xec, 0x04, 0x10, 0xff, 0xec, 0x04, 0x4b, 0xff, 0xec, 0x04, 0x4d, 0xff, 0xec, 0x04, 0x4f, 0xff, 0xec, 0x04, 0x51, + 0xff, 0xec, 0x04, 0x53, 0xff, 0xec, 0x04, 0x55, 0xff, 0xec, 0x04, 0x57, 0xff, 0xec, 0x04, 0x5f, 0xff, 0xec, 0x04, + 0xa0, 0xff, 0xec, 0x00, 0x06, 0x00, 0x10, 0xff, 0x84, 0x00, 0x12, 0xff, 0x84, 0x01, 0x86, 0xff, 0x84, 0x01, 0x8a, + 0xff, 0x84, 0x01, 0x8e, 0xff, 0x84, 0x01, 0x8f, 0xff, 0x84, 0x00, 0x11, 0x00, 0x2e, 0xff, 0xec, 0x00, 0x39, 0xff, + 0xec, 0x02, 0x95, 0xff, 0xec, 0x02, 0x96, 0xff, 0xec, 0x02, 0x97, 0xff, 0xec, 0x02, 0x98, 0xff, 0xec, 0x02, 0xe5, + 0xff, 0xec, 0x03, 0x14, 0xff, 0xec, 0x03, 0x16, 0xff, 0xec, 0x03, 0x18, 0xff, 0xec, 0x03, 0x1a, 0xff, 0xec, 0x03, + 0x1c, 0xff, 0xec, 0x03, 0x1e, 0xff, 0xec, 0x03, 0xb2, 0xff, 0xec, 0x04, 0x62, 0xff, 0xec, 0x04, 0x64, 0xff, 0xec, + 0x04, 0xc1, 0xff, 0xec, 0x00, 0x20, 0x00, 0x06, 0xff, 0xf2, 0x00, 0x0b, 0xff, 0xf2, 0x00, 0x5a, 0xff, 0xf3, 0x00, + 0x5d, 0xff, 0xf3, 0x00, 0xbd, 0xff, 0xf3, 0x00, 0xf6, 0xff, 0xf5, 0x01, 0x1a, 0xff, 0xf3, 0x01, 0x84, 0xff, 0xf2, + 0x01, 0x85, 0xff, 0xf2, 0x01, 0x87, 0xff, 0xf2, 0x01, 0x88, 0xff, 0xf2, 0x01, 0x89, 0xff, 0xf2, 0x02, 0xb4, 0xff, + 0xf3, 0x02, 0xb5, 0xff, 0xf3, 0x03, 0x23, 0xff, 0xf3, 0x03, 0xa6, 0xff, 0xf3, 0x03, 0xc9, 0xff, 0xf3, 0x03, 0xd2, + 0xff, 0xf3, 0x03, 0xda, 0xff, 0xf3, 0x03, 0xdb, 0xff, 0xf2, 0x03, 0xdc, 0xff, 0xf2, 0x03, 0xdf, 0xff, 0xf2, 0x03, + 0xeb, 0xff, 0xf3, 0x03, 0xf3, 0xff, 0xf3, 0x04, 0x14, 0xff, 0xf3, 0x04, 0x16, 0xff, 0xf3, 0x04, 0x18, 0xff, 0xf3, + 0x04, 0x71, 0xff, 0xf3, 0x04, 0x73, 0xff, 0xf3, 0x04, 0x75, 0xff, 0xf3, 0x04, 0xc3, 0xff, 0xf3, 0x04, 0xc5, 0xff, + 0xf3, 0x00, 0x3f, 0x00, 0x27, 0xff, 0xf3, 0x00, 0x2b, 0xff, 0xf3, 0x00, 0x33, 0xff, 0xf3, 0x00, 0x35, 0xff, 0xf3, + 0x00, 0x83, 0xff, 0xf3, 0x00, 0x93, 0xff, 0xf3, 0x00, 0x98, 0xff, 0xf3, 0x00, 0xb3, 0xff, 0xf3, 0x00, 0xc4, 0x00, + 0x0d, 0x00, 0xd3, 0xff, 0xf3, 0x01, 0x08, 0xff, 0xf3, 0x01, 0x17, 0xff, 0xf3, 0x01, 0x1b, 0xff, 0xf3, 0x01, 0x1d, + 0xff, 0xf3, 0x01, 0x1f, 0xff, 0xf3, 0x01, 0x21, 0xff, 0xf3, 0x01, 0x41, 0xff, 0xf3, 0x01, 0x6a, 0xff, 0xf3, 0x02, + 0x45, 0xff, 0xf3, 0x02, 0x46, 0xff, 0xf3, 0x02, 0x48, 0xff, 0xf3, 0x02, 0x49, 0xff, 0xf3, 0x02, 0x86, 0xff, 0xf3, + 0x02, 0x90, 0xff, 0xf3, 0x02, 0x91, 0xff, 0xf3, 0x02, 0x92, 0xff, 0xf3, 0x02, 0x93, 0xff, 0xf3, 0x02, 0x94, 0xff, + 0xf3, 0x02, 0xbc, 0xff, 0xf3, 0x02, 0xbe, 0xff, 0xf3, 0x02, 0xc0, 0xff, 0xf3, 0x02, 0xc2, 0xff, 0xf3, 0x02, 0xd0, + 0xff, 0xf3, 0x02, 0xd2, 0xff, 0xf3, 0x02, 0xd4, 0xff, 0xf3, 0x02, 0xd6, 0xff, 0xf3, 0x02, 0xf8, 0xff, 0xf3, 0x02, + 0xfa, 0xff, 0xf3, 0x02, 0xfc, 0xff, 0xf3, 0x03, 0x2d, 0xff, 0xf3, 0x03, 0x8a, 0xff, 0xf3, 0x03, 0x97, 0xff, 0xf3, + 0x03, 0xbd, 0xff, 0xf3, 0x03, 0xc0, 0xff, 0xf3, 0x03, 0xed, 0xff, 0xf3, 0x03, 0xf0, 0xff, 0xf3, 0x04, 0x0b, 0xff, + 0xf3, 0x04, 0x0d, 0xff, 0xf3, 0x04, 0x0f, 0xff, 0xf3, 0x04, 0x4a, 0xff, 0xf3, 0x04, 0x4c, 0xff, 0xf3, 0x04, 0x4e, + 0xff, 0xf3, 0x04, 0x50, 0xff, 0xf3, 0x04, 0x52, 0xff, 0xf3, 0x04, 0x54, 0xff, 0xf3, 0x04, 0x56, 0xff, 0xf3, 0x04, + 0x58, 0xff, 0xf3, 0x04, 0x5a, 0xff, 0xf3, 0x04, 0x5c, 0xff, 0xf3, 0x04, 0x5e, 0xff, 0xf3, 0x04, 0x60, 0xff, 0xf3, + 0x04, 0x9f, 0xff, 0xf3, 0x04, 0xb8, 0xff, 0xf3, 0x00, 0x40, 0x00, 0x27, 0xff, 0xe6, 0x00, 0x2b, 0xff, 0xe6, 0x00, + 0x33, 0xff, 0xe6, 0x00, 0x35, 0xff, 0xe6, 0x00, 0x83, 0xff, 0xe6, 0x00, 0x93, 0xff, 0xe6, 0x00, 0x98, 0xff, 0xe6, + 0x00, 0xb3, 0xff, 0xe6, 0x00, 0xb8, 0xff, 0xc2, 0x00, 0xc4, 0x00, 0x10, 0x00, 0xd3, 0xff, 0xe6, 0x01, 0x08, 0xff, + 0xe6, 0x01, 0x17, 0xff, 0xe6, 0x01, 0x1b, 0xff, 0xe6, 0x01, 0x1d, 0xff, 0xe6, 0x01, 0x1f, 0xff, 0xe6, 0x01, 0x21, + 0xff, 0xe6, 0x01, 0x41, 0xff, 0xe6, 0x01, 0x6a, 0xff, 0xe6, 0x02, 0x45, 0xff, 0xe6, 0x02, 0x46, 0xff, 0xe6, 0x02, + 0x48, 0xff, 0xe6, 0x02, 0x49, 0xff, 0xe6, 0x02, 0x86, 0xff, 0xe6, 0x02, 0x90, 0xff, 0xe6, 0x02, 0x91, 0xff, 0xe6, + 0x02, 0x92, 0xff, 0xe6, 0x02, 0x93, 0xff, 0xe6, 0x02, 0x94, 0xff, 0xe6, 0x02, 0xbc, 0xff, 0xe6, 0x02, 0xbe, 0xff, + 0xe6, 0x02, 0xc0, 0xff, 0xe6, 0x02, 0xc2, 0xff, 0xe6, 0x02, 0xd0, 0xff, 0xe6, 0x02, 0xd2, 0xff, 0xe6, 0x02, 0xd4, + 0xff, 0xe6, 0x02, 0xd6, 0xff, 0xe6, 0x02, 0xf8, 0xff, 0xe6, 0x02, 0xfa, 0xff, 0xe6, 0x02, 0xfc, 0xff, 0xe6, 0x03, + 0x2d, 0xff, 0xe6, 0x03, 0x8a, 0xff, 0xe6, 0x03, 0x97, 0xff, 0xe6, 0x03, 0xbd, 0xff, 0xe6, 0x03, 0xc0, 0xff, 0xe6, + 0x03, 0xed, 0xff, 0xe6, 0x03, 0xf0, 0xff, 0xe6, 0x04, 0x0b, 0xff, 0xe6, 0x04, 0x0d, 0xff, 0xe6, 0x04, 0x0f, 0xff, + 0xe6, 0x04, 0x4a, 0xff, 0xe6, 0x04, 0x4c, 0xff, 0xe6, 0x04, 0x4e, 0xff, 0xe6, 0x04, 0x50, 0xff, 0xe6, 0x04, 0x52, + 0xff, 0xe6, 0x04, 0x54, 0xff, 0xe6, 0x04, 0x56, 0xff, 0xe6, 0x04, 0x58, 0xff, 0xe6, 0x04, 0x5a, 0xff, 0xe6, 0x04, + 0x5c, 0xff, 0xe6, 0x04, 0x5e, 0xff, 0xe6, 0x04, 0x60, 0xff, 0xe6, 0x04, 0x9f, 0xff, 0xe6, 0x04, 0xb8, 0xff, 0xe6, + 0x00, 0x38, 0x00, 0x25, 0xff, 0xe4, 0x00, 0x3c, 0xff, 0xd2, 0x00, 0x3d, 0xff, 0xd3, 0x00, 0xb2, 0xff, 0xe4, 0x00, + 0xb4, 0xff, 0xe4, 0x00, 0xc4, 0xff, 0xe2, 0x00, 0xda, 0xff, 0xd2, 0x01, 0x0d, 0xff, 0xe4, 0x01, 0x33, 0xff, 0xd2, + 0x01, 0x43, 0xff, 0xd2, 0x01, 0x5d, 0xff, 0xd2, 0x02, 0x7f, 0xff, 0xe4, 0x02, 0x80, 0xff, 0xe4, 0x02, 0x81, 0xff, + 0xe4, 0x02, 0x82, 0xff, 0xe4, 0x02, 0x83, 0xff, 0xe4, 0x02, 0x84, 0xff, 0xe4, 0x02, 0x85, 0xff, 0xe4, 0x02, 0x99, + 0xff, 0xd3, 0x02, 0xb6, 0xff, 0xe4, 0x02, 0xb8, 0xff, 0xe4, 0x02, 0xba, 0xff, 0xe4, 0x03, 0x22, 0xff, 0xd3, 0x03, + 0x24, 0xff, 0xd3, 0x03, 0x86, 0xff, 0xe4, 0x03, 0x8b, 0xff, 0xd3, 0x03, 0x8e, 0xff, 0xe4, 0x03, 0x9a, 0xff, 0xd3, + 0x03, 0x9b, 0xff, 0xd2, 0x03, 0x9d, 0xff, 0xd3, 0x03, 0xb6, 0xff, 0xe4, 0x03, 0xc2, 0xff, 0xd2, 0x03, 0xd9, 0xff, + 0xd3, 0x03, 0xe2, 0xff, 0xe4, 0x03, 0xf2, 0xff, 0xd3, 0x03, 0xf5, 0xff, 0xd2, 0x03, 0xf8, 0xff, 0xe4, 0x03, 0xfa, + 0xff, 0xe4, 0x04, 0x03, 0xff, 0xd2, 0x04, 0x1e, 0xff, 0xe4, 0x04, 0x20, 0xff, 0xe4, 0x04, 0x22, 0xff, 0xe4, 0x04, + 0x24, 0xff, 0xe4, 0x04, 0x26, 0xff, 0xe4, 0x04, 0x28, 0xff, 0xe4, 0x04, 0x2a, 0xff, 0xe4, 0x04, 0x2c, 0xff, 0xe4, + 0x04, 0x2e, 0xff, 0xe4, 0x04, 0x30, 0xff, 0xe4, 0x04, 0x32, 0xff, 0xe4, 0x04, 0x34, 0xff, 0xe4, 0x04, 0x70, 0xff, + 0xd3, 0x04, 0x72, 0xff, 0xd3, 0x04, 0x74, 0xff, 0xd3, 0x04, 0x86, 0xff, 0xd3, 0x04, 0x99, 0xff, 0xe4, 0x00, 0x28, + 0x00, 0x10, 0xff, 0x1e, 0x00, 0x12, 0xff, 0x1e, 0x00, 0x25, 0xff, 0xcd, 0x00, 0xb2, 0xff, 0xcd, 0x00, 0xb4, 0xff, + 0xcd, 0x00, 0xc7, 0xff, 0xf2, 0x01, 0x0d, 0xff, 0xcd, 0x01, 0x86, 0xff, 0x1e, 0x01, 0x8a, 0xff, 0x1e, 0x01, 0x8e, + 0xff, 0x1e, 0x01, 0x8f, 0xff, 0x1e, 0x02, 0x7f, 0xff, 0xcd, 0x02, 0x80, 0xff, 0xcd, 0x02, 0x81, 0xff, 0xcd, 0x02, + 0x82, 0xff, 0xcd, 0x02, 0x83, 0xff, 0xcd, 0x02, 0x84, 0xff, 0xcd, 0x02, 0x85, 0xff, 0xcd, 0x02, 0xb6, 0xff, 0xcd, + 0x02, 0xb8, 0xff, 0xcd, 0x02, 0xba, 0xff, 0xcd, 0x03, 0x86, 0xff, 0xcd, 0x03, 0x8e, 0xff, 0xcd, 0x03, 0xb6, 0xff, + 0xcd, 0x03, 0xe2, 0xff, 0xcd, 0x03, 0xf8, 0xff, 0xcd, 0x03, 0xfa, 0xff, 0xcd, 0x04, 0x1e, 0xff, 0xcd, 0x04, 0x20, + 0xff, 0xcd, 0x04, 0x22, 0xff, 0xcd, 0x04, 0x24, 0xff, 0xcd, 0x04, 0x26, 0xff, 0xcd, 0x04, 0x28, 0xff, 0xcd, 0x04, + 0x2a, 0xff, 0xcd, 0x04, 0x2c, 0xff, 0xcd, 0x04, 0x2e, 0xff, 0xcd, 0x04, 0x30, 0xff, 0xcd, 0x04, 0x32, 0xff, 0xcd, + 0x04, 0x34, 0xff, 0xcd, 0x04, 0x99, 0xff, 0xcd, 0x00, 0x01, 0x00, 0xc4, 0x00, 0x0e, 0x00, 0x02, 0x00, 0xca, 0xff, + 0xed, 0x00, 0xf6, 0xff, 0xc0, 0x00, 0xba, 0x00, 0x47, 0xff, 0xdc, 0x00, 0x48, 0xff, 0xdc, 0x00, 0x49, 0xff, 0xdc, + 0x00, 0x4b, 0xff, 0xdc, 0x00, 0x51, 0xff, 0xf3, 0x00, 0x52, 0xff, 0xf3, 0x00, 0x53, 0xff, 0xd6, 0x00, 0x54, 0xff, + 0xf3, 0x00, 0x55, 0xff, 0xdc, 0x00, 0x59, 0xff, 0xdd, 0x00, 0x5a, 0xff, 0xe1, 0x00, 0x5d, 0xff, 0xe1, 0x00, 0x94, + 0xff, 0xdc, 0x00, 0x99, 0xff, 0xdc, 0x00, 0x9b, 0xff, 0xdd, 0x00, 0xbb, 0xff, 0xdc, 0x00, 0xbd, 0xff, 0xe1, 0x00, + 0xbe, 0xff, 0xee, 0x00, 0xbf, 0xff, 0xe6, 0x00, 0xc1, 0xff, 0xf3, 0x00, 0xc2, 0xff, 0xeb, 0x00, 0xc3, 0xff, 0xe9, + 0x00, 0xc5, 0xff, 0xf0, 0x00, 0xc6, 0xff, 0xe7, 0x00, 0xc8, 0xff, 0xdc, 0x00, 0xc9, 0xff, 0xdc, 0x00, 0xca, 0xff, + 0xe3, 0x00, 0xcb, 0xff, 0xdd, 0x00, 0xcc, 0xff, 0xce, 0x00, 0xcd, 0xff, 0xd4, 0x00, 0xce, 0xff, 0xdb, 0x00, 0xec, + 0xff, 0xf3, 0x00, 0xf0, 0xff, 0xf3, 0x00, 0xf1, 0xff, 0xf3, 0x00, 0xf3, 0xff, 0xf3, 0x00, 0xf4, 0xff, 0xf3, 0x00, + 0xf5, 0xff, 0xf3, 0x00, 0xf7, 0xff, 0xdc, 0x00, 0xf8, 0xff, 0xf3, 0x00, 0xfa, 0xff, 0xf3, 0x00, 0xfb, 0xff, 0xf3, + 0x00, 0xfe, 0xff, 0xf3, 0x01, 0x00, 0xff, 0xf3, 0x01, 0x03, 0xff, 0xdc, 0x01, 0x05, 0xff, 0xf3, 0x01, 0x18, 0xff, + 0xd6, 0x01, 0x1a, 0xff, 0xe1, 0x01, 0x1e, 0xff, 0xdc, 0x01, 0x22, 0xff, 0xdc, 0x01, 0x2b, 0xff, 0xf3, 0x01, 0x36, + 0xff, 0xf3, 0x01, 0x3c, 0xff, 0xf3, 0x01, 0x3e, 0xff, 0xf3, 0x01, 0x42, 0xff, 0xdc, 0x01, 0x53, 0xff, 0xf3, 0x01, + 0x55, 0xff, 0xf3, 0x01, 0x57, 0xff, 0xf3, 0x01, 0x5c, 0xff, 0xf3, 0x01, 0x60, 0xff, 0xdc, 0x01, 0x61, 0xff, 0xdc, + 0x01, 0x6b, 0xff, 0xdc, 0x02, 0xa1, 0xff, 0xdc, 0x02, 0xa2, 0xff, 0xdc, 0x02, 0xa3, 0xff, 0xdc, 0x02, 0xa4, 0xff, + 0xdc, 0x02, 0xa5, 0xff, 0xdc, 0x02, 0xaa, 0xff, 0xf3, 0x02, 0xab, 0xff, 0xd6, 0x02, 0xac, 0xff, 0xd6, 0x02, 0xad, + 0xff, 0xd6, 0x02, 0xae, 0xff, 0xd6, 0x02, 0xaf, 0xff, 0xd6, 0x02, 0xb0, 0xff, 0xdd, 0x02, 0xb1, 0xff, 0xdd, 0x02, + 0xb2, 0xff, 0xdd, 0x02, 0xb3, 0xff, 0xdd, 0x02, 0xb4, 0xff, 0xe1, 0x02, 0xb5, 0xff, 0xe1, 0x02, 0xbd, 0xff, 0xdc, + 0x02, 0xbf, 0xff, 0xdc, 0x02, 0xc1, 0xff, 0xdc, 0x02, 0xc3, 0xff, 0xdc, 0x02, 0xc5, 0xff, 0xdc, 0x02, 0xc7, 0xff, + 0xdc, 0x02, 0xc9, 0xff, 0xdc, 0x02, 0xcb, 0xff, 0xdc, 0x02, 0xcd, 0xff, 0xdc, 0x02, 0xcf, 0xff, 0xdc, 0x02, 0xd1, + 0xff, 0xdc, 0x02, 0xd3, 0xff, 0xdc, 0x02, 0xd5, 0xff, 0xdc, 0x02, 0xd7, 0xff, 0xdc, 0x02, 0xf2, 0xff, 0xf3, 0x02, + 0xf4, 0xff, 0xf3, 0x02, 0xf6, 0xff, 0xf3, 0x02, 0xf7, 0xff, 0xf3, 0x02, 0xf9, 0xff, 0xd6, 0x02, 0xfb, 0xff, 0xd6, + 0x02, 0xfd, 0xff, 0xd6, 0x03, 0x15, 0xff, 0xdd, 0x03, 0x17, 0xff, 0xdd, 0x03, 0x19, 0xff, 0xdd, 0x03, 0x1b, 0xff, + 0xdd, 0x03, 0x1d, 0xff, 0xdd, 0x03, 0x1f, 0xff, 0xdd, 0x03, 0x23, 0xff, 0xe1, 0x03, 0x9e, 0xff, 0xdc, 0x03, 0xa0, + 0xff, 0xf3, 0x03, 0xa2, 0xff, 0xdd, 0x03, 0xa4, 0xff, 0xd6, 0x03, 0xa6, 0xff, 0xe1, 0x03, 0xa9, 0xff, 0xdd, 0x03, + 0xaa, 0xff, 0xd6, 0x03, 0xab, 0xff, 0xdd, 0x03, 0xc4, 0xff, 0xdc, 0x03, 0xc5, 0xff, 0xf3, 0x03, 0xc6, 0xff, 0xd6, + 0x03, 0xc7, 0xff, 0xf3, 0x03, 0xc8, 0xff, 0xdc, 0x03, 0xc9, 0xff, 0xe1, 0x03, 0xcb, 0xff, 0xdc, 0x03, 0xcc, 0xff, + 0xf3, 0x03, 0xd1, 0xff, 0xf3, 0x03, 0xd2, 0xff, 0xe1, 0x03, 0xda, 0xff, 0xe1, 0x03, 0xe1, 0xff, 0xf3, 0x03, 0xe6, + 0xff, 0xdc, 0x03, 0xe7, 0xff, 0xf3, 0x03, 0xeb, 0xff, 0xe1, 0x03, 0xec, 0xff, 0xdc, 0x03, 0xf1, 0xff, 0xdc, 0x03, + 0xf3, 0xff, 0xe1, 0x03, 0xff, 0xff, 0xdc, 0x04, 0x01, 0xff, 0xdc, 0x04, 0x02, 0xff, 0xdc, 0x04, 0x08, 0xff, 0xf3, + 0x04, 0x0a, 0xff, 0xf3, 0x04, 0x0c, 0xff, 0xd6, 0x04, 0x0e, 0xff, 0xdc, 0x04, 0x10, 0xff, 0xd6, 0x04, 0x14, 0xff, + 0xe1, 0x04, 0x16, 0xff, 0xe1, 0x04, 0x18, 0xff, 0xe1, 0x04, 0x1c, 0xff, 0xf3, 0x04, 0x1d, 0xff, 0xdc, 0x04, 0x37, + 0xff, 0xdc, 0x04, 0x39, 0xff, 0xdc, 0x04, 0x3b, 0xff, 0xdc, 0x04, 0x3d, 0xff, 0xdc, 0x04, 0x3f, 0xff, 0xdc, 0x04, + 0x41, 0xff, 0xdc, 0x04, 0x43, 0xff, 0xdc, 0x04, 0x45, 0xff, 0xdc, 0x04, 0x4b, 0xff, 0xd6, 0x04, 0x4d, 0xff, 0xd6, + 0x04, 0x4f, 0xff, 0xd6, 0x04, 0x51, 0xff, 0xd6, 0x04, 0x53, 0xff, 0xd6, 0x04, 0x55, 0xff, 0xd6, 0x04, 0x57, 0xff, + 0xd6, 0x04, 0x59, 0xff, 0xdc, 0x04, 0x5b, 0xff, 0xdc, 0x04, 0x5d, 0xff, 0xdc, 0x04, 0x5f, 0xff, 0xd6, 0x04, 0x61, + 0xff, 0xdc, 0x04, 0x63, 0xff, 0xdd, 0x04, 0x65, 0xff, 0xdd, 0x04, 0x67, 0xff, 0xdd, 0x04, 0x69, 0xff, 0xdd, 0x04, + 0x6b, 0xff, 0xdd, 0x04, 0x6d, 0xff, 0xdd, 0x04, 0x6f, 0xff, 0xdd, 0x04, 0x71, 0xff, 0xe1, 0x04, 0x73, 0xff, 0xe1, + 0x04, 0x75, 0xff, 0xe1, 0x04, 0x7c, 0xff, 0xf3, 0x04, 0x98, 0xff, 0xf3, 0x04, 0x9c, 0xff, 0xdc, 0x04, 0xa0, 0xff, + 0xd6, 0x04, 0xa4, 0xff, 0xdd, 0x04, 0xa9, 0xff, 0xdc, 0x04, 0xab, 0xff, 0xdc, 0x04, 0xb5, 0xff, 0xf3, 0x04, 0xb7, + 0xff, 0xf3, 0x04, 0xc3, 0xff, 0xe1, 0x04, 0xc5, 0xff, 0xe1, 0x00, 0x7c, 0x00, 0x06, 0xff, 0xda, 0x00, 0x0b, 0xff, + 0xda, 0x00, 0x47, 0xff, 0xf0, 0x00, 0x48, 0xff, 0xf0, 0x00, 0x49, 0xff, 0xf0, 0x00, 0x4b, 0xff, 0xf0, 0x00, 0x55, + 0xff, 0xf0, 0x00, 0x59, 0xff, 0xef, 0x00, 0x5a, 0xff, 0xdc, 0x00, 0x5d, 0xff, 0xdc, 0x00, 0x94, 0xff, 0xf0, 0x00, + 0x99, 0xff, 0xf0, 0x00, 0x9b, 0xff, 0xef, 0x00, 0xbb, 0xff, 0xf0, 0x00, 0xbd, 0xff, 0xdc, 0x00, 0xc2, 0xff, 0xec, + 0x00, 0xc4, 0x00, 0x0f, 0x00, 0xc6, 0xff, 0xea, 0x00, 0xc8, 0xff, 0xf0, 0x00, 0xc9, 0xff, 0xf0, 0x00, 0xca, 0xff, + 0xc4, 0x00, 0xcb, 0xff, 0xef, 0x00, 0xcc, 0xff, 0xe7, 0x00, 0xf7, 0xff, 0xf0, 0x01, 0x03, 0xff, 0xf0, 0x01, 0x1a, + 0xff, 0xdc, 0x01, 0x1e, 0xff, 0xf0, 0x01, 0x22, 0xff, 0xf0, 0x01, 0x42, 0xff, 0xf0, 0x01, 0x60, 0xff, 0xf0, 0x01, + 0x61, 0xff, 0xf0, 0x01, 0x6b, 0xff, 0xf0, 0x01, 0x84, 0xff, 0xda, 0x01, 0x85, 0xff, 0xda, 0x01, 0x87, 0xff, 0xda, + 0x01, 0x88, 0xff, 0xda, 0x01, 0x89, 0xff, 0xda, 0x02, 0xa1, 0xff, 0xf0, 0x02, 0xa2, 0xff, 0xf0, 0x02, 0xa3, 0xff, + 0xf0, 0x02, 0xa4, 0xff, 0xf0, 0x02, 0xa5, 0xff, 0xf0, 0x02, 0xb0, 0xff, 0xef, 0x02, 0xb1, 0xff, 0xef, 0x02, 0xb2, + 0xff, 0xef, 0x02, 0xb3, 0xff, 0xef, 0x02, 0xb4, 0xff, 0xdc, 0x02, 0xb5, 0xff, 0xdc, 0x02, 0xbd, 0xff, 0xf0, 0x02, + 0xbf, 0xff, 0xf0, 0x02, 0xc1, 0xff, 0xf0, 0x02, 0xc3, 0xff, 0xf0, 0x02, 0xc5, 0xff, 0xf0, 0x02, 0xc7, 0xff, 0xf0, + 0x02, 0xc9, 0xff, 0xf0, 0x02, 0xcb, 0xff, 0xf0, 0x02, 0xcd, 0xff, 0xf0, 0x02, 0xcf, 0xff, 0xf0, 0x02, 0xd1, 0xff, + 0xf0, 0x02, 0xd3, 0xff, 0xf0, 0x02, 0xd5, 0xff, 0xf0, 0x02, 0xd7, 0xff, 0xf0, 0x03, 0x15, 0xff, 0xef, 0x03, 0x17, + 0xff, 0xef, 0x03, 0x19, 0xff, 0xef, 0x03, 0x1b, 0xff, 0xef, 0x03, 0x1d, 0xff, 0xef, 0x03, 0x1f, 0xff, 0xef, 0x03, + 0x23, 0xff, 0xdc, 0x03, 0x9e, 0xff, 0xf0, 0x03, 0xa2, 0xff, 0xef, 0x03, 0xa6, 0xff, 0xdc, 0x03, 0xa9, 0xff, 0xef, + 0x03, 0xab, 0xff, 0xef, 0x03, 0xc4, 0xff, 0xf0, 0x03, 0xc8, 0xff, 0xf0, 0x03, 0xc9, 0xff, 0xdc, 0x03, 0xcb, 0xff, + 0xf0, 0x03, 0xd2, 0xff, 0xdc, 0x03, 0xda, 0xff, 0xdc, 0x03, 0xdb, 0xff, 0xda, 0x03, 0xdc, 0xff, 0xda, 0x03, 0xdf, + 0xff, 0xda, 0x03, 0xe6, 0xff, 0xf0, 0x03, 0xeb, 0xff, 0xdc, 0x03, 0xec, 0xff, 0xf0, 0x03, 0xf1, 0xff, 0xf0, 0x03, + 0xf3, 0xff, 0xdc, 0x03, 0xff, 0xff, 0xf0, 0x04, 0x01, 0xff, 0xf0, 0x04, 0x02, 0xff, 0xf0, 0x04, 0x0e, 0xff, 0xf0, + 0x04, 0x14, 0xff, 0xdc, 0x04, 0x16, 0xff, 0xdc, 0x04, 0x18, 0xff, 0xdc, 0x04, 0x1d, 0xff, 0xf0, 0x04, 0x37, 0xff, + 0xf0, 0x04, 0x39, 0xff, 0xf0, 0x04, 0x3b, 0xff, 0xf0, 0x04, 0x3d, 0xff, 0xf0, 0x04, 0x3f, 0xff, 0xf0, 0x04, 0x41, + 0xff, 0xf0, 0x04, 0x43, 0xff, 0xf0, 0x04, 0x45, 0xff, 0xf0, 0x04, 0x59, 0xff, 0xf0, 0x04, 0x5b, 0xff, 0xf0, 0x04, + 0x5d, 0xff, 0xf0, 0x04, 0x61, 0xff, 0xf0, 0x04, 0x63, 0xff, 0xef, 0x04, 0x65, 0xff, 0xef, 0x04, 0x67, 0xff, 0xef, + 0x04, 0x69, 0xff, 0xef, 0x04, 0x6b, 0xff, 0xef, 0x04, 0x6d, 0xff, 0xef, 0x04, 0x6f, 0xff, 0xef, 0x04, 0x71, 0xff, + 0xdc, 0x04, 0x73, 0xff, 0xdc, 0x04, 0x75, 0xff, 0xdc, 0x04, 0x9c, 0xff, 0xf0, 0x04, 0xa4, 0xff, 0xef, 0x04, 0xa9, + 0xff, 0xf0, 0x04, 0xab, 0xff, 0xf0, 0x04, 0xc3, 0xff, 0xdc, 0x04, 0xc5, 0xff, 0xdc, 0x00, 0x3c, 0x00, 0x06, 0xff, + 0xa0, 0x00, 0x0b, 0xff, 0xa0, 0x00, 0x4a, 0xff, 0xe9, 0x00, 0x59, 0xff, 0xf1, 0x00, 0x5a, 0xff, 0xc5, 0x00, 0x5d, + 0xff, 0xc5, 0x00, 0x9b, 0xff, 0xf1, 0x00, 0xbd, 0xff, 0xc5, 0x00, 0xc2, 0xff, 0xee, 0x00, 0xc4, 0x00, 0x10, 0x00, + 0xc6, 0xff, 0xec, 0x00, 0xca, 0xff, 0x20, 0x00, 0xcb, 0xff, 0xf1, 0x01, 0x1a, 0xff, 0xc5, 0x01, 0x84, 0xff, 0xa0, + 0x01, 0x85, 0xff, 0xa0, 0x01, 0x87, 0xff, 0xa0, 0x01, 0x88, 0xff, 0xa0, 0x01, 0x89, 0xff, 0xa0, 0x02, 0xb0, 0xff, + 0xf1, 0x02, 0xb1, 0xff, 0xf1, 0x02, 0xb2, 0xff, 0xf1, 0x02, 0xb3, 0xff, 0xf1, 0x02, 0xb4, 0xff, 0xc5, 0x02, 0xb5, + 0xff, 0xc5, 0x03, 0x15, 0xff, 0xf1, 0x03, 0x17, 0xff, 0xf1, 0x03, 0x19, 0xff, 0xf1, 0x03, 0x1b, 0xff, 0xf1, 0x03, + 0x1d, 0xff, 0xf1, 0x03, 0x1f, 0xff, 0xf1, 0x03, 0x23, 0xff, 0xc5, 0x03, 0xa2, 0xff, 0xf1, 0x03, 0xa6, 0xff, 0xc5, + 0x03, 0xa9, 0xff, 0xf1, 0x03, 0xab, 0xff, 0xf1, 0x03, 0xc9, 0xff, 0xc5, 0x03, 0xd2, 0xff, 0xc5, 0x03, 0xda, 0xff, + 0xc5, 0x03, 0xdb, 0xff, 0xa0, 0x03, 0xdc, 0xff, 0xa0, 0x03, 0xdf, 0xff, 0xa0, 0x03, 0xeb, 0xff, 0xc5, 0x03, 0xf3, + 0xff, 0xc5, 0x04, 0x14, 0xff, 0xc5, 0x04, 0x16, 0xff, 0xc5, 0x04, 0x18, 0xff, 0xc5, 0x04, 0x63, 0xff, 0xf1, 0x04, + 0x65, 0xff, 0xf1, 0x04, 0x67, 0xff, 0xf1, 0x04, 0x69, 0xff, 0xf1, 0x04, 0x6b, 0xff, 0xf1, 0x04, 0x6d, 0xff, 0xf1, + 0x04, 0x6f, 0xff, 0xf1, 0x04, 0x71, 0xff, 0xc5, 0x04, 0x73, 0xff, 0xc5, 0x04, 0x75, 0xff, 0xc5, 0x04, 0xa4, 0xff, + 0xf1, 0x04, 0xc3, 0xff, 0xc5, 0x04, 0xc5, 0xff, 0xc5, 0x00, 0x41, 0x00, 0x47, 0xff, 0xe7, 0x00, 0x48, 0xff, 0xe7, + 0x00, 0x49, 0xff, 0xe7, 0x00, 0x4b, 0xff, 0xe7, 0x00, 0x55, 0xff, 0xe7, 0x00, 0x94, 0xff, 0xe7, 0x00, 0x99, 0xff, + 0xe7, 0x00, 0xbb, 0xff, 0xe7, 0x00, 0xc4, 0x00, 0x0f, 0x00, 0xc8, 0xff, 0xe7, 0x00, 0xc9, 0xff, 0xe7, 0x00, 0xf7, + 0xff, 0xe7, 0x01, 0x03, 0xff, 0xe7, 0x01, 0x1e, 0xff, 0xe7, 0x01, 0x22, 0xff, 0xe7, 0x01, 0x42, 0xff, 0xe7, 0x01, + 0x60, 0xff, 0xe7, 0x01, 0x61, 0xff, 0xe7, 0x01, 0x6b, 0xff, 0xe7, 0x02, 0xa1, 0xff, 0xe7, 0x02, 0xa2, 0xff, 0xe7, + 0x02, 0xa3, 0xff, 0xe7, 0x02, 0xa4, 0xff, 0xe7, 0x02, 0xa5, 0xff, 0xe7, 0x02, 0xbd, 0xff, 0xe7, 0x02, 0xbf, 0xff, + 0xe7, 0x02, 0xc1, 0xff, 0xe7, 0x02, 0xc3, 0xff, 0xe7, 0x02, 0xc5, 0xff, 0xe7, 0x02, 0xc7, 0xff, 0xe7, 0x02, 0xc9, + 0xff, 0xe7, 0x02, 0xcb, 0xff, 0xe7, 0x02, 0xcd, 0xff, 0xe7, 0x02, 0xcf, 0xff, 0xe7, 0x02, 0xd1, 0xff, 0xe7, 0x02, + 0xd3, 0xff, 0xe7, 0x02, 0xd5, 0xff, 0xe7, 0x02, 0xd7, 0xff, 0xe7, 0x03, 0x9e, 0xff, 0xe7, 0x03, 0xc4, 0xff, 0xe7, + 0x03, 0xc8, 0xff, 0xe7, 0x03, 0xcb, 0xff, 0xe7, 0x03, 0xe6, 0xff, 0xe7, 0x03, 0xec, 0xff, 0xe7, 0x03, 0xf1, 0xff, + 0xe7, 0x03, 0xff, 0xff, 0xe7, 0x04, 0x01, 0xff, 0xe7, 0x04, 0x02, 0xff, 0xe7, 0x04, 0x0e, 0xff, 0xe7, 0x04, 0x1d, + 0xff, 0xe7, 0x04, 0x37, 0xff, 0xe7, 0x04, 0x39, 0xff, 0xe7, 0x04, 0x3b, 0xff, 0xe7, 0x04, 0x3d, 0xff, 0xe7, 0x04, + 0x3f, 0xff, 0xe7, 0x04, 0x41, 0xff, 0xe7, 0x04, 0x43, 0xff, 0xe7, 0x04, 0x45, 0xff, 0xe7, 0x04, 0x59, 0xff, 0xe7, + 0x04, 0x5b, 0xff, 0xe7, 0x04, 0x5d, 0xff, 0xe7, 0x04, 0x61, 0xff, 0xe7, 0x04, 0x9c, 0xff, 0xe7, 0x04, 0xa9, 0xff, + 0xe7, 0x04, 0xab, 0xff, 0xe7, 0x00, 0x05, 0x00, 0xca, 0xff, 0xea, 0x00, 0xed, 0xff, 0xee, 0x00, 0xf6, 0xff, 0xab, + 0x01, 0x3a, 0xff, 0xec, 0x01, 0x6d, 0xff, 0xec, 0x00, 0x01, 0x00, 0xf6, 0xff, 0xd5, 0x00, 0x01, 0x00, 0xca, 0x00, + 0x0b, 0x00, 0xbe, 0x00, 0x06, 0x00, 0x0c, 0x00, 0x0b, 0x00, 0x0c, 0x00, 0x47, 0xff, 0xe8, 0x00, 0x48, 0xff, 0xe8, + 0x00, 0x49, 0xff, 0xe8, 0x00, 0x4a, 0x00, 0x0c, 0x00, 0x4b, 0xff, 0xe8, 0x00, 0x53, 0xff, 0xea, 0x00, 0x55, 0xff, + 0xe8, 0x00, 0x5a, 0x00, 0x0b, 0x00, 0x5d, 0x00, 0x0b, 0x00, 0x94, 0xff, 0xe8, 0x00, 0x99, 0xff, 0xe8, 0x00, 0xbb, + 0xff, 0xe8, 0x00, 0xbd, 0x00, 0x0b, 0x00, 0xbe, 0xff, 0xed, 0x00, 0xc6, 0x00, 0x0b, 0x00, 0xc8, 0xff, 0xe8, 0x00, + 0xc9, 0xff, 0xe8, 0x00, 0xca, 0x00, 0x0c, 0x00, 0xf7, 0xff, 0xe8, 0x01, 0x03, 0xff, 0xe8, 0x01, 0x18, 0xff, 0xea, + 0x01, 0x1a, 0x00, 0x0b, 0x01, 0x1e, 0xff, 0xe8, 0x01, 0x22, 0xff, 0xe8, 0x01, 0x42, 0xff, 0xe8, 0x01, 0x60, 0xff, + 0xe8, 0x01, 0x61, 0xff, 0xe8, 0x01, 0x6b, 0xff, 0xe8, 0x01, 0x84, 0x00, 0x0c, 0x01, 0x85, 0x00, 0x0c, 0x01, 0x87, + 0x00, 0x0c, 0x01, 0x88, 0x00, 0x0c, 0x01, 0x89, 0x00, 0x0c, 0x01, 0xd3, 0x00, 0x0d, 0x01, 0xd6, 0x00, 0x0d, 0x01, + 0xd8, 0x00, 0x0e, 0x01, 0xd9, 0xff, 0xf5, 0x01, 0xdb, 0xff, 0xec, 0x01, 0xdd, 0xff, 0xed, 0x01, 0xe5, 0xff, 0xec, + 0x01, 0xeb, 0xff, 0xbf, 0x01, 0xec, 0xff, 0xed, 0x01, 0xed, 0xff, 0xbf, 0x01, 0xf4, 0x00, 0x0e, 0x01, 0xf5, 0xff, + 0xed, 0x01, 0xf8, 0x00, 0x0e, 0x02, 0x10, 0x00, 0x0e, 0x02, 0x11, 0xff, 0xed, 0x02, 0x12, 0x00, 0x0d, 0x02, 0x14, + 0x00, 0x0e, 0x02, 0x1a, 0xff, 0xed, 0x02, 0x31, 0xff, 0xee, 0x02, 0x33, 0xff, 0xbf, 0x02, 0xa1, 0xff, 0xe8, 0x02, + 0xa2, 0xff, 0xe8, 0x02, 0xa3, 0xff, 0xe8, 0x02, 0xa4, 0xff, 0xe8, 0x02, 0xa5, 0xff, 0xe8, 0x02, 0xab, 0xff, 0xea, + 0x02, 0xac, 0xff, 0xea, 0x02, 0xad, 0xff, 0xea, 0x02, 0xae, 0xff, 0xea, 0x02, 0xaf, 0xff, 0xea, 0x02, 0xb4, 0x00, + 0x0b, 0x02, 0xb5, 0x00, 0x0b, 0x02, 0xbd, 0xff, 0xe8, 0x02, 0xbf, 0xff, 0xe8, 0x02, 0xc1, 0xff, 0xe8, 0x02, 0xc3, + 0xff, 0xe8, 0x02, 0xc5, 0xff, 0xe8, 0x02, 0xc7, 0xff, 0xe8, 0x02, 0xc9, 0xff, 0xe8, 0x02, 0xcb, 0xff, 0xe8, 0x02, + 0xcd, 0xff, 0xe8, 0x02, 0xcf, 0xff, 0xe8, 0x02, 0xd1, 0xff, 0xe8, 0x02, 0xd3, 0xff, 0xe8, 0x02, 0xd5, 0xff, 0xe8, + 0x02, 0xd7, 0xff, 0xe8, 0x02, 0xf9, 0xff, 0xea, 0x02, 0xfb, 0xff, 0xea, 0x02, 0xfd, 0xff, 0xea, 0x03, 0x23, 0x00, + 0x0b, 0x03, 0x32, 0xff, 0xbf, 0x03, 0x33, 0xff, 0xbf, 0x03, 0x34, 0xff, 0xbf, 0x03, 0x35, 0xff, 0xbf, 0x03, 0x36, + 0xff, 0xbf, 0x03, 0x37, 0xff, 0xbf, 0x03, 0x38, 0xff, 0xbf, 0x03, 0x39, 0xff, 0xed, 0x03, 0x43, 0xff, 0xed, 0x03, + 0x44, 0xff, 0xed, 0x03, 0x45, 0xff, 0xed, 0x03, 0x46, 0xff, 0xed, 0x03, 0x47, 0xff, 0xed, 0x03, 0x4c, 0x00, 0x0d, + 0x03, 0x4d, 0xff, 0xbf, 0x03, 0x4e, 0xff, 0xbf, 0x03, 0x4f, 0xff, 0xbf, 0x03, 0x50, 0xff, 0xed, 0x03, 0x51, 0xff, + 0xed, 0x03, 0x52, 0xff, 0xed, 0x03, 0x53, 0xff, 0xed, 0x03, 0x5a, 0xff, 0xed, 0x03, 0x5b, 0xff, 0xed, 0x03, 0x5c, + 0xff, 0xed, 0x03, 0x5d, 0xff, 0xed, 0x03, 0x6d, 0xff, 0xed, 0x03, 0x6e, 0xff, 0xed, 0x03, 0x6f, 0xff, 0xed, 0x03, + 0x73, 0xff, 0xf5, 0x03, 0x74, 0xff, 0xf5, 0x03, 0x75, 0xff, 0xf5, 0x03, 0x76, 0xff, 0xf5, 0x03, 0x78, 0x00, 0x0e, + 0x03, 0x81, 0x00, 0x0d, 0x03, 0x82, 0x00, 0x0d, 0x03, 0x9e, 0xff, 0xe8, 0x03, 0xa4, 0xff, 0xea, 0x03, 0xa6, 0x00, + 0x0b, 0x03, 0xaa, 0xff, 0xea, 0x03, 0xc4, 0xff, 0xe8, 0x03, 0xc6, 0xff, 0xea, 0x03, 0xc8, 0xff, 0xe8, 0x03, 0xc9, + 0x00, 0x0b, 0x03, 0xcb, 0xff, 0xe8, 0x03, 0xd2, 0x00, 0x0b, 0x03, 0xda, 0x00, 0x0b, 0x03, 0xdb, 0x00, 0x0c, 0x03, + 0xdc, 0x00, 0x0c, 0x03, 0xdf, 0x00, 0x0c, 0x03, 0xe6, 0xff, 0xe8, 0x03, 0xeb, 0x00, 0x0b, 0x03, 0xec, 0xff, 0xe8, + 0x03, 0xf1, 0xff, 0xe8, 0x03, 0xf3, 0x00, 0x0b, 0x03, 0xff, 0xff, 0xe8, 0x04, 0x01, 0xff, 0xe8, 0x04, 0x02, 0xff, + 0xe8, 0x04, 0x0c, 0xff, 0xea, 0x04, 0x0e, 0xff, 0xe8, 0x04, 0x10, 0xff, 0xea, 0x04, 0x14, 0x00, 0x0b, 0x04, 0x16, + 0x00, 0x0b, 0x04, 0x18, 0x00, 0x0b, 0x04, 0x1d, 0xff, 0xe8, 0x04, 0x37, 0xff, 0xe8, 0x04, 0x39, 0xff, 0xe8, 0x04, + 0x3b, 0xff, 0xe8, 0x04, 0x3d, 0xff, 0xe8, 0x04, 0x3f, 0xff, 0xe8, 0x04, 0x41, 0xff, 0xe8, 0x04, 0x43, 0xff, 0xe8, + 0x04, 0x45, 0xff, 0xe8, 0x04, 0x4b, 0xff, 0xea, 0x04, 0x4d, 0xff, 0xea, 0x04, 0x4f, 0xff, 0xea, 0x04, 0x51, 0xff, + 0xea, 0x04, 0x53, 0xff, 0xea, 0x04, 0x55, 0xff, 0xea, 0x04, 0x57, 0xff, 0xea, 0x04, 0x59, 0xff, 0xe8, 0x04, 0x5b, + 0xff, 0xe8, 0x04, 0x5d, 0xff, 0xe8, 0x04, 0x5f, 0xff, 0xea, 0x04, 0x61, 0xff, 0xe8, 0x04, 0x71, 0x00, 0x0b, 0x04, + 0x73, 0x00, 0x0b, 0x04, 0x75, 0x00, 0x0b, 0x04, 0x9c, 0xff, 0xe8, 0x04, 0xa0, 0xff, 0xea, 0x04, 0xa9, 0xff, 0xe8, + 0x04, 0xab, 0xff, 0xe8, 0x04, 0xc3, 0x00, 0x0b, 0x04, 0xc5, 0x00, 0x0b, 0x04, 0xcb, 0xff, 0xbf, 0x04, 0xcf, 0xff, + 0xed, 0x04, 0xd0, 0x00, 0x0d, 0x04, 0xd2, 0xff, 0xbf, 0x04, 0xde, 0x00, 0x0d, 0x04, 0xe1, 0x00, 0x0d, 0x04, 0xea, + 0xff, 0xbf, 0x04, 0xf1, 0xff, 0xed, 0x04, 0xf4, 0xff, 0xed, 0x04, 0xf5, 0x00, 0x0e, 0x04, 0xf9, 0xff, 0xed, 0x04, + 0xfa, 0x00, 0x0d, 0x00, 0x01, 0x00, 0xf6, 0xff, 0xd8, 0x00, 0x0e, 0x00, 0x5c, 0xff, 0xed, 0x00, 0x5e, 0xff, 0xed, + 0x00, 0xee, 0xff, 0xed, 0x00, 0xf6, 0xff, 0xaa, 0x01, 0x34, 0xff, 0xed, 0x01, 0x44, 0xff, 0xed, 0x01, 0x5e, 0xff, + 0xed, 0x03, 0x26, 0xff, 0xed, 0x03, 0x28, 0xff, 0xed, 0x03, 0x2a, 0xff, 0xed, 0x03, 0xca, 0xff, 0xed, 0x03, 0xf6, + 0xff, 0xed, 0x04, 0x04, 0xff, 0xed, 0x04, 0xc9, 0xff, 0xed, 0x00, 0x0d, 0x00, 0x5c, 0xff, 0xf2, 0x00, 0x5e, 0xff, + 0xf2, 0x00, 0xee, 0xff, 0xf2, 0x01, 0x34, 0xff, 0xf2, 0x01, 0x44, 0xff, 0xf2, 0x01, 0x5e, 0xff, 0xf2, 0x03, 0x26, + 0xff, 0xf2, 0x03, 0x28, 0xff, 0xf2, 0x03, 0x2a, 0xff, 0xf2, 0x03, 0xca, 0xff, 0xf2, 0x03, 0xf6, 0xff, 0xf2, 0x04, + 0x04, 0xff, 0xf2, 0x04, 0xc9, 0xff, 0xf2, 0x00, 0x22, 0x00, 0x5a, 0xff, 0xf4, 0x00, 0x5c, 0xff, 0xf2, 0x00, 0x5d, + 0xff, 0xf4, 0x00, 0x5e, 0xff, 0xf3, 0x00, 0xbd, 0xff, 0xf4, 0x00, 0xee, 0xff, 0xf2, 0x01, 0x1a, 0xff, 0xf4, 0x01, + 0x34, 0xff, 0xf2, 0x01, 0x44, 0xff, 0xf2, 0x01, 0x5e, 0xff, 0xf2, 0x02, 0xb4, 0xff, 0xf4, 0x02, 0xb5, 0xff, 0xf4, + 0x03, 0x23, 0xff, 0xf4, 0x03, 0x26, 0xff, 0xf3, 0x03, 0x28, 0xff, 0xf3, 0x03, 0x2a, 0xff, 0xf3, 0x03, 0xa6, 0xff, + 0xf4, 0x03, 0xc9, 0xff, 0xf4, 0x03, 0xca, 0xff, 0xf2, 0x03, 0xd2, 0xff, 0xf4, 0x03, 0xda, 0xff, 0xf4, 0x03, 0xeb, + 0xff, 0xf4, 0x03, 0xf3, 0xff, 0xf4, 0x03, 0xf6, 0xff, 0xf2, 0x04, 0x04, 0xff, 0xf2, 0x04, 0x14, 0xff, 0xf4, 0x04, + 0x16, 0xff, 0xf4, 0x04, 0x18, 0xff, 0xf4, 0x04, 0x71, 0xff, 0xf4, 0x04, 0x73, 0xff, 0xf4, 0x04, 0x75, 0xff, 0xf4, + 0x04, 0xc3, 0xff, 0xf4, 0x04, 0xc5, 0xff, 0xf4, 0x04, 0xc9, 0xff, 0xf3, 0x00, 0x8c, 0x00, 0x06, 0xff, 0xca, 0x00, + 0x0b, 0xff, 0xca, 0x00, 0x38, 0xff, 0xd2, 0x00, 0x3a, 0xff, 0xd4, 0x00, 0x3c, 0xff, 0xf4, 0x00, 0x3d, 0xff, 0xd3, + 0x00, 0x51, 0xff, 0xd1, 0x00, 0x52, 0xff, 0xd1, 0x00, 0x54, 0xff, 0xd1, 0x00, 0x5a, 0xff, 0xe6, 0x00, 0x5c, 0xff, + 0xef, 0x00, 0x5d, 0xff, 0xe6, 0x00, 0xbd, 0xff, 0xe6, 0x00, 0xc1, 0xff, 0xd1, 0x00, 0xd2, 0xff, 0xd2, 0x00, 0xd6, + 0xff, 0xd2, 0x00, 0xda, 0xff, 0xf4, 0x00, 0xde, 0xff, 0xed, 0x00, 0xe1, 0xff, 0xe1, 0x00, 0xe6, 0xff, 0xd4, 0x00, + 0xec, 0xff, 0xd1, 0x00, 0xee, 0xff, 0xef, 0x00, 0xf0, 0xff, 0xd1, 0x00, 0xf1, 0xff, 0xd1, 0x00, 0xf3, 0xff, 0xd1, + 0x00, 0xf4, 0xff, 0xd1, 0x00, 0xf5, 0xff, 0xd1, 0x00, 0xf6, 0xff, 0xc9, 0x00, 0xf8, 0xff, 0xd1, 0x00, 0xfa, 0xff, + 0xd1, 0x00, 0xfb, 0xff, 0xd1, 0x00, 0xfe, 0xff, 0xd1, 0x01, 0x00, 0xff, 0xd1, 0x01, 0x05, 0xff, 0xd1, 0x01, 0x09, + 0xff, 0xe5, 0x01, 0x19, 0xff, 0xd4, 0x01, 0x1a, 0xff, 0xe6, 0x01, 0x20, 0xff, 0xe3, 0x01, 0x2b, 0xff, 0xd1, 0x01, + 0x33, 0xff, 0xf4, 0x01, 0x34, 0xff, 0xef, 0x01, 0x36, 0xff, 0xd1, 0x01, 0x39, 0xff, 0xd2, 0x01, 0x3a, 0xff, 0xc4, + 0x01, 0x3c, 0xff, 0xd1, 0x01, 0x3e, 0xff, 0xd1, 0x01, 0x43, 0xff, 0xf4, 0x01, 0x44, 0xff, 0xef, 0x01, 0x45, 0xff, + 0xd2, 0x01, 0x47, 0xff, 0xe1, 0x01, 0x49, 0xff, 0xe1, 0x01, 0x53, 0xff, 0xd1, 0x01, 0x55, 0xff, 0xd1, 0x01, 0x57, + 0xff, 0xd1, 0x01, 0x5c, 0xff, 0xd1, 0x01, 0x5d, 0xff, 0xf4, 0x01, 0x5e, 0xff, 0xef, 0x01, 0x62, 0xff, 0xd4, 0x01, + 0x63, 0xff, 0xf5, 0x01, 0x64, 0xff, 0xe7, 0x01, 0x6c, 0xff, 0xd2, 0x01, 0x6d, 0xff, 0xc9, 0x01, 0x84, 0xff, 0xca, + 0x01, 0x85, 0xff, 0xca, 0x01, 0x87, 0xff, 0xca, 0x01, 0x88, 0xff, 0xca, 0x01, 0x89, 0xff, 0xca, 0x02, 0x99, 0xff, + 0xd3, 0x02, 0xaa, 0xff, 0xd1, 0x02, 0xb4, 0xff, 0xe6, 0x02, 0xb5, 0xff, 0xe6, 0x02, 0xf2, 0xff, 0xd1, 0x02, 0xf4, + 0xff, 0xd1, 0x02, 0xf6, 0xff, 0xd1, 0x02, 0xf7, 0xff, 0xd1, 0x03, 0x0e, 0xff, 0xd2, 0x03, 0x10, 0xff, 0xd2, 0x03, + 0x12, 0xff, 0xd2, 0x03, 0x22, 0xff, 0xd3, 0x03, 0x23, 0xff, 0xe6, 0x03, 0x24, 0xff, 0xd3, 0x03, 0x8b, 0xff, 0xd3, + 0x03, 0x9a, 0xff, 0xd3, 0x03, 0x9b, 0xff, 0xf4, 0x03, 0x9d, 0xff, 0xd3, 0x03, 0xa0, 0xff, 0xd1, 0x03, 0xa6, 0xff, + 0xe6, 0x03, 0xb5, 0xff, 0xed, 0x03, 0xc1, 0xff, 0xd2, 0x03, 0xc2, 0xff, 0xf4, 0x03, 0xc5, 0xff, 0xd1, 0x03, 0xc7, + 0xff, 0xd1, 0x03, 0xc9, 0xff, 0xe6, 0x03, 0xca, 0xff, 0xef, 0x03, 0xcc, 0xff, 0xd1, 0x03, 0xd1, 0xff, 0xd1, 0x03, + 0xd2, 0xff, 0xe6, 0x03, 0xd9, 0xff, 0xd3, 0x03, 0xda, 0xff, 0xe6, 0x03, 0xdb, 0xff, 0xca, 0x03, 0xdc, 0xff, 0xca, + 0x03, 0xdf, 0xff, 0xca, 0x03, 0xe1, 0xff, 0xd1, 0x03, 0xe7, 0xff, 0xd1, 0x03, 0xea, 0xff, 0xd4, 0x03, 0xeb, 0xff, + 0xe6, 0x03, 0xf2, 0xff, 0xd3, 0x03, 0xf3, 0xff, 0xe6, 0x03, 0xf5, 0xff, 0xf4, 0x03, 0xf6, 0xff, 0xef, 0x04, 0x03, + 0xff, 0xf4, 0x04, 0x04, 0xff, 0xef, 0x04, 0x08, 0xff, 0xd1, 0x04, 0x0a, 0xff, 0xd1, 0x04, 0x13, 0xff, 0xed, 0x04, + 0x14, 0xff, 0xe6, 0x04, 0x15, 0xff, 0xed, 0x04, 0x16, 0xff, 0xe6, 0x04, 0x17, 0xff, 0xed, 0x04, 0x18, 0xff, 0xe6, + 0x04, 0x19, 0xff, 0xe1, 0x04, 0x1c, 0xff, 0xd1, 0x04, 0x70, 0xff, 0xd3, 0x04, 0x71, 0xff, 0xe6, 0x04, 0x72, 0xff, + 0xd3, 0x04, 0x73, 0xff, 0xe6, 0x04, 0x74, 0xff, 0xd3, 0x04, 0x75, 0xff, 0xe6, 0x04, 0x77, 0xff, 0xd2, 0x04, 0x79, + 0xff, 0xe1, 0x04, 0x7c, 0xff, 0xd1, 0x04, 0x86, 0xff, 0xd3, 0x04, 0x98, 0xff, 0xd1, 0x04, 0xb5, 0xff, 0xd1, 0x04, + 0xb7, 0xff, 0xd1, 0x04, 0xbf, 0xff, 0xd2, 0x04, 0xc2, 0xff, 0xd4, 0x04, 0xc3, 0xff, 0xe6, 0x04, 0xc4, 0xff, 0xd4, + 0x04, 0xc5, 0xff, 0xe6, 0x00, 0x28, 0x00, 0x38, 0xff, 0xbe, 0x00, 0x5a, 0xff, 0xef, 0x00, 0x5d, 0xff, 0xef, 0x00, + 0xbd, 0xff, 0xef, 0x00, 0xd2, 0xff, 0xbe, 0x00, 0xd6, 0xff, 0xbe, 0x00, 0xe6, 0xff, 0xc9, 0x00, 0xf6, 0xff, 0xdf, + 0x01, 0x09, 0xff, 0xed, 0x01, 0x1a, 0xff, 0xef, 0x01, 0x20, 0xff, 0xeb, 0x01, 0x39, 0xff, 0xbe, 0x01, 0x3a, 0xff, + 0xdf, 0x01, 0x45, 0xff, 0xbe, 0x01, 0x4c, 0xff, 0xe9, 0x01, 0x63, 0xff, 0xf5, 0x01, 0x6d, 0xff, 0xe0, 0x02, 0xb4, + 0xff, 0xef, 0x02, 0xb5, 0xff, 0xef, 0x03, 0x0e, 0xff, 0xbe, 0x03, 0x10, 0xff, 0xbe, 0x03, 0x12, 0xff, 0xbe, 0x03, + 0x23, 0xff, 0xef, 0x03, 0xa6, 0xff, 0xef, 0x03, 0xc1, 0xff, 0xbe, 0x03, 0xc9, 0xff, 0xef, 0x03, 0xd2, 0xff, 0xef, + 0x03, 0xda, 0xff, 0xef, 0x03, 0xeb, 0xff, 0xef, 0x03, 0xf3, 0xff, 0xef, 0x04, 0x14, 0xff, 0xef, 0x04, 0x16, 0xff, + 0xef, 0x04, 0x18, 0xff, 0xef, 0x04, 0x71, 0xff, 0xef, 0x04, 0x73, 0xff, 0xef, 0x04, 0x75, 0xff, 0xef, 0x04, 0x77, + 0xff, 0xbe, 0x04, 0xbf, 0xff, 0xbe, 0x04, 0xc3, 0xff, 0xef, 0x04, 0xc5, 0xff, 0xef, 0x00, 0x3f, 0x00, 0x38, 0xff, + 0xe6, 0x00, 0x3a, 0xff, 0xe7, 0x00, 0x3c, 0xff, 0xf2, 0x00, 0x3d, 0xff, 0xe7, 0x00, 0x5c, 0xff, 0xf1, 0x00, 0xd2, + 0xff, 0xe6, 0x00, 0xd6, 0xff, 0xe6, 0x00, 0xda, 0xff, 0xf2, 0x00, 0xde, 0xff, 0xee, 0x00, 0xe1, 0xff, 0xe8, 0x00, + 0xe6, 0xff, 0xe6, 0x00, 0xee, 0xff, 0xf1, 0x00, 0xf6, 0xff, 0xd0, 0x01, 0x19, 0xff, 0xe7, 0x01, 0x33, 0xff, 0xf2, + 0x01, 0x34, 0xff, 0xf1, 0x01, 0x39, 0xff, 0xe6, 0x01, 0x3a, 0xff, 0xce, 0x01, 0x43, 0xff, 0xf2, 0x01, 0x44, 0xff, + 0xf1, 0x01, 0x45, 0xff, 0xe6, 0x01, 0x47, 0xff, 0xe8, 0x01, 0x49, 0xff, 0xe8, 0x01, 0x5d, 0xff, 0xf2, 0x01, 0x5e, + 0xff, 0xf1, 0x01, 0x62, 0xff, 0xe7, 0x01, 0x64, 0xff, 0xed, 0x01, 0x6c, 0xff, 0xe6, 0x01, 0x6d, 0xff, 0xd0, 0x02, + 0x99, 0xff, 0xe7, 0x03, 0x0e, 0xff, 0xe6, 0x03, 0x10, 0xff, 0xe6, 0x03, 0x12, 0xff, 0xe6, 0x03, 0x22, 0xff, 0xe7, + 0x03, 0x24, 0xff, 0xe7, 0x03, 0x8b, 0xff, 0xe7, 0x03, 0x9a, 0xff, 0xe7, 0x03, 0x9b, 0xff, 0xf2, 0x03, 0x9d, 0xff, + 0xe7, 0x03, 0xb5, 0xff, 0xee, 0x03, 0xc1, 0xff, 0xe6, 0x03, 0xc2, 0xff, 0xf2, 0x03, 0xca, 0xff, 0xf1, 0x03, 0xd9, + 0xff, 0xe7, 0x03, 0xea, 0xff, 0xe7, 0x03, 0xf2, 0xff, 0xe7, 0x03, 0xf5, 0xff, 0xf2, 0x03, 0xf6, 0xff, 0xf1, 0x04, + 0x03, 0xff, 0xf2, 0x04, 0x04, 0xff, 0xf1, 0x04, 0x13, 0xff, 0xee, 0x04, 0x15, 0xff, 0xee, 0x04, 0x17, 0xff, 0xee, + 0x04, 0x19, 0xff, 0xe8, 0x04, 0x70, 0xff, 0xe7, 0x04, 0x72, 0xff, 0xe7, 0x04, 0x74, 0xff, 0xe7, 0x04, 0x77, 0xff, + 0xe6, 0x04, 0x79, 0xff, 0xe8, 0x04, 0x86, 0xff, 0xe7, 0x04, 0xbf, 0xff, 0xe6, 0x04, 0xc2, 0xff, 0xe7, 0x04, 0xc4, + 0xff, 0xe7, 0x00, 0x98, 0x00, 0x25, 0x00, 0x10, 0x00, 0x27, 0xff, 0xe8, 0x00, 0x2b, 0xff, 0xe8, 0x00, 0x33, 0xff, + 0xe8, 0x00, 0x35, 0xff, 0xe8, 0x00, 0x38, 0xff, 0xe0, 0x00, 0x3a, 0xff, 0xe0, 0x00, 0x3d, 0xff, 0xdf, 0x00, 0x83, + 0xff, 0xe8, 0x00, 0x93, 0xff, 0xe8, 0x00, 0x98, 0xff, 0xe8, 0x00, 0xb2, 0x00, 0x10, 0x00, 0xb3, 0xff, 0xe8, 0x00, + 0xb4, 0x00, 0x10, 0x00, 0xd2, 0xff, 0xe0, 0x00, 0xd3, 0xff, 0xe8, 0x00, 0xd4, 0x00, 0x10, 0x00, 0xd6, 0xff, 0xe0, + 0x00, 0xd9, 0x00, 0x14, 0x00, 0xdd, 0x00, 0x10, 0x00, 0xe1, 0xff, 0xe1, 0x00, 0xe6, 0xff, 0xe0, 0x00, 0xed, 0x00, + 0x13, 0x00, 0xf2, 0x00, 0x10, 0x00, 0xf9, 0xff, 0xe0, 0x01, 0x04, 0x00, 0x10, 0x01, 0x08, 0xff, 0xe8, 0x01, 0x0d, + 0x00, 0x10, 0x01, 0x17, 0xff, 0xe8, 0x01, 0x19, 0xff, 0xe0, 0x01, 0x1b, 0xff, 0xe8, 0x01, 0x1d, 0xff, 0xe8, 0x01, + 0x1f, 0xff, 0xe8, 0x01, 0x21, 0xff, 0xe8, 0x01, 0x39, 0xff, 0xe0, 0x01, 0x41, 0xff, 0xe8, 0x01, 0x45, 0xff, 0xe0, + 0x01, 0x47, 0xff, 0xe1, 0x01, 0x48, 0xff, 0xe0, 0x01, 0x49, 0xff, 0xe1, 0x01, 0x4a, 0xff, 0xe0, 0x01, 0x4d, 0xff, + 0xe1, 0x01, 0x50, 0x00, 0x10, 0x01, 0x51, 0x00, 0x10, 0x01, 0x58, 0xff, 0xe9, 0x01, 0x62, 0xff, 0xdf, 0x01, 0x64, + 0xff, 0xde, 0x01, 0x66, 0x00, 0x10, 0x01, 0x6a, 0xff, 0xe8, 0x01, 0x6c, 0xff, 0xdf, 0x01, 0x6e, 0xff, 0xf2, 0x01, + 0x6f, 0x00, 0x10, 0x01, 0x70, 0x00, 0x10, 0x02, 0x45, 0xff, 0xe8, 0x02, 0x46, 0xff, 0xe8, 0x02, 0x48, 0xff, 0xe8, + 0x02, 0x49, 0xff, 0xe8, 0x02, 0x7f, 0x00, 0x10, 0x02, 0x80, 0x00, 0x10, 0x02, 0x81, 0x00, 0x10, 0x02, 0x82, 0x00, + 0x10, 0x02, 0x83, 0x00, 0x10, 0x02, 0x84, 0x00, 0x10, 0x02, 0x85, 0x00, 0x10, 0x02, 0x86, 0xff, 0xe8, 0x02, 0x90, + 0xff, 0xe8, 0x02, 0x91, 0xff, 0xe8, 0x02, 0x92, 0xff, 0xe8, 0x02, 0x93, 0xff, 0xe8, 0x02, 0x94, 0xff, 0xe8, 0x02, + 0x99, 0xff, 0xdf, 0x02, 0xb6, 0x00, 0x10, 0x02, 0xb8, 0x00, 0x10, 0x02, 0xba, 0x00, 0x10, 0x02, 0xbc, 0xff, 0xe8, + 0x02, 0xbe, 0xff, 0xe8, 0x02, 0xc0, 0xff, 0xe8, 0x02, 0xc2, 0xff, 0xe8, 0x02, 0xd0, 0xff, 0xe8, 0x02, 0xd2, 0xff, + 0xe8, 0x02, 0xd4, 0xff, 0xe8, 0x02, 0xd6, 0xff, 0xe8, 0x02, 0xf8, 0xff, 0xe8, 0x02, 0xfa, 0xff, 0xe8, 0x02, 0xfc, + 0xff, 0xe8, 0x03, 0x0e, 0xff, 0xe0, 0x03, 0x10, 0xff, 0xe0, 0x03, 0x12, 0xff, 0xe0, 0x03, 0x22, 0xff, 0xdf, 0x03, + 0x24, 0xff, 0xdf, 0x03, 0x2d, 0xff, 0xe8, 0x03, 0x86, 0x00, 0x10, 0x03, 0x8a, 0xff, 0xe8, 0x03, 0x8b, 0xff, 0xdf, + 0x03, 0x8e, 0x00, 0x10, 0x03, 0x97, 0xff, 0xe8, 0x03, 0x9a, 0xff, 0xdf, 0x03, 0x9d, 0xff, 0xdf, 0x03, 0xb6, 0x00, + 0x10, 0x03, 0xbd, 0xff, 0xe8, 0x03, 0xc0, 0xff, 0xe8, 0x03, 0xc1, 0xff, 0xe0, 0x03, 0xd9, 0xff, 0xdf, 0x03, 0xe2, + 0x00, 0x10, 0x03, 0xea, 0xff, 0xe0, 0x03, 0xed, 0xff, 0xe8, 0x03, 0xf0, 0xff, 0xe8, 0x03, 0xf2, 0xff, 0xdf, 0x03, + 0xf8, 0x00, 0x10, 0x03, 0xfa, 0x00, 0x10, 0x04, 0x0b, 0xff, 0xe8, 0x04, 0x0d, 0xff, 0xe8, 0x04, 0x0f, 0xff, 0xe8, + 0x04, 0x19, 0xff, 0xe1, 0x04, 0x1a, 0xff, 0xe0, 0x04, 0x1e, 0x00, 0x10, 0x04, 0x20, 0x00, 0x10, 0x04, 0x22, 0x00, + 0x10, 0x04, 0x24, 0x00, 0x10, 0x04, 0x26, 0x00, 0x10, 0x04, 0x28, 0x00, 0x10, 0x04, 0x2a, 0x00, 0x10, 0x04, 0x2c, + 0x00, 0x10, 0x04, 0x2e, 0x00, 0x10, 0x04, 0x30, 0x00, 0x10, 0x04, 0x32, 0x00, 0x10, 0x04, 0x34, 0x00, 0x10, 0x04, + 0x4a, 0xff, 0xe8, 0x04, 0x4c, 0xff, 0xe8, 0x04, 0x4e, 0xff, 0xe8, 0x04, 0x50, 0xff, 0xe8, 0x04, 0x52, 0xff, 0xe8, + 0x04, 0x54, 0xff, 0xe8, 0x04, 0x56, 0xff, 0xe8, 0x04, 0x58, 0xff, 0xe8, 0x04, 0x5a, 0xff, 0xe8, 0x04, 0x5c, 0xff, + 0xe8, 0x04, 0x5e, 0xff, 0xe8, 0x04, 0x60, 0xff, 0xe8, 0x04, 0x70, 0xff, 0xdf, 0x04, 0x72, 0xff, 0xdf, 0x04, 0x74, + 0xff, 0xdf, 0x04, 0x77, 0xff, 0xe0, 0x04, 0x79, 0xff, 0xe1, 0x04, 0x7a, 0xff, 0xe0, 0x04, 0x86, 0xff, 0xdf, 0x04, + 0x99, 0x00, 0x10, 0x04, 0x9f, 0xff, 0xe8, 0x04, 0xb8, 0xff, 0xe8, 0x04, 0xbf, 0xff, 0xe0, 0x04, 0xc2, 0xff, 0xe0, + 0x04, 0xc4, 0xff, 0xe0, 0x00, 0x35, 0x00, 0x1b, 0xff, 0xf2, 0x00, 0x38, 0xff, 0xf1, 0x00, 0x3a, 0xff, 0xf4, 0x00, + 0x3c, 0xff, 0xf4, 0x00, 0x3d, 0xff, 0xf0, 0x00, 0xd2, 0xff, 0xf1, 0x00, 0xd4, 0xff, 0xf5, 0x00, 0xd6, 0xff, 0xf1, + 0x00, 0xda, 0xff, 0xf4, 0x00, 0xdd, 0xff, 0xf5, 0x00, 0xde, 0xff, 0xf3, 0x00, 0xe6, 0xff, 0xf1, 0x01, 0x19, 0xff, + 0xf4, 0x01, 0x33, 0xff, 0xf4, 0x01, 0x39, 0xff, 0xf1, 0x01, 0x43, 0xff, 0xf4, 0x01, 0x45, 0xff, 0xf1, 0x01, 0x50, + 0xff, 0xf5, 0x01, 0x5d, 0xff, 0xf4, 0x01, 0x62, 0xff, 0xf2, 0x01, 0x64, 0xff, 0xf2, 0x01, 0x66, 0xff, 0xf5, 0x01, + 0x6c, 0xff, 0xf2, 0x01, 0x6f, 0xff, 0xf5, 0x02, 0x99, 0xff, 0xf0, 0x03, 0x0e, 0xff, 0xf1, 0x03, 0x10, 0xff, 0xf1, + 0x03, 0x12, 0xff, 0xf1, 0x03, 0x22, 0xff, 0xf0, 0x03, 0x24, 0xff, 0xf0, 0x03, 0x8b, 0xff, 0xf0, 0x03, 0x9a, 0xff, + 0xf0, 0x03, 0x9b, 0xff, 0xf4, 0x03, 0x9d, 0xff, 0xf0, 0x03, 0xb5, 0xff, 0xf3, 0x03, 0xc1, 0xff, 0xf1, 0x03, 0xc2, + 0xff, 0xf4, 0x03, 0xd9, 0xff, 0xf0, 0x03, 0xea, 0xff, 0xf4, 0x03, 0xf2, 0xff, 0xf0, 0x03, 0xf5, 0xff, 0xf4, 0x04, + 0x03, 0xff, 0xf4, 0x04, 0x13, 0xff, 0xf3, 0x04, 0x15, 0xff, 0xf3, 0x04, 0x17, 0xff, 0xf3, 0x04, 0x70, 0xff, 0xf0, + 0x04, 0x72, 0xff, 0xf0, 0x04, 0x74, 0xff, 0xf0, 0x04, 0x77, 0xff, 0xf1, 0x04, 0x86, 0xff, 0xf0, 0x04, 0xbf, 0xff, + 0xf1, 0x04, 0xc2, 0xff, 0xf4, 0x04, 0xc4, 0xff, 0xf4, 0x00, 0x6a, 0x00, 0x25, 0x00, 0x0f, 0x00, 0x38, 0xff, 0xe6, + 0x00, 0x3a, 0xff, 0xe6, 0x00, 0x3c, 0x00, 0x0e, 0x00, 0x3d, 0xff, 0xe6, 0x00, 0xb2, 0x00, 0x0f, 0x00, 0xb4, 0x00, + 0x0f, 0x00, 0xd2, 0xff, 0xe6, 0x00, 0xd4, 0x00, 0x0e, 0x00, 0xd6, 0xff, 0xe6, 0x00, 0xd9, 0x00, 0x13, 0x00, 0xda, + 0x00, 0x0e, 0x00, 0xdd, 0x00, 0x0e, 0x00, 0xde, 0x00, 0x0b, 0x00, 0xe1, 0xff, 0xe5, 0x00, 0xe6, 0xff, 0xe6, 0x00, + 0xe7, 0xff, 0xf4, 0x00, 0xed, 0x00, 0x12, 0x00, 0xf2, 0x00, 0x0f, 0x00, 0xf6, 0xff, 0xe7, 0x00, 0xf9, 0xff, 0xe8, + 0x01, 0x04, 0x00, 0x0f, 0x01, 0x0d, 0x00, 0x0f, 0x01, 0x19, 0xff, 0xe6, 0x01, 0x33, 0x00, 0x0e, 0x01, 0x39, 0xff, + 0xe6, 0x01, 0x3a, 0xff, 0xe7, 0x01, 0x43, 0x00, 0x0e, 0x01, 0x45, 0xff, 0xe6, 0x01, 0x47, 0xff, 0xe5, 0x01, 0x48, + 0xff, 0xe8, 0x01, 0x49, 0xff, 0xe5, 0x01, 0x4a, 0xff, 0xe8, 0x01, 0x4c, 0xff, 0xe4, 0x01, 0x50, 0x00, 0x0e, 0x01, + 0x51, 0x00, 0x0f, 0x01, 0x5d, 0x00, 0x0e, 0x01, 0x62, 0xff, 0xe6, 0x01, 0x64, 0xff, 0xe6, 0x01, 0x66, 0x00, 0x0e, + 0x01, 0x6c, 0xff, 0xe6, 0x01, 0x6d, 0xff, 0xe7, 0x01, 0x6f, 0x00, 0x0e, 0x01, 0x70, 0x00, 0x0f, 0x02, 0x7f, 0x00, + 0x0f, 0x02, 0x80, 0x00, 0x0f, 0x02, 0x81, 0x00, 0x0f, 0x02, 0x82, 0x00, 0x0f, 0x02, 0x83, 0x00, 0x0f, 0x02, 0x84, + 0x00, 0x0f, 0x02, 0x85, 0x00, 0x0f, 0x02, 0x99, 0xff, 0xe6, 0x02, 0xb6, 0x00, 0x0f, 0x02, 0xb8, 0x00, 0x0f, 0x02, + 0xba, 0x00, 0x0f, 0x03, 0x0e, 0xff, 0xe6, 0x03, 0x10, 0xff, 0xe6, 0x03, 0x12, 0xff, 0xe6, 0x03, 0x22, 0xff, 0xe6, + 0x03, 0x24, 0xff, 0xe6, 0x03, 0x86, 0x00, 0x0f, 0x03, 0x8b, 0xff, 0xe6, 0x03, 0x8e, 0x00, 0x0f, 0x03, 0x9a, 0xff, + 0xe6, 0x03, 0x9b, 0x00, 0x0e, 0x03, 0x9d, 0xff, 0xe6, 0x03, 0xb5, 0x00, 0x0b, 0x03, 0xb6, 0x00, 0x0f, 0x03, 0xc1, + 0xff, 0xe6, 0x03, 0xc2, 0x00, 0x0e, 0x03, 0xd9, 0xff, 0xe6, 0x03, 0xe2, 0x00, 0x0f, 0x03, 0xea, 0xff, 0xe6, 0x03, + 0xf2, 0xff, 0xe6, 0x03, 0xf5, 0x00, 0x0e, 0x03, 0xf8, 0x00, 0x0f, 0x03, 0xfa, 0x00, 0x0f, 0x04, 0x03, 0x00, 0x0e, + 0x04, 0x13, 0x00, 0x0b, 0x04, 0x15, 0x00, 0x0b, 0x04, 0x17, 0x00, 0x0b, 0x04, 0x19, 0xff, 0xe5, 0x04, 0x1a, 0xff, + 0xe8, 0x04, 0x1e, 0x00, 0x0f, 0x04, 0x20, 0x00, 0x0f, 0x04, 0x22, 0x00, 0x0f, 0x04, 0x24, 0x00, 0x0f, 0x04, 0x26, + 0x00, 0x0f, 0x04, 0x28, 0x00, 0x0f, 0x04, 0x2a, 0x00, 0x0f, 0x04, 0x2c, 0x00, 0x0f, 0x04, 0x2e, 0x00, 0x0f, 0x04, + 0x30, 0x00, 0x0f, 0x04, 0x32, 0x00, 0x0f, 0x04, 0x34, 0x00, 0x0f, 0x04, 0x70, 0xff, 0xe6, 0x04, 0x72, 0xff, 0xe6, + 0x04, 0x74, 0xff, 0xe6, 0x04, 0x77, 0xff, 0xe6, 0x04, 0x79, 0xff, 0xe5, 0x04, 0x7a, 0xff, 0xe8, 0x04, 0x86, 0xff, + 0xe6, 0x04, 0x99, 0x00, 0x0f, 0x04, 0xbf, 0xff, 0xe6, 0x04, 0xc2, 0xff, 0xe6, 0x04, 0xc4, 0xff, 0xe6, 0x00, 0x31, + 0x00, 0x38, 0xff, 0xe3, 0x00, 0x3c, 0xff, 0xe5, 0x00, 0x3d, 0xff, 0xe4, 0x00, 0xd2, 0xff, 0xe3, 0x00, 0xd4, 0xff, + 0xe5, 0x00, 0xd6, 0xff, 0xe3, 0x00, 0xd9, 0xff, 0xe2, 0x00, 0xda, 0xff, 0xe5, 0x00, 0xdd, 0xff, 0xe5, 0x00, 0xde, + 0xff, 0xe9, 0x00, 0xf2, 0xff, 0xea, 0x01, 0x04, 0xff, 0xea, 0x01, 0x33, 0xff, 0xe5, 0x01, 0x39, 0xff, 0xe3, 0x01, + 0x43, 0xff, 0xe5, 0x01, 0x45, 0xff, 0xe3, 0x01, 0x50, 0xff, 0xe5, 0x01, 0x51, 0xff, 0xea, 0x01, 0x5d, 0xff, 0xe5, + 0x01, 0x66, 0xff, 0xe5, 0x01, 0x6c, 0xff, 0xe4, 0x01, 0x6f, 0xff, 0xe5, 0x01, 0x70, 0xff, 0xea, 0x02, 0x99, 0xff, + 0xe4, 0x03, 0x0e, 0xff, 0xe3, 0x03, 0x10, 0xff, 0xe3, 0x03, 0x12, 0xff, 0xe3, 0x03, 0x22, 0xff, 0xe4, 0x03, 0x24, + 0xff, 0xe4, 0x03, 0x8b, 0xff, 0xe4, 0x03, 0x9a, 0xff, 0xe4, 0x03, 0x9b, 0xff, 0xe5, 0x03, 0x9d, 0xff, 0xe4, 0x03, + 0xb5, 0xff, 0xe9, 0x03, 0xc1, 0xff, 0xe3, 0x03, 0xc2, 0xff, 0xe5, 0x03, 0xd9, 0xff, 0xe4, 0x03, 0xf2, 0xff, 0xe4, + 0x03, 0xf5, 0xff, 0xe5, 0x04, 0x03, 0xff, 0xe5, 0x04, 0x13, 0xff, 0xe9, 0x04, 0x15, 0xff, 0xe9, 0x04, 0x17, 0xff, + 0xe9, 0x04, 0x70, 0xff, 0xe4, 0x04, 0x72, 0xff, 0xe4, 0x04, 0x74, 0xff, 0xe4, 0x04, 0x77, 0xff, 0xe3, 0x04, 0x86, + 0xff, 0xe4, 0x04, 0xbf, 0xff, 0xe3, 0x00, 0x24, 0x00, 0x38, 0xff, 0xe2, 0x00, 0x3c, 0xff, 0xe4, 0x00, 0xd2, 0xff, + 0xe2, 0x00, 0xd4, 0xff, 0xe4, 0x00, 0xd6, 0xff, 0xe2, 0x00, 0xd9, 0xff, 0xe1, 0x00, 0xda, 0xff, 0xe4, 0x00, 0xdd, + 0xff, 0xe4, 0x00, 0xde, 0xff, 0xe9, 0x00, 0xed, 0xff, 0xe4, 0x00, 0xf2, 0xff, 0xeb, 0x01, 0x04, 0xff, 0xeb, 0x01, + 0x33, 0xff, 0xe4, 0x01, 0x39, 0xff, 0xe2, 0x01, 0x43, 0xff, 0xe4, 0x01, 0x45, 0xff, 0xe2, 0x01, 0x50, 0xff, 0xe4, + 0x01, 0x51, 0xff, 0xeb, 0x01, 0x5d, 0xff, 0xe4, 0x01, 0x66, 0xff, 0xe4, 0x01, 0x6f, 0xff, 0xe4, 0x01, 0x70, 0xff, + 0xeb, 0x03, 0x0e, 0xff, 0xe2, 0x03, 0x10, 0xff, 0xe2, 0x03, 0x12, 0xff, 0xe2, 0x03, 0x9b, 0xff, 0xe4, 0x03, 0xb5, + 0xff, 0xe9, 0x03, 0xc1, 0xff, 0xe2, 0x03, 0xc2, 0xff, 0xe4, 0x03, 0xf5, 0xff, 0xe4, 0x04, 0x03, 0xff, 0xe4, 0x04, + 0x13, 0xff, 0xe9, 0x04, 0x15, 0xff, 0xe9, 0x04, 0x17, 0xff, 0xe9, 0x04, 0x77, 0xff, 0xe2, 0x04, 0xbf, 0xff, 0xe2, + 0x00, 0x18, 0x00, 0x38, 0xff, 0xeb, 0x00, 0x3d, 0xff, 0xf3, 0x00, 0xd2, 0xff, 0xeb, 0x00, 0xd6, 0xff, 0xeb, 0x01, + 0x39, 0xff, 0xeb, 0x01, 0x45, 0xff, 0xeb, 0x02, 0x99, 0xff, 0xf3, 0x03, 0x0e, 0xff, 0xeb, 0x03, 0x10, 0xff, 0xeb, + 0x03, 0x12, 0xff, 0xeb, 0x03, 0x22, 0xff, 0xf3, 0x03, 0x24, 0xff, 0xf3, 0x03, 0x8b, 0xff, 0xf3, 0x03, 0x9a, 0xff, + 0xf3, 0x03, 0x9d, 0xff, 0xf3, 0x03, 0xc1, 0xff, 0xeb, 0x03, 0xd9, 0xff, 0xf3, 0x03, 0xf2, 0xff, 0xf3, 0x04, 0x70, + 0xff, 0xf3, 0x04, 0x72, 0xff, 0xf3, 0x04, 0x74, 0xff, 0xf3, 0x04, 0x77, 0xff, 0xeb, 0x04, 0x86, 0xff, 0xf3, 0x04, + 0xbf, 0xff, 0xeb, 0x00, 0x39, 0x00, 0x51, 0xff, 0xef, 0x00, 0x52, 0xff, 0xef, 0x00, 0x54, 0xff, 0xef, 0x00, 0x5c, + 0xff, 0xf0, 0x00, 0xc1, 0xff, 0xef, 0x00, 0xec, 0xff, 0xef, 0x00, 0xed, 0xff, 0xee, 0x00, 0xee, 0xff, 0xf0, 0x00, + 0xf0, 0xff, 0xef, 0x00, 0xf1, 0xff, 0xef, 0x00, 0xf3, 0xff, 0xef, 0x00, 0xf4, 0xff, 0xef, 0x00, 0xf5, 0xff, 0xef, + 0x00, 0xf6, 0xff, 0xee, 0x00, 0xf8, 0xff, 0xef, 0x00, 0xfa, 0xff, 0xef, 0x00, 0xfb, 0xff, 0xef, 0x00, 0xfe, 0xff, + 0xef, 0x01, 0x00, 0xff, 0xef, 0x01, 0x05, 0xff, 0xef, 0x01, 0x09, 0xff, 0xf4, 0x01, 0x20, 0xff, 0xf1, 0x01, 0x2b, + 0xff, 0xef, 0x01, 0x34, 0xff, 0xf0, 0x01, 0x36, 0xff, 0xef, 0x01, 0x3a, 0xff, 0xef, 0x01, 0x3c, 0xff, 0xef, 0x01, + 0x3e, 0xff, 0xef, 0x01, 0x44, 0xff, 0xf0, 0x01, 0x53, 0xff, 0xef, 0x01, 0x55, 0xff, 0xef, 0x01, 0x57, 0xff, 0xef, + 0x01, 0x5c, 0xff, 0xef, 0x01, 0x5e, 0xff, 0xf0, 0x01, 0x6d, 0xff, 0xef, 0x02, 0xaa, 0xff, 0xef, 0x02, 0xf2, 0xff, + 0xef, 0x02, 0xf4, 0xff, 0xef, 0x02, 0xf6, 0xff, 0xef, 0x02, 0xf7, 0xff, 0xef, 0x03, 0xa0, 0xff, 0xef, 0x03, 0xc5, + 0xff, 0xef, 0x03, 0xc7, 0xff, 0xef, 0x03, 0xca, 0xff, 0xf0, 0x03, 0xcc, 0xff, 0xef, 0x03, 0xd1, 0xff, 0xef, 0x03, + 0xe1, 0xff, 0xef, 0x03, 0xe7, 0xff, 0xef, 0x03, 0xf6, 0xff, 0xf0, 0x04, 0x04, 0xff, 0xf0, 0x04, 0x08, 0xff, 0xef, + 0x04, 0x0a, 0xff, 0xef, 0x04, 0x1c, 0xff, 0xef, 0x04, 0x7c, 0xff, 0xef, 0x04, 0x98, 0xff, 0xef, 0x04, 0xb5, 0xff, + 0xef, 0x04, 0xb7, 0xff, 0xef, 0x00, 0x23, 0x00, 0x06, 0xff, 0xf2, 0x00, 0x0b, 0xff, 0xf2, 0x00, 0x5a, 0xff, 0xf5, + 0x00, 0x5d, 0xff, 0xf5, 0x00, 0xbd, 0xff, 0xf5, 0x00, 0xf6, 0xff, 0xf4, 0x01, 0x09, 0xff, 0xf5, 0x01, 0x1a, 0xff, + 0xf5, 0x01, 0x3a, 0xff, 0xf5, 0x01, 0x6d, 0xff, 0xf5, 0x01, 0x84, 0xff, 0xf2, 0x01, 0x85, 0xff, 0xf2, 0x01, 0x87, + 0xff, 0xf2, 0x01, 0x88, 0xff, 0xf2, 0x01, 0x89, 0xff, 0xf2, 0x02, 0xb4, 0xff, 0xf5, 0x02, 0xb5, 0xff, 0xf5, 0x03, + 0x23, 0xff, 0xf5, 0x03, 0xa6, 0xff, 0xf5, 0x03, 0xc9, 0xff, 0xf5, 0x03, 0xd2, 0xff, 0xf5, 0x03, 0xda, 0xff, 0xf5, + 0x03, 0xdb, 0xff, 0xf2, 0x03, 0xdc, 0xff, 0xf2, 0x03, 0xdf, 0xff, 0xf2, 0x03, 0xeb, 0xff, 0xf5, 0x03, 0xf3, 0xff, + 0xf5, 0x04, 0x14, 0xff, 0xf5, 0x04, 0x16, 0xff, 0xf5, 0x04, 0x18, 0xff, 0xf5, 0x04, 0x71, 0xff, 0xf5, 0x04, 0x73, + 0xff, 0xf5, 0x04, 0x75, 0xff, 0xf5, 0x04, 0xc3, 0xff, 0xf5, 0x04, 0xc5, 0xff, 0xf5, 0x00, 0x0a, 0x00, 0xed, 0x00, + 0x14, 0x00, 0xf6, 0xff, 0xed, 0x00, 0xf9, 0xff, 0xed, 0x00, 0xfc, 0xff, 0xe2, 0x01, 0x3a, 0xff, 0xed, 0x01, 0x48, + 0xff, 0xed, 0x01, 0x4a, 0xff, 0xed, 0x01, 0x6d, 0xff, 0xed, 0x04, 0x1a, 0xff, 0xed, 0x04, 0x7a, 0xff, 0xed, 0x00, + 0x76, 0x00, 0x47, 0xff, 0xf0, 0x00, 0x48, 0xff, 0xf0, 0x00, 0x49, 0xff, 0xf0, 0x00, 0x4b, 0xff, 0xf0, 0x00, 0x53, + 0xff, 0xeb, 0x00, 0x55, 0xff, 0xf0, 0x00, 0x94, 0xff, 0xf0, 0x00, 0x99, 0xff, 0xf0, 0x00, 0xbb, 0xff, 0xf0, 0x00, + 0xc8, 0xff, 0xf0, 0x00, 0xc9, 0xff, 0xf0, 0x00, 0xf7, 0xff, 0xf0, 0x01, 0x03, 0xff, 0xf0, 0x01, 0x18, 0xff, 0xeb, + 0x01, 0x1c, 0xff, 0xeb, 0x01, 0x1e, 0xff, 0xf0, 0x01, 0x22, 0xff, 0xf0, 0x01, 0x42, 0xff, 0xf0, 0x01, 0x60, 0xff, + 0xf0, 0x01, 0x61, 0xff, 0xf0, 0x01, 0x6b, 0xff, 0xf0, 0x01, 0xdb, 0xff, 0xeb, 0x01, 0xdd, 0xff, 0xeb, 0x01, 0xe5, + 0xff, 0xe9, 0x01, 0xec, 0xff, 0xeb, 0x01, 0xf5, 0xff, 0xeb, 0x02, 0x11, 0xff, 0xeb, 0x02, 0x1a, 0xff, 0xeb, 0x02, + 0x31, 0xff, 0xeb, 0x02, 0xa1, 0xff, 0xf0, 0x02, 0xa2, 0xff, 0xf0, 0x02, 0xa3, 0xff, 0xf0, 0x02, 0xa4, 0xff, 0xf0, + 0x02, 0xa5, 0xff, 0xf0, 0x02, 0xab, 0xff, 0xeb, 0x02, 0xac, 0xff, 0xeb, 0x02, 0xad, 0xff, 0xeb, 0x02, 0xae, 0xff, + 0xeb, 0x02, 0xaf, 0xff, 0xeb, 0x02, 0xbd, 0xff, 0xf0, 0x02, 0xbf, 0xff, 0xf0, 0x02, 0xc1, 0xff, 0xf0, 0x02, 0xc3, + 0xff, 0xf0, 0x02, 0xc5, 0xff, 0xf0, 0x02, 0xc7, 0xff, 0xf0, 0x02, 0xc9, 0xff, 0xf0, 0x02, 0xcb, 0xff, 0xf0, 0x02, + 0xcd, 0xff, 0xf0, 0x02, 0xcf, 0xff, 0xf0, 0x02, 0xd1, 0xff, 0xf0, 0x02, 0xd3, 0xff, 0xf0, 0x02, 0xd5, 0xff, 0xf0, + 0x02, 0xd7, 0xff, 0xf0, 0x02, 0xf9, 0xff, 0xeb, 0x02, 0xfb, 0xff, 0xeb, 0x02, 0xfd, 0xff, 0xeb, 0x03, 0x39, 0xff, + 0xeb, 0x03, 0x43, 0xff, 0xeb, 0x03, 0x44, 0xff, 0xeb, 0x03, 0x45, 0xff, 0xeb, 0x03, 0x46, 0xff, 0xeb, 0x03, 0x47, + 0xff, 0xeb, 0x03, 0x50, 0xff, 0xeb, 0x03, 0x51, 0xff, 0xeb, 0x03, 0x52, 0xff, 0xeb, 0x03, 0x53, 0xff, 0xeb, 0x03, + 0x5a, 0xff, 0xeb, 0x03, 0x5b, 0xff, 0xeb, 0x03, 0x5c, 0xff, 0xeb, 0x03, 0x5d, 0xff, 0xeb, 0x03, 0x6d, 0xff, 0xeb, + 0x03, 0x6e, 0xff, 0xeb, 0x03, 0x6f, 0xff, 0xeb, 0x03, 0x9e, 0xff, 0xf0, 0x03, 0xa4, 0xff, 0xeb, 0x03, 0xaa, 0xff, + 0xeb, 0x03, 0xc4, 0xff, 0xf0, 0x03, 0xc6, 0xff, 0xeb, 0x03, 0xc8, 0xff, 0xf0, 0x03, 0xcb, 0xff, 0xf0, 0x03, 0xe6, + 0xff, 0xf0, 0x03, 0xec, 0xff, 0xf0, 0x03, 0xf1, 0xff, 0xf0, 0x03, 0xff, 0xff, 0xf0, 0x04, 0x01, 0xff, 0xf0, 0x04, + 0x02, 0xff, 0xf0, 0x04, 0x0c, 0xff, 0xeb, 0x04, 0x0e, 0xff, 0xf0, 0x04, 0x10, 0xff, 0xeb, 0x04, 0x1d, 0xff, 0xf0, + 0x04, 0x37, 0xff, 0xf0, 0x04, 0x39, 0xff, 0xf0, 0x04, 0x3b, 0xff, 0xf0, 0x04, 0x3d, 0xff, 0xf0, 0x04, 0x3f, 0xff, + 0xf0, 0x04, 0x41, 0xff, 0xf0, 0x04, 0x43, 0xff, 0xf0, 0x04, 0x45, 0xff, 0xf0, 0x04, 0x4b, 0xff, 0xeb, 0x04, 0x4d, + 0xff, 0xeb, 0x04, 0x4f, 0xff, 0xeb, 0x04, 0x51, 0xff, 0xeb, 0x04, 0x53, 0xff, 0xeb, 0x04, 0x55, 0xff, 0xeb, 0x04, + 0x57, 0xff, 0xeb, 0x04, 0x59, 0xff, 0xf0, 0x04, 0x5b, 0xff, 0xf0, 0x04, 0x5d, 0xff, 0xf0, 0x04, 0x5f, 0xff, 0xeb, + 0x04, 0x61, 0xff, 0xf0, 0x04, 0x9c, 0xff, 0xf0, 0x04, 0xa0, 0xff, 0xeb, 0x04, 0xa9, 0xff, 0xf0, 0x04, 0xab, 0xff, + 0xf0, 0x04, 0xcf, 0xff, 0xeb, 0x04, 0xf1, 0xff, 0xeb, 0x04, 0xf4, 0xff, 0xeb, 0x04, 0xf9, 0xff, 0xeb, 0x00, 0xe3, + 0x00, 0x06, 0x00, 0x0d, 0x00, 0x0b, 0x00, 0x0d, 0x00, 0x45, 0xff, 0xf0, 0x00, 0x47, 0xff, 0xb0, 0x00, 0x48, 0xff, + 0xb0, 0x00, 0x49, 0xff, 0xb0, 0x00, 0x4a, 0x00, 0x0d, 0x00, 0x4b, 0xff, 0xb0, 0x00, 0x53, 0xff, 0xd6, 0x00, 0x55, + 0xff, 0xb0, 0x00, 0x5a, 0x00, 0x0b, 0x00, 0x5d, 0x00, 0x0b, 0x00, 0x94, 0xff, 0xb0, 0x00, 0x99, 0xff, 0xb0, 0x00, + 0xbb, 0xff, 0xb0, 0x00, 0xbd, 0x00, 0x0b, 0x00, 0xbe, 0xff, 0xb0, 0x00, 0xc7, 0xff, 0xab, 0x00, 0xc8, 0xff, 0xc0, + 0x00, 0xc9, 0xff, 0xb0, 0x00, 0xcc, 0xff, 0xd5, 0x00, 0xed, 0xff, 0xaa, 0x00, 0xf2, 0xff, 0xaf, 0x00, 0xf7, 0xff, + 0xb0, 0x01, 0x03, 0xff, 0xb0, 0x01, 0x04, 0xff, 0xaf, 0x01, 0x18, 0xff, 0xd6, 0x01, 0x1a, 0x00, 0x0b, 0x01, 0x1c, + 0xff, 0xe2, 0x01, 0x1e, 0xff, 0xb0, 0x01, 0x20, 0x00, 0x0c, 0x01, 0x22, 0xff, 0xb0, 0x01, 0x42, 0xff, 0xb0, 0x01, + 0x51, 0xff, 0xaf, 0x01, 0x60, 0xff, 0xb0, 0x01, 0x61, 0xff, 0xb0, 0x01, 0x63, 0x00, 0x0b, 0x01, 0x65, 0x00, 0x0b, + 0x01, 0x6b, 0xff, 0xb0, 0x01, 0x70, 0xff, 0xaf, 0x01, 0x84, 0x00, 0x0d, 0x01, 0x85, 0x00, 0x0d, 0x01, 0x87, 0x00, + 0x0d, 0x01, 0x88, 0x00, 0x0d, 0x01, 0x89, 0x00, 0x0d, 0x01, 0xd3, 0x00, 0x0d, 0x01, 0xd6, 0x00, 0x0d, 0x01, 0xd8, + 0x00, 0x0e, 0x01, 0xd9, 0xff, 0xf5, 0x01, 0xdb, 0xff, 0xec, 0x01, 0xdd, 0xff, 0xed, 0x01, 0xe5, 0xff, 0xec, 0x01, + 0xeb, 0xff, 0xbf, 0x01, 0xec, 0xff, 0xed, 0x01, 0xed, 0xff, 0xbf, 0x01, 0xf4, 0x00, 0x0e, 0x01, 0xf5, 0xff, 0xed, + 0x01, 0xf8, 0x00, 0x0e, 0x02, 0x10, 0x00, 0x0e, 0x02, 0x11, 0xff, 0xed, 0x02, 0x12, 0x00, 0x0d, 0x02, 0x14, 0x00, + 0x0e, 0x02, 0x1a, 0xff, 0xed, 0x02, 0x31, 0xff, 0xee, 0x02, 0x33, 0xff, 0xbf, 0x02, 0x9a, 0xff, 0xf0, 0x02, 0x9b, + 0xff, 0xf0, 0x02, 0x9c, 0xff, 0xf0, 0x02, 0x9d, 0xff, 0xf0, 0x02, 0x9e, 0xff, 0xf0, 0x02, 0x9f, 0xff, 0xf0, 0x02, + 0xa0, 0xff, 0xf0, 0x02, 0xa1, 0xff, 0xb0, 0x02, 0xa2, 0xff, 0xb0, 0x02, 0xa3, 0xff, 0xb0, 0x02, 0xa4, 0xff, 0xb0, + 0x02, 0xa5, 0xff, 0xb0, 0x02, 0xab, 0xff, 0xd6, 0x02, 0xac, 0xff, 0xd6, 0x02, 0xad, 0xff, 0xd6, 0x02, 0xae, 0xff, + 0xd6, 0x02, 0xaf, 0xff, 0xd6, 0x02, 0xb4, 0x00, 0x0b, 0x02, 0xb5, 0x00, 0x0b, 0x02, 0xb7, 0xff, 0xf0, 0x02, 0xb9, + 0xff, 0xf0, 0x02, 0xbb, 0xff, 0xf0, 0x02, 0xbd, 0xff, 0xb0, 0x02, 0xbf, 0xff, 0xb0, 0x02, 0xc1, 0xff, 0xb0, 0x02, + 0xc3, 0xff, 0xb0, 0x02, 0xc5, 0xff, 0xb0, 0x02, 0xc7, 0xff, 0xb0, 0x02, 0xc9, 0xff, 0xb0, 0x02, 0xcb, 0xff, 0xb0, + 0x02, 0xcd, 0xff, 0xb0, 0x02, 0xcf, 0xff, 0xb0, 0x02, 0xd1, 0xff, 0xb0, 0x02, 0xd3, 0xff, 0xb0, 0x02, 0xd5, 0xff, + 0xb0, 0x02, 0xd7, 0xff, 0xb0, 0x02, 0xf9, 0xff, 0xd6, 0x02, 0xfb, 0xff, 0xd6, 0x02, 0xfd, 0xff, 0xd6, 0x03, 0x23, + 0x00, 0x0b, 0x03, 0x32, 0xff, 0xbf, 0x03, 0x33, 0xff, 0xbf, 0x03, 0x34, 0xff, 0xbf, 0x03, 0x35, 0xff, 0xbf, 0x03, + 0x36, 0xff, 0xbf, 0x03, 0x37, 0xff, 0xbf, 0x03, 0x38, 0xff, 0xbf, 0x03, 0x39, 0xff, 0xed, 0x03, 0x43, 0xff, 0xed, + 0x03, 0x44, 0xff, 0xed, 0x03, 0x45, 0xff, 0xed, 0x03, 0x46, 0xff, 0xed, 0x03, 0x47, 0xff, 0xed, 0x03, 0x4c, 0x00, + 0x0d, 0x03, 0x4d, 0xff, 0xbf, 0x03, 0x4e, 0xff, 0xbf, 0x03, 0x4f, 0xff, 0xbf, 0x03, 0x50, 0xff, 0xed, 0x03, 0x51, + 0xff, 0xed, 0x03, 0x52, 0xff, 0xed, 0x03, 0x53, 0xff, 0xed, 0x03, 0x5a, 0xff, 0xed, 0x03, 0x5b, 0xff, 0xed, 0x03, + 0x5c, 0xff, 0xed, 0x03, 0x5d, 0xff, 0xed, 0x03, 0x6d, 0xff, 0xed, 0x03, 0x6e, 0xff, 0xed, 0x03, 0x6f, 0xff, 0xed, + 0x03, 0x73, 0xff, 0xf5, 0x03, 0x74, 0xff, 0xf5, 0x03, 0x75, 0xff, 0xf5, 0x03, 0x76, 0xff, 0xf5, 0x03, 0x78, 0x00, + 0x0e, 0x03, 0x81, 0x00, 0x0d, 0x03, 0x82, 0x00, 0x0d, 0x03, 0x9e, 0xff, 0xb0, 0x03, 0xa4, 0xff, 0xd6, 0x03, 0xa6, + 0x00, 0x0b, 0x03, 0xaa, 0xff, 0xd6, 0x03, 0xc3, 0xff, 0xf0, 0x03, 0xc4, 0xff, 0xb0, 0x03, 0xc6, 0xff, 0xd6, 0x03, + 0xc8, 0xff, 0xb0, 0x03, 0xc9, 0x00, 0x0b, 0x03, 0xcb, 0xff, 0xb0, 0x03, 0xd2, 0x00, 0x0b, 0x03, 0xda, 0x00, 0x0b, + 0x03, 0xdb, 0x00, 0x0d, 0x03, 0xdc, 0x00, 0x0d, 0x03, 0xdf, 0x00, 0x0d, 0x03, 0xe3, 0xff, 0xf0, 0x03, 0xe6, 0xff, + 0xb0, 0x03, 0xeb, 0x00, 0x0b, 0x03, 0xec, 0xff, 0xb0, 0x03, 0xf1, 0xff, 0xb0, 0x03, 0xf3, 0x00, 0x0b, 0x03, 0xf9, + 0xff, 0xf0, 0x03, 0xfb, 0xff, 0xf0, 0x03, 0xff, 0xff, 0xb0, 0x04, 0x01, 0xff, 0xb0, 0x04, 0x02, 0xff, 0xb0, 0x04, + 0x0c, 0xff, 0xd6, 0x04, 0x0e, 0xff, 0xb0, 0x04, 0x10, 0xff, 0xd6, 0x04, 0x14, 0x00, 0x0b, 0x04, 0x16, 0x00, 0x0b, + 0x04, 0x18, 0x00, 0x0b, 0x04, 0x1d, 0xff, 0xb0, 0x04, 0x1f, 0xff, 0xf0, 0x04, 0x21, 0xff, 0xf0, 0x04, 0x23, 0xff, + 0xf0, 0x04, 0x25, 0xff, 0xf0, 0x04, 0x27, 0xff, 0xf0, 0x04, 0x29, 0xff, 0xf0, 0x04, 0x2b, 0xff, 0xf0, 0x04, 0x2d, + 0xff, 0xf0, 0x04, 0x2f, 0xff, 0xf0, 0x04, 0x31, 0xff, 0xf0, 0x04, 0x33, 0xff, 0xf0, 0x04, 0x35, 0xff, 0xf0, 0x04, + 0x37, 0xff, 0xb0, 0x04, 0x39, 0xff, 0xb0, 0x04, 0x3b, 0xff, 0xb0, 0x04, 0x3d, 0xff, 0xb0, 0x04, 0x3f, 0xff, 0xb0, + 0x04, 0x41, 0xff, 0xb0, 0x04, 0x43, 0xff, 0xb0, 0x04, 0x45, 0xff, 0xb0, 0x04, 0x4b, 0xff, 0xd6, 0x04, 0x4d, 0xff, + 0xd6, 0x04, 0x4f, 0xff, 0xd6, 0x04, 0x51, 0xff, 0xd6, 0x04, 0x53, 0xff, 0xd6, 0x04, 0x55, 0xff, 0xd6, 0x04, 0x57, + 0xff, 0xd6, 0x04, 0x59, 0xff, 0xb0, 0x04, 0x5b, 0xff, 0xb0, 0x04, 0x5d, 0xff, 0xb0, 0x04, 0x5f, 0xff, 0xd6, 0x04, + 0x61, 0xff, 0xb0, 0x04, 0x71, 0x00, 0x0b, 0x04, 0x73, 0x00, 0x0b, 0x04, 0x75, 0x00, 0x0b, 0x04, 0x9a, 0xff, 0xf0, + 0x04, 0x9c, 0xff, 0xb0, 0x04, 0xa0, 0xff, 0xd6, 0x04, 0xa9, 0xff, 0xb0, 0x04, 0xab, 0xff, 0xb0, 0x04, 0xc3, 0x00, + 0x0b, 0x04, 0xc5, 0x00, 0x0b, 0x04, 0xcb, 0xff, 0xbf, 0x04, 0xcf, 0xff, 0xed, 0x04, 0xd0, 0x00, 0x0d, 0x04, 0xd2, + 0xff, 0xbf, 0x04, 0xde, 0x00, 0x0d, 0x04, 0xe1, 0x00, 0x0d, 0x04, 0xea, 0xff, 0xbf, 0x04, 0xf1, 0xff, 0xed, 0x04, + 0xf4, 0xff, 0xed, 0x04, 0xf5, 0x00, 0x0e, 0x04, 0xf9, 0xff, 0xed, 0x04, 0xfa, 0x00, 0x0d, 0x00, 0x0e, 0x00, 0xed, + 0x00, 0x14, 0x00, 0xf2, 0x00, 0x10, 0x00, 0xf6, 0xff, 0xf0, 0x00, 0xf9, 0xff, 0xf0, 0x01, 0x01, 0x00, 0x0c, 0x01, + 0x04, 0x00, 0x10, 0x01, 0x3a, 0xff, 0xf0, 0x01, 0x48, 0xff, 0xf0, 0x01, 0x4a, 0xff, 0xe6, 0x01, 0x51, 0x00, 0x10, + 0x01, 0x6d, 0xff, 0xf0, 0x01, 0x70, 0x00, 0x10, 0x04, 0x1a, 0xff, 0xf0, 0x04, 0x7a, 0xff, 0xf0, 0x00, 0x4d, 0x00, + 0x47, 0x00, 0x0c, 0x00, 0x48, 0x00, 0x0c, 0x00, 0x49, 0x00, 0x0c, 0x00, 0x4b, 0x00, 0x0c, 0x00, 0x55, 0x00, 0x0c, + 0x00, 0x94, 0x00, 0x0c, 0x00, 0x99, 0x00, 0x0c, 0x00, 0xbb, 0x00, 0x0c, 0x00, 0xc8, 0x00, 0x0c, 0x00, 0xc9, 0x00, + 0x0c, 0x00, 0xed, 0x00, 0x3a, 0x00, 0xf2, 0x00, 0x18, 0x00, 0xf6, 0xff, 0xe3, 0x00, 0xf7, 0x00, 0x0c, 0x00, 0xf9, + 0xff, 0xf7, 0x01, 0x03, 0x00, 0x0c, 0x01, 0x04, 0x00, 0x18, 0x01, 0x1e, 0x00, 0x0c, 0x01, 0x22, 0x00, 0x0c, 0x01, + 0x3a, 0xff, 0xe2, 0x01, 0x42, 0x00, 0x0c, 0x01, 0x48, 0xff, 0xf7, 0x01, 0x4a, 0xff, 0xe3, 0x01, 0x51, 0x00, 0x18, + 0x01, 0x60, 0x00, 0x0c, 0x01, 0x61, 0x00, 0x0c, 0x01, 0x6b, 0x00, 0x0c, 0x01, 0x6d, 0xff, 0xe3, 0x01, 0x70, 0x00, + 0x18, 0x02, 0xa1, 0x00, 0x0c, 0x02, 0xa2, 0x00, 0x0c, 0x02, 0xa3, 0x00, 0x0c, 0x02, 0xa4, 0x00, 0x0c, 0x02, 0xa5, + 0x00, 0x0c, 0x02, 0xbd, 0x00, 0x0c, 0x02, 0xbf, 0x00, 0x0c, 0x02, 0xc1, 0x00, 0x0c, 0x02, 0xc3, 0x00, 0x0c, 0x02, + 0xc5, 0x00, 0x0c, 0x02, 0xc7, 0x00, 0x0c, 0x02, 0xc9, 0x00, 0x0c, 0x02, 0xcb, 0x00, 0x0c, 0x02, 0xcd, 0x00, 0x0c, + 0x02, 0xcf, 0x00, 0x0c, 0x02, 0xd1, 0x00, 0x0c, 0x02, 0xd3, 0x00, 0x0c, 0x02, 0xd5, 0x00, 0x0c, 0x02, 0xd7, 0x00, + 0x0c, 0x03, 0x9e, 0x00, 0x0c, 0x03, 0xc4, 0x00, 0x0c, 0x03, 0xc8, 0x00, 0x0c, 0x03, 0xcb, 0x00, 0x0c, 0x03, 0xe6, + 0x00, 0x0c, 0x03, 0xec, 0x00, 0x0c, 0x03, 0xf1, 0x00, 0x0c, 0x03, 0xff, 0x00, 0x0c, 0x04, 0x01, 0x00, 0x0c, 0x04, + 0x02, 0x00, 0x0c, 0x04, 0x0e, 0x00, 0x0c, 0x04, 0x1a, 0xff, 0xf7, 0x04, 0x1d, 0x00, 0x0c, 0x04, 0x37, 0x00, 0x0c, + 0x04, 0x39, 0x00, 0x0c, 0x04, 0x3b, 0x00, 0x0c, 0x04, 0x3d, 0x00, 0x0c, 0x04, 0x3f, 0x00, 0x0c, 0x04, 0x41, 0x00, + 0x0c, 0x04, 0x43, 0x00, 0x0c, 0x04, 0x45, 0x00, 0x0c, 0x04, 0x59, 0x00, 0x0c, 0x04, 0x5b, 0x00, 0x0c, 0x04, 0x5d, + 0x00, 0x0c, 0x04, 0x61, 0x00, 0x0c, 0x04, 0x7a, 0xff, 0xf7, 0x04, 0x9c, 0x00, 0x0c, 0x04, 0xa9, 0x00, 0x0c, 0x04, + 0xab, 0x00, 0x0c, 0x00, 0x22, 0x00, 0x5a, 0xff, 0xf4, 0x00, 0x5c, 0xff, 0xf0, 0x00, 0x5d, 0xff, 0xf4, 0x00, 0xbd, + 0xff, 0xf4, 0x00, 0xed, 0xff, 0xef, 0x00, 0xee, 0xff, 0xf0, 0x00, 0xf2, 0xff, 0xf3, 0x01, 0x04, 0xff, 0xf3, 0x01, + 0x1a, 0xff, 0xf4, 0x01, 0x34, 0xff, 0xf0, 0x01, 0x44, 0xff, 0xf0, 0x01, 0x51, 0xff, 0xf3, 0x01, 0x5e, 0xff, 0xf0, + 0x01, 0x70, 0xff, 0xf3, 0x02, 0xb4, 0xff, 0xf4, 0x02, 0xb5, 0xff, 0xf4, 0x03, 0x23, 0xff, 0xf4, 0x03, 0xa6, 0xff, + 0xf4, 0x03, 0xc9, 0xff, 0xf4, 0x03, 0xca, 0xff, 0xf0, 0x03, 0xd2, 0xff, 0xf4, 0x03, 0xda, 0xff, 0xf4, 0x03, 0xeb, + 0xff, 0xf4, 0x03, 0xf3, 0xff, 0xf4, 0x03, 0xf6, 0xff, 0xf0, 0x04, 0x04, 0xff, 0xf0, 0x04, 0x14, 0xff, 0xf4, 0x04, + 0x16, 0xff, 0xf4, 0x04, 0x18, 0xff, 0xf4, 0x04, 0x71, 0xff, 0xf4, 0x04, 0x73, 0xff, 0xf4, 0x04, 0x75, 0xff, 0xf4, + 0x04, 0xc3, 0xff, 0xf4, 0x04, 0xc5, 0xff, 0xf4, 0x00, 0x0a, 0x00, 0x06, 0xff, 0xd6, 0x00, 0x0b, 0xff, 0xd6, 0x01, + 0x84, 0xff, 0xd6, 0x01, 0x85, 0xff, 0xd6, 0x01, 0x87, 0xff, 0xd6, 0x01, 0x88, 0xff, 0xd6, 0x01, 0x89, 0xff, 0xd6, + 0x03, 0xdb, 0xff, 0xd6, 0x03, 0xdc, 0xff, 0xd6, 0x03, 0xdf, 0xff, 0xd6, 0x00, 0x08, 0x00, 0xf6, 0xff, 0xba, 0x01, + 0x09, 0xff, 0xcf, 0x01, 0x20, 0xff, 0xdb, 0x01, 0x3a, 0xff, 0x50, 0x01, 0x4a, 0xff, 0x9d, 0x01, 0x63, 0xff, 0xf0, + 0x01, 0x65, 0xff, 0xf2, 0x01, 0x6d, 0xff, 0x4c, 0x00, 0x0a, 0x00, 0x06, 0xff, 0xf5, 0x00, 0x0b, 0xff, 0xf5, 0x01, + 0x84, 0xff, 0xf5, 0x01, 0x85, 0xff, 0xf5, 0x01, 0x87, 0xff, 0xf5, 0x01, 0x88, 0xff, 0xf5, 0x01, 0x89, 0xff, 0xf5, + 0x03, 0xdb, 0xff, 0xf5, 0x03, 0xdc, 0xff, 0xf5, 0x03, 0xdf, 0xff, 0xf5, 0x00, 0x28, 0x00, 0x4c, 0x00, 0x20, 0x00, + 0x4f, 0x00, 0x20, 0x00, 0x50, 0x00, 0x20, 0x00, 0x53, 0xff, 0x80, 0x00, 0x57, 0xff, 0x90, 0x00, 0x5b, 0x00, 0x0b, + 0x01, 0x18, 0xff, 0x80, 0x01, 0xc1, 0xff, 0x90, 0x02, 0xab, 0xff, 0x80, 0x02, 0xac, 0xff, 0x80, 0x02, 0xad, 0xff, + 0x80, 0x02, 0xae, 0xff, 0x80, 0x02, 0xaf, 0xff, 0x80, 0x02, 0xf9, 0xff, 0x80, 0x02, 0xfb, 0xff, 0x80, 0x02, 0xfd, + 0xff, 0x80, 0x03, 0x05, 0xff, 0x90, 0x03, 0x07, 0xff, 0x90, 0x03, 0x09, 0xff, 0x90, 0x03, 0x0b, 0xff, 0x90, 0x03, + 0x0d, 0xff, 0x90, 0x03, 0xa4, 0xff, 0x80, 0x03, 0xaa, 0xff, 0x80, 0x03, 0xc6, 0xff, 0x80, 0x03, 0xcd, 0xff, 0x90, + 0x04, 0x0c, 0xff, 0x80, 0x04, 0x10, 0xff, 0x80, 0x04, 0x4b, 0xff, 0x80, 0x04, 0x4d, 0xff, 0x80, 0x04, 0x4f, 0xff, + 0x80, 0x04, 0x51, 0xff, 0x80, 0x04, 0x53, 0xff, 0x80, 0x04, 0x55, 0xff, 0x80, 0x04, 0x57, 0xff, 0x80, 0x04, 0x5f, + 0xff, 0x80, 0x04, 0xa0, 0xff, 0x80, 0x04, 0xad, 0x00, 0x20, 0x04, 0xaf, 0x00, 0x20, 0x04, 0xb1, 0x00, 0x20, 0x04, + 0xbe, 0xff, 0x90, 0x00, 0x13, 0x01, 0xd3, 0xff, 0xee, 0x01, 0xd5, 0xff, 0xf5, 0x01, 0xd6, 0xff, 0xf1, 0x01, 0xd8, + 0xff, 0xf2, 0x01, 0xf4, 0xff, 0xf2, 0x01, 0xf8, 0xff, 0xf2, 0x02, 0x10, 0xff, 0xf2, 0x02, 0x12, 0xff, 0xee, 0x02, + 0x14, 0xff, 0xf2, 0x03, 0x4c, 0xff, 0xee, 0x03, 0x78, 0xff, 0xf2, 0x03, 0x80, 0xff, 0xf5, 0x03, 0x81, 0xff, 0xee, + 0x03, 0x82, 0xff, 0xee, 0x04, 0xd0, 0xff, 0xee, 0x04, 0xde, 0xff, 0xee, 0x04, 0xe1, 0xff, 0xee, 0x04, 0xf5, 0xff, + 0xf2, 0x04, 0xfa, 0xff, 0xee, 0x00, 0x13, 0x01, 0xd3, 0xff, 0xe5, 0x01, 0xd5, 0xff, 0xf1, 0x01, 0xd6, 0xff, 0xeb, + 0x01, 0xd8, 0xff, 0xe9, 0x01, 0xf4, 0xff, 0xe9, 0x01, 0xf8, 0xff, 0xe9, 0x02, 0x10, 0xff, 0xe9, 0x02, 0x12, 0xff, + 0xe5, 0x02, 0x14, 0xff, 0xe9, 0x03, 0x4c, 0xff, 0xe5, 0x03, 0x78, 0xff, 0xe9, 0x03, 0x80, 0xff, 0xf1, 0x03, 0x81, + 0xff, 0xe5, 0x03, 0x82, 0xff, 0xe5, 0x04, 0xd0, 0xff, 0xe5, 0x04, 0xde, 0xff, 0xe5, 0x04, 0xe1, 0xff, 0xe5, 0x04, + 0xf5, 0xff, 0xe9, 0x04, 0xfa, 0xff, 0xe5, 0x00, 0x03, 0x01, 0xd5, 0xff, 0xf5, 0x01, 0xd6, 0xff, 0xee, 0x03, 0x80, + 0xff, 0xf5, 0x00, 0x02, 0x01, 0xd6, 0xff, 0xb7, 0x01, 0xdb, 0xff, 0xf0, 0x00, 0x01, 0x00, 0x5b, 0x00, 0x0b, 0x00, + 0x04, 0x00, 0x0d, 0xff, 0xe6, 0x00, 0x41, 0xff, 0xf4, 0x00, 0x61, 0xff, 0xef, 0x01, 0x4d, 0xff, 0xed, 0x00, 0x17, + 0x00, 0xb8, 0xff, 0xd4, 0x00, 0xbe, 0xff, 0xf0, 0x00, 0xc2, 0xff, 0xed, 0x00, 0xc4, 0x00, 0x11, 0x00, 0xca, 0xff, + 0xe0, 0x00, 0xcc, 0xff, 0xe7, 0x00, 0xcd, 0xff, 0xe5, 0x00, 0xce, 0xff, 0xee, 0x00, 0xd9, 0x00, 0x12, 0x00, 0xea, + 0xff, 0xe9, 0x00, 0xf6, 0xff, 0xd7, 0x01, 0x3a, 0xff, 0xd7, 0x01, 0x4a, 0xff, 0xd3, 0x01, 0x4c, 0xff, 0xd6, 0x01, + 0x4d, 0xff, 0xc5, 0x01, 0x58, 0xff, 0xe7, 0x01, 0x62, 0x00, 0x0d, 0x01, 0x64, 0x00, 0x0c, 0x01, 0x6d, 0xff, 0xd6, + 0x01, 0x6e, 0xff, 0xf2, 0x01, 0xdb, 0xff, 0xe9, 0x01, 0xe5, 0xff, 0xe7, 0x02, 0x31, 0xff, 0xe9, 0x00, 0x01, 0x01, + 0x1c, 0xff, 0xf1, 0x00, 0x12, 0x00, 0xd9, 0xff, 0xae, 0x00, 0xe6, 0x00, 0x12, 0x00, 0xeb, 0xff, 0xe0, 0x00, 0xed, + 0xff, 0xad, 0x00, 0xef, 0xff, 0xd6, 0x00, 0xfd, 0xff, 0xdf, 0x01, 0x01, 0xff, 0xd2, 0x01, 0x07, 0xff, 0xe0, 0x01, + 0x1c, 0xff, 0xce, 0x01, 0x2e, 0xff, 0xdd, 0x01, 0x30, 0xff, 0xe2, 0x01, 0x38, 0xff, 0xe0, 0x01, 0x40, 0xff, 0xe0, + 0x01, 0x4a, 0xff, 0xe9, 0x01, 0x4d, 0xff, 0xda, 0x01, 0x5f, 0xff, 0xbd, 0x01, 0x69, 0xff, 0xdf, 0x01, 0x6c, 0x00, + 0x11, 0x00, 0x02, 0x00, 0xf6, 0xff, 0xf5, 0x01, 0x85, 0xff, 0xb0, 0x00, 0x02, 0x00, 0xed, 0xff, 0xc9, 0x01, 0x1c, + 0xff, 0xee, 0x00, 0x09, 0x00, 0xe6, 0xff, 0xc3, 0x00, 0xf6, 0xff, 0xcf, 0x01, 0x3a, 0xff, 0xce, 0x01, 0x49, 0xff, + 0xe7, 0x01, 0x4c, 0xff, 0xdf, 0x01, 0x62, 0xff, 0xd1, 0x01, 0x64, 0xff, 0xec, 0x01, 0x6c, 0xff, 0xa0, 0x01, 0x6d, + 0xff, 0xd1, 0x00, 0x2f, 0x00, 0x56, 0xff, 0x6d, 0x00, 0x5b, 0xff, 0x8c, 0x00, 0x6d, 0xfd, 0xbf, 0x00, 0x7c, 0xfe, + 0x7d, 0x00, 0x81, 0xfe, 0xbc, 0x00, 0x86, 0xff, 0x2b, 0x00, 0x89, 0xff, 0x4b, 0x00, 0xb8, 0xff, 0x61, 0x00, 0xbe, + 0xff, 0x8f, 0x00, 0xbf, 0xff, 0x0f, 0x00, 0xc3, 0xfe, 0xe8, 0x00, 0xc6, 0xff, 0x1f, 0x00, 0xc7, 0xfe, 0xe5, 0x00, + 0xca, 0xff, 0x46, 0x00, 0xcc, 0xfe, 0xed, 0x00, 0xcd, 0xfe, 0xfd, 0x00, 0xce, 0xfe, 0xd9, 0x00, 0xd9, 0xff, 0x52, + 0x00, 0xe6, 0x00, 0x05, 0x00, 0xea, 0xff, 0xbd, 0x00, 0xeb, 0xff, 0x49, 0x00, 0xed, 0xfe, 0xfe, 0x00, 0xef, 0xff, + 0x13, 0x00, 0xf6, 0xff, 0x68, 0x00, 0xfd, 0xff, 0x0e, 0x00, 0xff, 0xff, 0x13, 0x01, 0x01, 0xff, 0x07, 0x01, 0x07, + 0xff, 0x0e, 0x01, 0x09, 0xff, 0x11, 0x01, 0x1c, 0xff, 0x3c, 0x01, 0x20, 0xff, 0xac, 0x01, 0x2e, 0xff, 0x15, 0x01, + 0x30, 0xff, 0x3c, 0x01, 0x38, 0xff, 0x0e, 0x01, 0x3a, 0xff, 0x6a, 0x01, 0x40, 0xff, 0x49, 0x01, 0x4a, 0xff, 0x0c, + 0x01, 0x4c, 0xff, 0x3f, 0x01, 0x4d, 0xfe, 0xf1, 0x01, 0x58, 0xff, 0xc0, 0x01, 0x5f, 0xfe, 0xef, 0x01, 0x63, 0xff, + 0x31, 0x01, 0x65, 0xff, 0x5f, 0x01, 0x69, 0xff, 0x0a, 0x01, 0x6c, 0x00, 0x05, 0x01, 0x6d, 0xff, 0x30, 0x01, 0x6e, + 0xff, 0xd5, 0x00, 0x1e, 0x00, 0x0a, 0xff, 0xe2, 0x00, 0x0d, 0x00, 0x14, 0x00, 0x0e, 0xff, 0xcf, 0x00, 0x41, 0x00, + 0x12, 0x00, 0x4a, 0xff, 0xea, 0x00, 0x56, 0xff, 0xd8, 0x00, 0x58, 0xff, 0xea, 0x00, 0x61, 0x00, 0x13, 0x00, 0x6d, + 0xff, 0xae, 0x00, 0x7c, 0xff, 0xcd, 0x00, 0x81, 0xff, 0xa0, 0x00, 0x86, 0xff, 0xc1, 0x00, 0x89, 0xff, 0xc0, 0x00, + 0xb8, 0xff, 0xd0, 0x00, 0xbc, 0xff, 0xea, 0x00, 0xbe, 0xff, 0xee, 0x00, 0xbf, 0xff, 0xc6, 0x00, 0xc0, 0x00, 0x0d, + 0x00, 0xc2, 0xff, 0xe9, 0x00, 0xc3, 0xff, 0xd6, 0x00, 0xc6, 0xff, 0xe8, 0x00, 0xc7, 0xff, 0xba, 0x00, 0xca, 0xff, + 0xe9, 0x00, 0xcc, 0xff, 0xcb, 0x00, 0xcd, 0xff, 0xda, 0x00, 0xce, 0xff, 0xc7, 0x01, 0x8d, 0xff, 0xd3, 0x01, 0xdb, + 0xff, 0xcb, 0x01, 0xe5, 0xff, 0xcb, 0x02, 0x31, 0xff, 0xcd, 0x00, 0x17, 0x00, 0x23, 0xff, 0xc3, 0x00, 0x58, 0xff, + 0xef, 0x00, 0x5b, 0xff, 0xdf, 0x00, 0x9a, 0xff, 0xee, 0x00, 0xb8, 0xff, 0xe5, 0x00, 0xb9, 0xff, 0xd1, 0x00, 0xc4, + 0x00, 0x11, 0x00, 0xca, 0xff, 0xc8, 0x00, 0xd9, 0x00, 0x13, 0x00, 0xe6, 0xff, 0xc5, 0x00, 0xf6, 0xff, 0xca, 0x01, + 0x3a, 0xff, 0x9f, 0x01, 0x49, 0xff, 0x51, 0x01, 0x4a, 0xff, 0x7b, 0x01, 0x4c, 0xff, 0xca, 0x01, 0x4d, 0xff, 0xdd, + 0x01, 0x58, 0xff, 0xf2, 0x01, 0x62, 0xff, 0x75, 0x01, 0x64, 0xff, 0xca, 0x01, 0x6c, 0xff, 0x4f, 0x01, 0x6d, 0xff, + 0x8c, 0x01, 0xd6, 0xff, 0xcd, 0x01, 0xe5, 0xff, 0xf5, 0x00, 0x07, 0x00, 0xf6, 0xff, 0xf0, 0x01, 0x09, 0xff, 0xf1, + 0x01, 0x20, 0xff, 0xf3, 0x01, 0x3a, 0xff, 0xf1, 0x01, 0x63, 0xff, 0xf3, 0x01, 0x65, 0xff, 0xe9, 0x01, 0x6d, 0xff, + 0xd3, 0x00, 0x03, 0x00, 0x4a, 0xff, 0xee, 0x00, 0x5b, 0xff, 0xea, 0x01, 0xd6, 0xff, 0xf0, 0x00, 0x09, 0x00, 0xca, + 0xff, 0xea, 0x00, 0xed, 0xff, 0xb8, 0x00, 0xf6, 0xff, 0xea, 0x01, 0x09, 0xff, 0xf0, 0x01, 0x20, 0xff, 0xf1, 0x01, + 0x3a, 0xff, 0xeb, 0x01, 0x63, 0xff, 0xf5, 0x01, 0x6d, 0xff, 0xec, 0x01, 0x85, 0xff, 0xb0, 0x00, 0x02, 0x01, 0x11, + 0x00, 0x0b, 0x01, 0x6c, 0xff, 0xe6, 0x00, 0x12, 0x00, 0x5b, 0xff, 0xc1, 0x00, 0xb8, 0xff, 0xc5, 0x00, 0xca, 0xff, + 0xb4, 0x00, 0xea, 0xff, 0xd7, 0x00, 0xf6, 0xff, 0xb9, 0x01, 0x09, 0xff, 0xb2, 0x01, 0x1c, 0xff, 0xd2, 0x01, 0x20, + 0xff, 0xc8, 0x01, 0x3a, 0xff, 0xa0, 0x01, 0x4a, 0xff, 0xc5, 0x01, 0x58, 0xff, 0xe4, 0x01, 0x63, 0xff, 0xcc, 0x01, + 0x65, 0xff, 0xcc, 0x01, 0x6d, 0xff, 0xcb, 0x01, 0x6e, 0xff, 0xef, 0x01, 0xdb, 0xff, 0xe7, 0x01, 0xe5, 0xff, 0xe6, + 0x02, 0x31, 0xff, 0xe8, 0x00, 0x05, 0x00, 0x5b, 0xff, 0xa4, 0x01, 0xd6, 0xff, 0x54, 0x01, 0xdb, 0xff, 0xf1, 0x01, + 0xe5, 0xff, 0xf1, 0x02, 0x31, 0xff, 0xf3, 0x00, 0x08, 0x00, 0xd9, 0x00, 0x15, 0x00, 0xed, 0x00, 0x15, 0x01, 0x49, + 0xff, 0xe4, 0x01, 0x4a, 0xff, 0xe5, 0x01, 0x4c, 0xff, 0xe4, 0x01, 0x62, 0xff, 0xe3, 0x01, 0x64, 0xff, 0xe2, 0x01, + 0x6c, 0xff, 0xe4, 0x00, 0x02, 0x00, 0xf6, 0xff, 0xc0, 0x01, 0x85, 0xff, 0xb0, 0x00, 0x08, 0x00, 0x58, 0x00, 0x0e, + 0x00, 0x81, 0xff, 0x9f, 0x00, 0xbe, 0xff, 0xf5, 0x00, 0xc4, 0xff, 0xde, 0x00, 0xc7, 0xff, 0xe5, 0x00, 0xd9, 0xff, + 0xa8, 0x00, 0xed, 0xff, 0xca, 0x01, 0x5f, 0xff, 0xe3, 0x00, 0x05, 0x00, 0xca, 0xff, 0xea, 0x00, 0xed, 0xff, 0xee, + 0x00, 0xf6, 0xff, 0xb0, 0x01, 0x3a, 0xff, 0xec, 0x01, 0x6d, 0xff, 0xec, 0x00, 0x03, 0x00, 0x4a, 0x00, 0x0f, 0x00, + 0x58, 0x00, 0x32, 0x00, 0x5b, 0x00, 0x11, 0x00, 0x33, 0x00, 0x04, 0xff, 0xd8, 0x00, 0x56, 0xff, 0xb5, 0x00, 0x5b, + 0xff, 0xc7, 0x00, 0x6d, 0xfe, 0xb8, 0x00, 0x7c, 0xff, 0x28, 0x00, 0x81, 0xff, 0x4d, 0x00, 0x86, 0xff, 0x8e, 0x00, + 0x89, 0xff, 0xa1, 0x00, 0xb8, 0xff, 0xae, 0x00, 0xbe, 0xff, 0xc9, 0x00, 0xbf, 0xff, 0x7e, 0x00, 0xc3, 0xff, 0x67, + 0x00, 0xc6, 0xff, 0x87, 0x00, 0xc7, 0xff, 0x65, 0x00, 0xca, 0xff, 0x9e, 0x00, 0xcc, 0xff, 0x6a, 0x00, 0xcd, 0xff, + 0x73, 0x00, 0xce, 0xff, 0x5e, 0x00, 0xd9, 0xff, 0xa5, 0x00, 0xe6, 0x00, 0x0f, 0x00, 0xea, 0xff, 0xe4, 0x00, 0xeb, + 0xff, 0xa0, 0x00, 0xed, 0xff, 0x74, 0x00, 0xef, 0xff, 0x80, 0x00, 0xf6, 0xff, 0xb2, 0x00, 0xfd, 0xff, 0x7d, 0x00, + 0xff, 0xff, 0x80, 0x01, 0x01, 0xff, 0x79, 0x01, 0x07, 0xff, 0x7d, 0x01, 0x09, 0xff, 0x7f, 0x01, 0x1c, 0xff, 0x98, + 0x01, 0x20, 0xff, 0xda, 0x01, 0x2e, 0xff, 0x81, 0x01, 0x30, 0xff, 0x98, 0x01, 0x38, 0xff, 0x7d, 0x01, 0x3a, 0xff, + 0xb3, 0x01, 0x40, 0xff, 0xa0, 0x01, 0x4a, 0xff, 0x7c, 0x01, 0x4c, 0xff, 0x9a, 0x01, 0x4d, 0xff, 0x6c, 0x01, 0x58, + 0xff, 0xe6, 0x01, 0x5f, 0xff, 0x6b, 0x01, 0x63, 0xff, 0x92, 0x01, 0x65, 0xff, 0xad, 0x01, 0x69, 0xff, 0x7b, 0x01, + 0x6c, 0x00, 0x0f, 0x01, 0x6d, 0xff, 0x91, 0x01, 0x6e, 0xff, 0xf2, 0x01, 0xdb, 0xff, 0xb9, 0x01, 0xe5, 0xff, 0xb9, + 0x02, 0x31, 0xff, 0xb9, 0x00, 0x07, 0x00, 0x0d, 0x00, 0x14, 0x00, 0x41, 0x00, 0x11, 0x00, 0x56, 0xff, 0xe2, 0x00, + 0x61, 0x00, 0x13, 0x01, 0xdb, 0xff, 0xd9, 0x01, 0xe5, 0xff, 0xd9, 0x02, 0x31, 0xff, 0xd9, 0x00, 0x07, 0x00, 0x4a, + 0x00, 0x0d, 0x00, 0xbe, 0xff, 0xf5, 0x00, 0xc6, 0x00, 0x0b, 0x00, 0xc7, 0xff, 0xea, 0x00, 0xca, 0x00, 0x0c, 0x00, + 0xed, 0xff, 0xc8, 0x01, 0x1c, 0xff, 0xf1, 0x00, 0x07, 0x00, 0x0d, 0x00, 0x0f, 0x00, 0x41, 0x00, 0x0c, 0x00, 0x56, + 0xff, 0xeb, 0x00, 0x61, 0x00, 0x0e, 0x01, 0xdb, 0xff, 0xe7, 0x01, 0xe5, 0xff, 0xe7, 0x02, 0x31, 0xff, 0xe9, 0x00, + 0x06, 0x00, 0x5b, 0xff, 0xe5, 0x00, 0xb8, 0xff, 0xcb, 0x00, 0xcd, 0xff, 0xe4, 0x01, 0xdb, 0xff, 0xec, 0x01, 0xe5, + 0xff, 0xeb, 0x02, 0x31, 0xff, 0xed, 0x00, 0x07, 0x00, 0x81, 0xff, 0xdf, 0x00, 0xb5, 0xff, 0xf3, 0x00, 0xb7, 0xff, + 0xf0, 0x00, 0xc4, 0xff, 0xea, 0x00, 0xd9, 0xff, 0xdf, 0x00, 0xe6, 0xff, 0xe0, 0x01, 0x6c, 0xff, 0xe0, 0x00, 0x01, + 0x01, 0xdb, 0xff, 0xeb, 0x00, 0x04, 0x01, 0xd6, 0xff, 0xc7, 0x01, 0xdb, 0xff, 0xf2, 0x01, 0xe5, 0xff, 0xf2, 0x02, + 0x31, 0xff, 0xf2, 0x00, 0x01, 0x01, 0xd6, 0xff, 0xf1, 0x00, 0x01, 0x01, 0xd6, 0x00, 0x0d, 0x00, 0x02, 0x0b, 0x0c, + 0x00, 0x04, 0x00, 0x00, 0x0e, 0xac, 0x17, 0x68, 0x00, 0x26, 0x00, 0x25, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xe3, 0xff, 0xe4, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xe4, 0xff, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xeb, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xe5, 0xff, 0xd5, 0xff, 0xed, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xea, 0x00, 0x00, 0xff, 0xe9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xe1, 0xff, 0x9a, 0x00, 0x00, 0xff, 0xf5, 0xff, 0xea, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xf5, 0x00, 0x00, 0xff, 0xf4, 0xff, + 0xf5, 0x00, 0x00, 0x00, 0x00, 0xff, 0xf5, 0xff, 0xce, 0xff, 0xef, 0xff, 0x7f, 0xff, 0xa2, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0xff, 0xf1, 0x00, 0x00, 0xff, 0x88, 0x00, 0x00, 0xff, 0xbb, 0xff, 0xc4, 0xff, + 0xc7, 0x00, 0x11, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0xff, 0xa9, 0x00, 0x00, 0x00, 0x00, 0xff, 0xc9, 0xff, 0x8f, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xdd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xf1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xf0, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x78, 0xff, 0xeb, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x98, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xed, 0x00, 0x00, 0x00, 0x00, 0xff, 0xed, 0xff, 0xef, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xe6, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xed, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xf1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xbd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xf5, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xf1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xe3, 0xff, 0xf1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xf2, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xf3, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xf2, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xf3, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xf1, 0x00, 0x00, 0x00, 0x00, 0xff, 0xf1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x95, 0xff, 0xd7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xea, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xeb, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xe6, 0xff, 0xe1, 0xff, 0xe9, 0xff, 0xe5, + 0xff, 0xe9, 0x00, 0x00, 0x00, 0x00, 0xff, 0xe7, 0xff, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xc0, 0x00, 0x00, 0xff, + 0xa3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xbf, 0xff, 0xe3, 0xff, 0xd8, 0xff, 0xbf, 0xff, 0xd9, + 0xff, 0xa2, 0xff, 0xb7, 0xff, 0xcb, 0xff, 0xec, 0xff, 0xa0, 0x00, 0x11, 0x00, 0x12, 0xff, 0xab, 0xff, 0xc6, 0xff, + 0xe2, 0xff, 0xf0, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xe9, 0x00, 0x11, 0x00, 0x00, 0xff, 0xf3, + 0x00, 0x00, 0xff, 0x2d, 0x00, 0x00, 0xff, 0xef, 0x00, 0x12, 0x00, 0x00, 0xff, 0xcc, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xa0, 0xff, 0xf3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xea, 0xff, 0xee, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xec, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x9d, 0xff, 0xe4, 0xff, 0x93, 0xff, 0x9d, 0xff, 0xa1, 0xff, 0xb1, 0xff, 0x8f, + 0xff, 0xb9, 0xff, 0xb8, 0x00, 0x00, 0x00, 0x10, 0x00, 0x10, 0xff, 0xaf, 0xff, 0x8c, 0xff, 0xc4, 0xff, 0xf0, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xb3, 0x00, 0x0f, 0x00, 0x00, 0xff, 0xf1, 0xff, 0xcb, 0xff, 0x26, + 0xff, 0x7e, 0xff, 0xed, 0x00, 0x10, 0xff, 0xbc, 0xff, 0x18, 0x00, 0x00, 0xff, 0x7c, 0x00, 0x00, 0xff, 0x10, 0xff, + 0xf1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xf2, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xec, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xbf, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xd8, 0x00, + 0x00, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xeb, 0xff, 0xe6, 0x00, 0x00, 0xff, 0xeb, 0xff, 0xed, 0x00, 0x0d, 0x00, 0x00, 0xff, 0xec, 0xff, 0xe5, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xe6, 0xff, + 0xe7, 0x00, 0x00, 0xff, 0xeb, 0xff, 0xeb, 0x00, 0x00, 0x00, 0x00, 0xff, 0xe7, 0xff, 0xe1, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, + 0xff, 0xd2, 0x00, 0x00, 0xff, 0xd1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xe3, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xec, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xec, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xed, 0x00, 0x00, 0x00, 0x00, 0xff, 0xec, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xd8, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0x85, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xf3, 0x00, 0x00, 0x00, 0x00, 0xff, 0xf3, 0x00, 0x00, 0xff, + 0x76, 0xff, 0xf5, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xc6, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xe1, 0x00, 0x00, 0xff, 0xe6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xc9, 0xfe, 0xbc, 0xff, 0xd9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xf5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xbf, 0x00, 0x00, 0x00, 0x00, 0xff, 0xd4, 0x00, 0x13, 0x00, 0x00, 0xff, + 0xf2, 0xff, 0x7b, 0xff, 0xca, 0xfe, 0xed, 0xff, 0x11, 0x00, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xda, 0x00, 0x00, 0xfe, 0xb0, 0x00, 0x00, 0xff, 0x71, 0xff, 0x3f, 0xff, 0x3b, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0x51, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x91, + 0x00, 0x00, 0xff, 0xc5, 0x00, 0x00, 0xff, 0xec, 0xff, 0xc3, 0x00, 0x00, 0xff, 0x88, 0xff, 0xce, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xb0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xec, 0x00, 0x00, 0x00, 0x00, 0xff, 0xec, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xd8, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xe1, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xe1, 0xff, 0xed, 0xff, 0xd5, 0xff, 0xdf, 0xff, 0xe7, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x0e, 0x00, 0x00, 0xff, 0xcb, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x85, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xc4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xe5, 0xff, + 0xc9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xe8, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xf3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xd4, 0xff, 0xf3, 0x00, 0x00, + 0xff, 0xd2, 0xff, 0xe4, 0xff, 0xb5, 0xff, 0xd2, 0xff, 0xd9, 0xff, 0xf5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xb4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xdb, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xeb, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xdd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x79, 0xff, 0xf5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xd9, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xf5, 0xff, 0xad, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0xff, 0xc0, 0xff, 0xc9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xf5, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xc8, 0x00, 0x00, 0x00, 0x00, 0xff, 0xe7, 0x00, 0x00, 0xff, 0xeb, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x56, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0x44, 0xff, 0xbd, 0xff, 0x33, 0xff, 0x44, 0xff, 0x4b, 0xff, 0x3e, 0xff, 0x2c, 0x00, 0x00, + 0xff, 0x72, 0x00, 0x00, 0x00, 0x07, 0x00, 0x07, 0x00, 0x00, 0xff, 0x27, 0xff, 0x86, 0xff, 0xd1, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x6a, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0xff, 0x92, 0xfe, 0x7a, 0xff, 0x0f, + 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0xfe, 0x62, 0x00, 0x00, 0xff, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xef, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xec, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xb4, 0xff, 0xbb, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xd5, 0x00, 0x00, 0xff, 0xbd, 0xff, + 0xe9, 0xff, 0x9a, 0xff, 0xbd, 0x00, 0x00, 0xff, 0xa5, 0xff, 0x91, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, + 0x00, 0x12, 0x00, 0x00, 0xff, 0xd2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xca, 0xfe, 0x6d, 0xff, 0xbb, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x89, 0x00, 0x00, 0xff, 0xe9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x9a, 0x00, 0x06, 0x00, + 0x06, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x0b, 0x00, 0x01, 0x00, 0x10, 0x00, 0x10, 0x00, 0x02, 0x00, 0x12, 0x00, 0x12, + 0x00, 0x03, 0x00, 0x25, 0x00, 0x29, 0x00, 0x04, 0x00, 0x2c, 0x00, 0x34, 0x00, 0x09, 0x00, 0x38, 0x00, 0x3e, 0x00, + 0x12, 0x00, 0x45, 0x00, 0x47, 0x00, 0x19, 0x00, 0x49, 0x00, 0x49, 0x00, 0x1c, 0x00, 0x4c, 0x00, 0x4c, 0x00, 0x1d, + 0x00, 0x51, 0x00, 0x54, 0x00, 0x1e, 0x00, 0x56, 0x00, 0x56, 0x00, 0x22, 0x00, 0x5a, 0x00, 0x5a, 0x00, 0x23, 0x00, + 0x5c, 0x00, 0x5e, 0x00, 0x24, 0x00, 0x8a, 0x00, 0x8a, 0x00, 0x27, 0x00, 0x96, 0x00, 0x96, 0x00, 0x28, 0x00, 0xb1, + 0x00, 0xb4, 0x00, 0x29, 0x00, 0xbd, 0x00, 0xbd, 0x00, 0x2d, 0x00, 0xc1, 0x00, 0xc1, 0x00, 0x2e, 0x00, 0xc7, 0x00, + 0xc7, 0x00, 0x2f, 0x00, 0xd4, 0x00, 0xd5, 0x00, 0x30, 0x00, 0xd7, 0x00, 0xd7, 0x00, 0x32, 0x00, 0xda, 0x00, 0xda, + 0x00, 0x33, 0x00, 0xdc, 0x00, 0xde, 0x00, 0x34, 0x00, 0xe0, 0x00, 0xe6, 0x00, 0x37, 0x00, 0xec, 0x00, 0xec, 0x00, + 0x3e, 0x00, 0xee, 0x00, 0xee, 0x00, 0x3f, 0x00, 0xf7, 0x00, 0xf7, 0x00, 0x40, 0x00, 0xfc, 0x00, 0xfc, 0x00, 0x41, + 0x00, 0xfe, 0x00, 0xff, 0x00, 0x42, 0x01, 0x04, 0x01, 0x05, 0x00, 0x44, 0x01, 0x0a, 0x01, 0x0a, 0x00, 0x46, 0x01, + 0x0d, 0x01, 0x0d, 0x00, 0x47, 0x01, 0x18, 0x01, 0x1a, 0x00, 0x48, 0x01, 0x2e, 0x01, 0x30, 0x00, 0x4b, 0x01, 0x33, + 0x01, 0x35, 0x00, 0x4e, 0x01, 0x37, 0x01, 0x37, 0x00, 0x51, 0x01, 0x39, 0x01, 0x39, 0x00, 0x52, 0x01, 0x3b, 0x01, + 0x3b, 0x00, 0x53, 0x01, 0x43, 0x01, 0x44, 0x00, 0x54, 0x01, 0x54, 0x01, 0x54, 0x00, 0x56, 0x01, 0x56, 0x01, 0x56, + 0x00, 0x57, 0x01, 0x58, 0x01, 0x58, 0x00, 0x58, 0x01, 0x5c, 0x01, 0x5e, 0x00, 0x59, 0x01, 0x84, 0x01, 0x8a, 0x00, + 0x5c, 0x01, 0x8e, 0x01, 0x8f, 0x00, 0x63, 0x01, 0xd8, 0x01, 0xd8, 0x00, 0x65, 0x01, 0xdd, 0x01, 0xdd, 0x00, 0x66, + 0x01, 0xe0, 0x01, 0xe1, 0x00, 0x67, 0x01, 0xeb, 0x01, 0xed, 0x00, 0x69, 0x01, 0xff, 0x01, 0xff, 0x00, 0x6c, 0x02, + 0x0e, 0x02, 0x10, 0x00, 0x6d, 0x02, 0x30, 0x02, 0x30, 0x00, 0x70, 0x02, 0x33, 0x02, 0x33, 0x00, 0x71, 0x02, 0x45, + 0x02, 0x45, 0x00, 0x72, 0x02, 0x47, 0x02, 0x48, 0x00, 0x73, 0x02, 0x7a, 0x02, 0x7b, 0x00, 0x75, 0x02, 0x7d, 0x02, + 0x7d, 0x00, 0x77, 0x02, 0x7f, 0x02, 0xa5, 0x00, 0x78, 0x02, 0xaa, 0x02, 0xaf, 0x00, 0x9f, 0x02, 0xb4, 0x02, 0xc4, + 0x00, 0xa5, 0x02, 0xc6, 0x02, 0xcf, 0x00, 0xb6, 0x02, 0xd8, 0x02, 0xda, 0x00, 0xc0, 0x02, 0xdc, 0x02, 0xdc, 0x00, + 0xc3, 0x02, 0xde, 0x02, 0xde, 0x00, 0xc4, 0x02, 0xe0, 0x02, 0xe0, 0x00, 0xc5, 0x02, 0xe2, 0x02, 0xe2, 0x00, 0xc6, + 0x02, 0xe5, 0x02, 0xe5, 0x00, 0xc7, 0x02, 0xe7, 0x02, 0xe7, 0x00, 0xc8, 0x02, 0xe9, 0x02, 0xe9, 0x00, 0xc9, 0x02, + 0xeb, 0x02, 0xeb, 0x00, 0xca, 0x02, 0xed, 0x02, 0xed, 0x00, 0xcb, 0x02, 0xef, 0x02, 0xef, 0x00, 0xcc, 0x02, 0xf1, + 0x02, 0xfd, 0x00, 0xcd, 0x02, 0xff, 0x02, 0xff, 0x00, 0xda, 0x03, 0x01, 0x03, 0x01, 0x00, 0xdb, 0x03, 0x03, 0x03, + 0x03, 0x00, 0xdc, 0x03, 0x0e, 0x03, 0x0e, 0x00, 0xdd, 0x03, 0x10, 0x03, 0x10, 0x00, 0xde, 0x03, 0x12, 0x03, 0x12, + 0x00, 0xdf, 0x03, 0x14, 0x03, 0x14, 0x00, 0xe0, 0x03, 0x16, 0x03, 0x16, 0x00, 0xe1, 0x03, 0x18, 0x03, 0x18, 0x00, + 0xe2, 0x03, 0x1a, 0x03, 0x1a, 0x00, 0xe3, 0x03, 0x1c, 0x03, 0x1c, 0x00, 0xe4, 0x03, 0x1e, 0x03, 0x1e, 0x00, 0xe5, + 0x03, 0x20, 0x03, 0x20, 0x00, 0xe6, 0x03, 0x22, 0x03, 0x2a, 0x00, 0xe7, 0x03, 0x2f, 0x03, 0x38, 0x00, 0xf0, 0x03, + 0x43, 0x03, 0x47, 0x00, 0xfa, 0x03, 0x4d, 0x03, 0x4f, 0x00, 0xff, 0x03, 0x54, 0x03, 0x54, 0x01, 0x02, 0x03, 0x65, + 0x03, 0x69, 0x01, 0x03, 0x03, 0x6d, 0x03, 0x6f, 0x01, 0x08, 0x03, 0x78, 0x03, 0x78, 0x01, 0x0b, 0x03, 0x86, 0x03, + 0x8b, 0x01, 0x0c, 0x03, 0x8e, 0x03, 0x9d, 0x01, 0x12, 0x03, 0xa0, 0x03, 0xa0, 0x01, 0x22, 0x03, 0xa4, 0x03, 0xa4, + 0x01, 0x23, 0x03, 0xa6, 0x03, 0xa6, 0x01, 0x24, 0x03, 0xaa, 0x03, 0xaa, 0x01, 0x25, 0x03, 0xad, 0x03, 0xae, 0x01, + 0x26, 0x03, 0xb0, 0x03, 0xb9, 0x01, 0x28, 0x03, 0xbb, 0x03, 0xbd, 0x01, 0x32, 0x03, 0xbf, 0x03, 0xc4, 0x01, 0x35, + 0x03, 0xc6, 0x03, 0xcc, 0x01, 0x3b, 0x03, 0xd2, 0x03, 0xd3, 0x01, 0x42, 0x03, 0xd5, 0x03, 0xd5, 0x01, 0x44, 0x03, + 0xd7, 0x03, 0xd7, 0x01, 0x45, 0x03, 0xd9, 0x03, 0xdc, 0x01, 0x46, 0x03, 0xdf, 0x03, 0xe4, 0x01, 0x4a, 0x03, 0xe6, + 0x03, 0xe6, 0x01, 0x50, 0x03, 0xea, 0x03, 0xeb, 0x01, 0x51, 0x03, 0xf0, 0x03, 0xfb, 0x01, 0x53, 0x03, 0xfe, 0x03, + 0xff, 0x01, 0x5f, 0x04, 0x01, 0x04, 0x04, 0x01, 0x61, 0x04, 0x0b, 0x04, 0x0c, 0x01, 0x65, 0x04, 0x10, 0x04, 0x10, + 0x01, 0x67, 0x04, 0x12, 0x04, 0x18, 0x01, 0x68, 0x04, 0x1e, 0x04, 0x46, 0x01, 0x6f, 0x04, 0x48, 0x04, 0x48, 0x01, + 0x98, 0x04, 0x4a, 0x04, 0x57, 0x01, 0x99, 0x04, 0x5f, 0x04, 0x5f, 0x01, 0xa7, 0x04, 0x62, 0x04, 0x62, 0x01, 0xa8, + 0x04, 0x64, 0x04, 0x64, 0x01, 0xa9, 0x04, 0x70, 0x04, 0x75, 0x01, 0xaa, 0x04, 0x77, 0x04, 0x77, 0x01, 0xb0, 0x04, + 0x7b, 0x04, 0x7c, 0x01, 0xb1, 0x04, 0x7f, 0x04, 0x7f, 0x01, 0xb3, 0x04, 0x81, 0x04, 0x82, 0x01, 0xb4, 0x04, 0x84, + 0x04, 0x84, 0x01, 0xb6, 0x04, 0x86, 0x04, 0x86, 0x01, 0xb7, 0x04, 0x97, 0x04, 0x9b, 0x01, 0xb8, 0x04, 0x9d, 0x04, + 0x9d, 0x01, 0xbd, 0x04, 0x9f, 0x04, 0xa0, 0x01, 0xbe, 0x04, 0xa2, 0x04, 0xa2, 0x01, 0xc0, 0x04, 0xa6, 0x04, 0xa8, + 0x01, 0xc1, 0x04, 0xaa, 0x04, 0xaa, 0x01, 0xc4, 0x04, 0xac, 0x04, 0xae, 0x01, 0xc5, 0x04, 0xb0, 0x04, 0xb0, 0x01, + 0xc8, 0x04, 0xb2, 0x04, 0xb2, 0x01, 0xc9, 0x04, 0xb4, 0x04, 0xba, 0x01, 0xca, 0x04, 0xbc, 0x04, 0xbc, 0x01, 0xd1, + 0x04, 0xbf, 0x04, 0xbf, 0x01, 0xd2, 0x04, 0xc1, 0x04, 0xc6, 0x01, 0xd3, 0x04, 0xc8, 0x04, 0xcb, 0x01, 0xd9, 0x04, + 0xcf, 0x04, 0xcf, 0x01, 0xdd, 0x04, 0xd2, 0x04, 0xd2, 0x01, 0xde, 0x04, 0xd8, 0x04, 0xd8, 0x01, 0xdf, 0x04, 0xdd, + 0x04, 0xdd, 0x01, 0xe0, 0x04, 0xe8, 0x04, 0xe8, 0x01, 0xe1, 0x04, 0xea, 0x04, 0xea, 0x01, 0xe2, 0x04, 0xf1, 0x04, + 0xf1, 0x01, 0xe3, 0x04, 0xf5, 0x04, 0xf5, 0x01, 0xe4, 0x00, 0x02, 0x01, 0x74, 0x00, 0x06, 0x00, 0x06, 0x00, 0x19, + 0x00, 0x0b, 0x00, 0x0b, 0x00, 0x19, 0x00, 0x10, 0x00, 0x10, 0x00, 0x21, 0x00, 0x12, 0x00, 0x12, 0x00, 0x21, 0x00, + 0x25, 0x00, 0x25, 0x00, 0x02, 0x00, 0x26, 0x00, 0x26, 0x00, 0x1c, 0x00, 0x27, 0x00, 0x27, 0x00, 0x13, 0x00, 0x28, + 0x00, 0x28, 0x00, 0x01, 0x00, 0x29, 0x00, 0x29, 0x00, 0x05, 0x00, 0x2e, 0x00, 0x2e, 0x00, 0x0a, 0x00, 0x2f, 0x00, + 0x2f, 0x00, 0x0b, 0x00, 0x30, 0x00, 0x30, 0x00, 0x18, 0x00, 0x33, 0x00, 0x33, 0x00, 0x01, 0x00, 0x34, 0x00, 0x34, + 0x00, 0x16, 0x00, 0x38, 0x00, 0x38, 0x00, 0x0e, 0x00, 0x39, 0x00, 0x39, 0x00, 0x0a, 0x00, 0x3a, 0x00, 0x3a, 0x00, + 0x1d, 0x00, 0x3b, 0x00, 0x3b, 0x00, 0x1b, 0x00, 0x3c, 0x00, 0x3c, 0x00, 0x12, 0x00, 0x3d, 0x00, 0x3d, 0x00, 0x0c, + 0x00, 0x3e, 0x00, 0x3e, 0x00, 0x11, 0x00, 0x45, 0x00, 0x45, 0x00, 0x06, 0x00, 0x46, 0x00, 0x46, 0x00, 0x07, 0x00, + 0x47, 0x00, 0x47, 0x00, 0x17, 0x00, 0x49, 0x00, 0x49, 0x00, 0x08, 0x00, 0x4c, 0x00, 0x4c, 0x00, 0x04, 0x00, 0x51, + 0x00, 0x52, 0x00, 0x04, 0x00, 0x53, 0x00, 0x53, 0x00, 0x03, 0x00, 0x54, 0x00, 0x54, 0x00, 0x07, 0x00, 0x56, 0x00, + 0x56, 0x00, 0x15, 0x00, 0x5a, 0x00, 0x5a, 0x00, 0x09, 0x00, 0x5c, 0x00, 0x5c, 0x00, 0x14, 0x00, 0x5d, 0x00, 0x5d, + 0x00, 0x09, 0x00, 0x5e, 0x00, 0x5e, 0x00, 0x10, 0x00, 0x8a, 0x00, 0x8a, 0x00, 0x07, 0x00, 0x96, 0x00, 0x96, 0x00, + 0x01, 0x00, 0xb1, 0x00, 0xb1, 0x00, 0x22, 0x00, 0xb2, 0x00, 0xb2, 0x00, 0x02, 0x00, 0xb3, 0x00, 0xb3, 0x00, 0x01, + 0x00, 0xb4, 0x00, 0xb4, 0x00, 0x02, 0x00, 0xbd, 0x00, 0xbd, 0x00, 0x09, 0x00, 0xc1, 0x00, 0xc1, 0x00, 0x04, 0x00, + 0xc7, 0x00, 0xc7, 0x00, 0x07, 0x00, 0xd4, 0x00, 0xd5, 0x00, 0x20, 0x00, 0xda, 0x00, 0xda, 0x00, 0x12, 0x00, 0xde, + 0x00, 0xde, 0x00, 0x25, 0x00, 0xe4, 0x00, 0xe4, 0x00, 0x20, 0x00, 0xe6, 0x00, 0xe6, 0x00, 0x20, 0x00, 0xec, 0x00, + 0xec, 0x00, 0x1a, 0x00, 0xee, 0x00, 0xee, 0x00, 0x14, 0x00, 0xf7, 0x00, 0xf7, 0x00, 0x07, 0x00, 0xfc, 0x00, 0xfc, + 0x00, 0x1f, 0x00, 0xfe, 0x00, 0xfe, 0x00, 0x1f, 0x00, 0xff, 0x00, 0xff, 0x00, 0x07, 0x01, 0x04, 0x01, 0x05, 0x00, + 0x1f, 0x01, 0x0a, 0x01, 0x0a, 0x00, 0x1f, 0x01, 0x0d, 0x01, 0x0d, 0x00, 0x02, 0x01, 0x18, 0x01, 0x18, 0x00, 0x03, + 0x01, 0x19, 0x01, 0x19, 0x00, 0x1d, 0x01, 0x1a, 0x01, 0x1a, 0x00, 0x09, 0x01, 0x2e, 0x01, 0x2e, 0x00, 0x07, 0x01, + 0x2f, 0x01, 0x2f, 0x00, 0x22, 0x01, 0x30, 0x01, 0x30, 0x00, 0x1a, 0x01, 0x33, 0x01, 0x33, 0x00, 0x12, 0x01, 0x34, + 0x01, 0x34, 0x00, 0x14, 0x01, 0x35, 0x01, 0x35, 0x00, 0x0b, 0x01, 0x37, 0x01, 0x37, 0x00, 0x0b, 0x01, 0x39, 0x01, + 0x39, 0x00, 0x0b, 0x01, 0x43, 0x01, 0x43, 0x00, 0x12, 0x01, 0x44, 0x01, 0x44, 0x00, 0x14, 0x01, 0x58, 0x01, 0x58, + 0x00, 0x01, 0x01, 0x5c, 0x01, 0x5c, 0x00, 0x1a, 0x01, 0x5d, 0x01, 0x5d, 0x00, 0x12, 0x01, 0x5e, 0x01, 0x5e, 0x00, + 0x14, 0x01, 0x84, 0x01, 0x85, 0x00, 0x19, 0x01, 0x86, 0x01, 0x86, 0x00, 0x21, 0x01, 0x87, 0x01, 0x89, 0x00, 0x19, + 0x01, 0x8a, 0x01, 0x8a, 0x00, 0x21, 0x01, 0x8e, 0x01, 0x8f, 0x00, 0x21, 0x01, 0xd8, 0x01, 0xd8, 0x00, 0x23, 0x01, + 0xdd, 0x01, 0xdd, 0x00, 0x0d, 0x01, 0xe0, 0x01, 0xe0, 0x00, 0x24, 0x01, 0xe1, 0x01, 0xe1, 0x00, 0x1e, 0x01, 0xeb, + 0x01, 0xeb, 0x00, 0x0f, 0x01, 0xec, 0x01, 0xec, 0x00, 0x0d, 0x01, 0xed, 0x01, 0xed, 0x00, 0x0f, 0x01, 0xff, 0x01, + 0xff, 0x00, 0x1e, 0x02, 0x0e, 0x02, 0x10, 0x00, 0x1e, 0x02, 0x30, 0x02, 0x30, 0x00, 0x0d, 0x02, 0x33, 0x02, 0x33, + 0x00, 0x0f, 0x02, 0x45, 0x02, 0x45, 0x00, 0x13, 0x02, 0x47, 0x02, 0x48, 0x00, 0x01, 0x02, 0x7a, 0x02, 0x7b, 0x00, + 0x01, 0x02, 0x7d, 0x02, 0x7d, 0x00, 0x0e, 0x02, 0x7f, 0x02, 0x85, 0x00, 0x02, 0x02, 0x86, 0x02, 0x86, 0x00, 0x13, + 0x02, 0x87, 0x02, 0x8a, 0x00, 0x05, 0x02, 0x90, 0x02, 0x94, 0x00, 0x01, 0x02, 0x95, 0x02, 0x98, 0x00, 0x0a, 0x02, + 0x99, 0x02, 0x99, 0x00, 0x0c, 0x02, 0x9a, 0x02, 0xa0, 0x00, 0x06, 0x02, 0xa1, 0x02, 0xa1, 0x00, 0x17, 0x02, 0xa2, + 0x02, 0xa5, 0x00, 0x08, 0x02, 0xaa, 0x02, 0xaa, 0x00, 0x04, 0x02, 0xab, 0x02, 0xaf, 0x00, 0x03, 0x02, 0xb4, 0x02, + 0xb5, 0x00, 0x09, 0x02, 0xb6, 0x02, 0xb6, 0x00, 0x02, 0x02, 0xb7, 0x02, 0xb7, 0x00, 0x06, 0x02, 0xb8, 0x02, 0xb8, + 0x00, 0x02, 0x02, 0xb9, 0x02, 0xb9, 0x00, 0x06, 0x02, 0xba, 0x02, 0xba, 0x00, 0x02, 0x02, 0xbb, 0x02, 0xbb, 0x00, + 0x06, 0x02, 0xbc, 0x02, 0xbc, 0x00, 0x13, 0x02, 0xbd, 0x02, 0xbd, 0x00, 0x17, 0x02, 0xbe, 0x02, 0xbe, 0x00, 0x13, + 0x02, 0xbf, 0x02, 0xbf, 0x00, 0x17, 0x02, 0xc0, 0x02, 0xc0, 0x00, 0x13, 0x02, 0xc1, 0x02, 0xc1, 0x00, 0x17, 0x02, + 0xc2, 0x02, 0xc2, 0x00, 0x13, 0x02, 0xc3, 0x02, 0xc3, 0x00, 0x17, 0x02, 0xc4, 0x02, 0xc4, 0x00, 0x01, 0x02, 0xc6, + 0x02, 0xc6, 0x00, 0x05, 0x02, 0xc7, 0x02, 0xc7, 0x00, 0x08, 0x02, 0xc8, 0x02, 0xc8, 0x00, 0x05, 0x02, 0xc9, 0x02, + 0xc9, 0x00, 0x08, 0x02, 0xca, 0x02, 0xca, 0x00, 0x05, 0x02, 0xcb, 0x02, 0xcb, 0x00, 0x08, 0x02, 0xcc, 0x02, 0xcc, + 0x00, 0x05, 0x02, 0xcd, 0x02, 0xcd, 0x00, 0x08, 0x02, 0xce, 0x02, 0xce, 0x00, 0x05, 0x02, 0xcf, 0x02, 0xcf, 0x00, + 0x08, 0x02, 0xd9, 0x02, 0xd9, 0x00, 0x04, 0x02, 0xe5, 0x02, 0xe5, 0x00, 0x0a, 0x02, 0xe7, 0x02, 0xe7, 0x00, 0x0b, + 0x02, 0xe9, 0x02, 0xe9, 0x00, 0x18, 0x02, 0xeb, 0x02, 0xeb, 0x00, 0x18, 0x02, 0xed, 0x02, 0xed, 0x00, 0x18, 0x02, + 0xef, 0x02, 0xef, 0x00, 0x18, 0x02, 0xf2, 0x02, 0xf2, 0x00, 0x04, 0x02, 0xf4, 0x02, 0xf4, 0x00, 0x04, 0x02, 0xf6, + 0x02, 0xf7, 0x00, 0x04, 0x02, 0xf8, 0x02, 0xf8, 0x00, 0x01, 0x02, 0xf9, 0x02, 0xf9, 0x00, 0x03, 0x02, 0xfa, 0x02, + 0xfa, 0x00, 0x01, 0x02, 0xfb, 0x02, 0xfb, 0x00, 0x03, 0x02, 0xfc, 0x02, 0xfc, 0x00, 0x01, 0x02, 0xfd, 0x02, 0xfd, + 0x00, 0x03, 0x02, 0xff, 0x02, 0xff, 0x00, 0x15, 0x03, 0x01, 0x03, 0x01, 0x00, 0x15, 0x03, 0x03, 0x03, 0x03, 0x00, + 0x15, 0x03, 0x0e, 0x03, 0x0e, 0x00, 0x0e, 0x03, 0x10, 0x03, 0x10, 0x00, 0x0e, 0x03, 0x12, 0x03, 0x12, 0x00, 0x0e, + 0x03, 0x14, 0x03, 0x14, 0x00, 0x0a, 0x03, 0x16, 0x03, 0x16, 0x00, 0x0a, 0x03, 0x18, 0x03, 0x18, 0x00, 0x0a, 0x03, + 0x1a, 0x03, 0x1a, 0x00, 0x0a, 0x03, 0x1c, 0x03, 0x1c, 0x00, 0x0a, 0x03, 0x1e, 0x03, 0x1e, 0x00, 0x0a, 0x03, 0x20, + 0x03, 0x20, 0x00, 0x1b, 0x03, 0x22, 0x03, 0x22, 0x00, 0x0c, 0x03, 0x23, 0x03, 0x23, 0x00, 0x09, 0x03, 0x24, 0x03, + 0x24, 0x00, 0x0c, 0x03, 0x25, 0x03, 0x25, 0x00, 0x11, 0x03, 0x26, 0x03, 0x26, 0x00, 0x10, 0x03, 0x27, 0x03, 0x27, + 0x00, 0x11, 0x03, 0x28, 0x03, 0x28, 0x00, 0x10, 0x03, 0x29, 0x03, 0x29, 0x00, 0x11, 0x03, 0x2a, 0x03, 0x2a, 0x00, + 0x10, 0x03, 0x2f, 0x03, 0x30, 0x00, 0x0d, 0x03, 0x31, 0x03, 0x31, 0x00, 0x23, 0x03, 0x32, 0x03, 0x38, 0x00, 0x0f, + 0x03, 0x43, 0x03, 0x47, 0x00, 0x0d, 0x03, 0x4d, 0x03, 0x4f, 0x00, 0x0f, 0x03, 0x54, 0x03, 0x54, 0x00, 0x0d, 0x03, + 0x65, 0x03, 0x65, 0x00, 0x1e, 0x03, 0x66, 0x03, 0x69, 0x00, 0x24, 0x03, 0x6d, 0x03, 0x6f, 0x00, 0x0d, 0x03, 0x78, + 0x03, 0x78, 0x00, 0x23, 0x03, 0x86, 0x03, 0x86, 0x00, 0x02, 0x03, 0x87, 0x03, 0x87, 0x00, 0x05, 0x03, 0x8a, 0x03, + 0x8a, 0x00, 0x01, 0x03, 0x8b, 0x03, 0x8b, 0x00, 0x0c, 0x03, 0x8e, 0x03, 0x8e, 0x00, 0x02, 0x03, 0x8f, 0x03, 0x8f, + 0x00, 0x1c, 0x03, 0x90, 0x03, 0x90, 0x00, 0x05, 0x03, 0x91, 0x03, 0x91, 0x00, 0x11, 0x03, 0x94, 0x03, 0x94, 0x00, + 0x0b, 0x03, 0x97, 0x03, 0x97, 0x00, 0x01, 0x03, 0x98, 0x03, 0x98, 0x00, 0x16, 0x03, 0x99, 0x03, 0x99, 0x00, 0x0e, + 0x03, 0x9a, 0x03, 0x9a, 0x00, 0x0c, 0x03, 0x9b, 0x03, 0x9b, 0x00, 0x12, 0x03, 0x9d, 0x03, 0x9d, 0x00, 0x0c, 0x03, + 0xa0, 0x03, 0xa0, 0x00, 0x04, 0x03, 0xa4, 0x03, 0xa4, 0x00, 0x03, 0x03, 0xa6, 0x03, 0xa6, 0x00, 0x09, 0x03, 0xaa, + 0x03, 0xaa, 0x00, 0x03, 0x03, 0xad, 0x03, 0xad, 0x00, 0x05, 0x03, 0xae, 0x03, 0xae, 0x00, 0x22, 0x03, 0xb2, 0x03, + 0xb2, 0x00, 0x0a, 0x03, 0xb3, 0x03, 0xb4, 0x00, 0x0b, 0x03, 0xb5, 0x03, 0xb5, 0x00, 0x25, 0x03, 0xb6, 0x03, 0xb6, + 0x00, 0x02, 0x03, 0xb7, 0x03, 0xb7, 0x00, 0x1c, 0x03, 0xb8, 0x03, 0xb8, 0x00, 0x22, 0x03, 0xb9, 0x03, 0xb9, 0x00, + 0x05, 0x03, 0xbd, 0x03, 0xbd, 0x00, 0x01, 0x03, 0xbf, 0x03, 0xbf, 0x00, 0x16, 0x03, 0xc0, 0x03, 0xc0, 0x00, 0x13, + 0x03, 0xc1, 0x03, 0xc1, 0x00, 0x0e, 0x03, 0xc2, 0x03, 0xc2, 0x00, 0x12, 0x03, 0xc3, 0x03, 0xc3, 0x00, 0x06, 0x03, + 0xc4, 0x03, 0xc4, 0x00, 0x08, 0x03, 0xc6, 0x03, 0xc6, 0x00, 0x03, 0x03, 0xc7, 0x03, 0xc7, 0x00, 0x07, 0x03, 0xc8, + 0x03, 0xc8, 0x00, 0x17, 0x03, 0xc9, 0x03, 0xc9, 0x00, 0x09, 0x03, 0xca, 0x03, 0xca, 0x00, 0x14, 0x03, 0xcb, 0x03, + 0xcb, 0x00, 0x08, 0x03, 0xcc, 0x03, 0xcc, 0x00, 0x1a, 0x03, 0xd2, 0x03, 0xd2, 0x00, 0x09, 0x03, 0xd3, 0x03, 0xd3, + 0x00, 0x1b, 0x03, 0xd5, 0x03, 0xd5, 0x00, 0x1b, 0x03, 0xd7, 0x03, 0xd7, 0x00, 0x1b, 0x03, 0xd9, 0x03, 0xd9, 0x00, + 0x0c, 0x03, 0xda, 0x03, 0xda, 0x00, 0x09, 0x03, 0xdb, 0x03, 0xdc, 0x00, 0x19, 0x03, 0xdf, 0x03, 0xdf, 0x00, 0x19, + 0x03, 0xe1, 0x03, 0xe1, 0x00, 0x04, 0x03, 0xe2, 0x03, 0xe2, 0x00, 0x02, 0x03, 0xe3, 0x03, 0xe3, 0x00, 0x06, 0x03, + 0xe4, 0x03, 0xe4, 0x00, 0x05, 0x03, 0xe6, 0x03, 0xe6, 0x00, 0x08, 0x03, 0xea, 0x03, 0xea, 0x00, 0x1d, 0x03, 0xeb, + 0x03, 0xeb, 0x00, 0x09, 0x03, 0xf0, 0x03, 0xf0, 0x00, 0x13, 0x03, 0xf1, 0x03, 0xf1, 0x00, 0x17, 0x03, 0xf2, 0x03, + 0xf2, 0x00, 0x0c, 0x03, 0xf3, 0x03, 0xf3, 0x00, 0x09, 0x03, 0xf5, 0x03, 0xf5, 0x00, 0x12, 0x03, 0xf6, 0x03, 0xf6, + 0x00, 0x14, 0x03, 0xf8, 0x03, 0xf8, 0x00, 0x02, 0x03, 0xf9, 0x03, 0xf9, 0x00, 0x06, 0x03, 0xfa, 0x03, 0xfa, 0x00, + 0x02, 0x03, 0xfb, 0x03, 0xfb, 0x00, 0x06, 0x03, 0xfe, 0x03, 0xfe, 0x00, 0x05, 0x03, 0xff, 0x03, 0xff, 0x00, 0x08, + 0x04, 0x01, 0x04, 0x02, 0x00, 0x08, 0x04, 0x03, 0x04, 0x03, 0x00, 0x12, 0x04, 0x04, 0x04, 0x04, 0x00, 0x14, 0x04, + 0x0b, 0x04, 0x0b, 0x00, 0x01, 0x04, 0x0c, 0x04, 0x0c, 0x00, 0x03, 0x04, 0x10, 0x04, 0x10, 0x00, 0x03, 0x04, 0x12, + 0x04, 0x12, 0x00, 0x07, 0x04, 0x13, 0x04, 0x13, 0x00, 0x25, 0x04, 0x14, 0x04, 0x14, 0x00, 0x09, 0x04, 0x15, 0x04, + 0x15, 0x00, 0x25, 0x04, 0x16, 0x04, 0x16, 0x00, 0x09, 0x04, 0x17, 0x04, 0x17, 0x00, 0x25, 0x04, 0x18, 0x04, 0x18, + 0x00, 0x09, 0x04, 0x1e, 0x04, 0x1e, 0x00, 0x02, 0x04, 0x1f, 0x04, 0x1f, 0x00, 0x06, 0x04, 0x20, 0x04, 0x20, 0x00, + 0x02, 0x04, 0x21, 0x04, 0x21, 0x00, 0x06, 0x04, 0x22, 0x04, 0x22, 0x00, 0x02, 0x04, 0x23, 0x04, 0x23, 0x00, 0x06, + 0x04, 0x24, 0x04, 0x24, 0x00, 0x02, 0x04, 0x25, 0x04, 0x25, 0x00, 0x06, 0x04, 0x26, 0x04, 0x26, 0x00, 0x02, 0x04, + 0x27, 0x04, 0x27, 0x00, 0x06, 0x04, 0x28, 0x04, 0x28, 0x00, 0x02, 0x04, 0x29, 0x04, 0x29, 0x00, 0x06, 0x04, 0x2a, + 0x04, 0x2a, 0x00, 0x02, 0x04, 0x2b, 0x04, 0x2b, 0x00, 0x06, 0x04, 0x2c, 0x04, 0x2c, 0x00, 0x02, 0x04, 0x2d, 0x04, + 0x2d, 0x00, 0x06, 0x04, 0x2e, 0x04, 0x2e, 0x00, 0x02, 0x04, 0x2f, 0x04, 0x2f, 0x00, 0x06, 0x04, 0x30, 0x04, 0x30, + 0x00, 0x02, 0x04, 0x31, 0x04, 0x31, 0x00, 0x06, 0x04, 0x32, 0x04, 0x32, 0x00, 0x02, 0x04, 0x33, 0x04, 0x33, 0x00, + 0x06, 0x04, 0x34, 0x04, 0x34, 0x00, 0x02, 0x04, 0x35, 0x04, 0x35, 0x00, 0x06, 0x04, 0x36, 0x04, 0x36, 0x00, 0x05, + 0x04, 0x37, 0x04, 0x37, 0x00, 0x08, 0x04, 0x38, 0x04, 0x38, 0x00, 0x05, 0x04, 0x39, 0x04, 0x39, 0x00, 0x08, 0x04, + 0x3a, 0x04, 0x3a, 0x00, 0x05, 0x04, 0x3b, 0x04, 0x3b, 0x00, 0x08, 0x04, 0x3c, 0x04, 0x3c, 0x00, 0x05, 0x04, 0x3d, + 0x04, 0x3d, 0x00, 0x08, 0x04, 0x3e, 0x04, 0x3e, 0x00, 0x05, 0x04, 0x3f, 0x04, 0x3f, 0x00, 0x08, 0x04, 0x40, 0x04, + 0x40, 0x00, 0x05, 0x04, 0x41, 0x04, 0x41, 0x00, 0x08, 0x04, 0x42, 0x04, 0x42, 0x00, 0x05, 0x04, 0x43, 0x04, 0x43, + 0x00, 0x08, 0x04, 0x44, 0x04, 0x44, 0x00, 0x05, 0x04, 0x45, 0x04, 0x45, 0x00, 0x08, 0x04, 0x4a, 0x04, 0x4a, 0x00, + 0x01, 0x04, 0x4b, 0x04, 0x4b, 0x00, 0x03, 0x04, 0x4c, 0x04, 0x4c, 0x00, 0x01, 0x04, 0x4d, 0x04, 0x4d, 0x00, 0x03, + 0x04, 0x4e, 0x04, 0x4e, 0x00, 0x01, 0x04, 0x4f, 0x04, 0x4f, 0x00, 0x03, 0x04, 0x50, 0x04, 0x50, 0x00, 0x01, 0x04, + 0x51, 0x04, 0x51, 0x00, 0x03, 0x04, 0x52, 0x04, 0x52, 0x00, 0x01, 0x04, 0x53, 0x04, 0x53, 0x00, 0x03, 0x04, 0x54, + 0x04, 0x54, 0x00, 0x01, 0x04, 0x55, 0x04, 0x55, 0x00, 0x03, 0x04, 0x56, 0x04, 0x56, 0x00, 0x01, 0x04, 0x57, 0x04, + 0x57, 0x00, 0x03, 0x04, 0x5f, 0x04, 0x5f, 0x00, 0x03, 0x04, 0x62, 0x04, 0x62, 0x00, 0x0a, 0x04, 0x64, 0x04, 0x64, + 0x00, 0x0a, 0x04, 0x70, 0x04, 0x70, 0x00, 0x0c, 0x04, 0x71, 0x04, 0x71, 0x00, 0x09, 0x04, 0x72, 0x04, 0x72, 0x00, + 0x0c, 0x04, 0x73, 0x04, 0x73, 0x00, 0x09, 0x04, 0x74, 0x04, 0x74, 0x00, 0x0c, 0x04, 0x75, 0x04, 0x75, 0x00, 0x09, + 0x04, 0x77, 0x04, 0x77, 0x00, 0x0e, 0x04, 0x7b, 0x04, 0x7b, 0x00, 0x22, 0x04, 0x7c, 0x04, 0x7c, 0x00, 0x1a, 0x04, + 0x7f, 0x04, 0x7f, 0x00, 0x04, 0x04, 0x81, 0x04, 0x81, 0x00, 0x20, 0x04, 0x82, 0x04, 0x82, 0x00, 0x22, 0x04, 0x84, + 0x04, 0x84, 0x00, 0x0b, 0x04, 0x86, 0x04, 0x86, 0x00, 0x0c, 0x04, 0x98, 0x04, 0x98, 0x00, 0x04, 0x04, 0x99, 0x04, + 0x99, 0x00, 0x02, 0x04, 0x9a, 0x04, 0x9a, 0x00, 0x06, 0x04, 0x9b, 0x04, 0x9b, 0x00, 0x05, 0x04, 0x9f, 0x04, 0x9f, + 0x00, 0x01, 0x04, 0xa0, 0x04, 0xa0, 0x00, 0x03, 0x04, 0xa2, 0x04, 0xa2, 0x00, 0x15, 0x04, 0xa6, 0x04, 0xa6, 0x00, + 0x1c, 0x04, 0xa7, 0x04, 0xa7, 0x00, 0x07, 0x04, 0xa8, 0x04, 0xa8, 0x00, 0x01, 0x04, 0xaa, 0x04, 0xaa, 0x00, 0x01, + 0x04, 0xad, 0x04, 0xad, 0x00, 0x04, 0x04, 0xae, 0x04, 0xae, 0x00, 0x0b, 0x04, 0xb0, 0x04, 0xb0, 0x00, 0x0b, 0x04, + 0xb2, 0x04, 0xb2, 0x00, 0x18, 0x04, 0xb5, 0x04, 0xb5, 0x00, 0x04, 0x04, 0xb7, 0x04, 0xb7, 0x00, 0x04, 0x04, 0xb8, + 0x04, 0xb8, 0x00, 0x01, 0x04, 0xb9, 0x04, 0xb9, 0x00, 0x16, 0x04, 0xba, 0x04, 0xba, 0x00, 0x07, 0x04, 0xbc, 0x04, + 0xbc, 0x00, 0x15, 0x04, 0xbf, 0x04, 0xbf, 0x00, 0x0e, 0x04, 0xc1, 0x04, 0xc1, 0x00, 0x0a, 0x04, 0xc2, 0x04, 0xc2, + 0x00, 0x1d, 0x04, 0xc3, 0x04, 0xc3, 0x00, 0x09, 0x04, 0xc4, 0x04, 0xc4, 0x00, 0x1d, 0x04, 0xc5, 0x04, 0xc5, 0x00, + 0x09, 0x04, 0xc6, 0x04, 0xc6, 0x00, 0x1b, 0x04, 0xc8, 0x04, 0xc8, 0x00, 0x11, 0x04, 0xc9, 0x04, 0xc9, 0x00, 0x10, + 0x04, 0xca, 0x04, 0xca, 0x00, 0x01, 0x04, 0xcb, 0x04, 0xcb, 0x00, 0x0f, 0x04, 0xcf, 0x04, 0xcf, 0x00, 0x0d, 0x04, + 0xd2, 0x04, 0xd2, 0x00, 0x0f, 0x04, 0xd8, 0x04, 0xd8, 0x00, 0x1e, 0x04, 0xdd, 0x04, 0xdd, 0x00, 0x23, 0x04, 0xe8, + 0x04, 0xe8, 0x00, 0x1e, 0x04, 0xea, 0x04, 0xea, 0x00, 0x0f, 0x04, 0xf1, 0x04, 0xf1, 0x00, 0x0d, 0x04, 0xf5, 0x04, + 0xf5, 0x00, 0x23, 0x00, 0x01, 0x00, 0x06, 0x04, 0xf5, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x1f, 0x00, 0x1a, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x10, 0x00, 0x0b, 0x00, 0x0a, 0x00, + 0x1d, 0x00, 0x16, 0x00, 0x11, 0x00, 0x0c, 0x00, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x03, 0x00, 0x04, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, + 0x00, 0x0e, 0x00, 0x00, 0x00, 0x05, 0x00, 0x09, 0x00, 0x00, 0x00, 0x15, 0x00, 0x09, 0x00, 0x0f, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x02, 0x00, 0x06, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x0b, 0x00, 0x02, 0x00, 0x19, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x19, 0x00, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x15, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x03, 0x00, 0x1b, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, + 0x03, 0x00, 0x21, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x1b, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x04, 0x00, 0x1d, 0x00, 0x09, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, + 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x15, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x01, 0x00, 0x11, 0x00, + 0x15, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x20, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x19, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x11, 0x00, 0x15, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x19, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x14, 0x00, 0x14, 0x00, 0x1a, + 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x1a, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x17, 0x00, 0x1c, 0x00, 0x24, 0x00, 0x00, 0x00, 0x12, 0x00, 0x18, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x08, 0x00, + 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x08, 0x00, 0x0d, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x08, 0x00, 0x17, 0x00, 0x1c, 0x00, 0x18, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x06, 0x00, 0x06, 0x00, 0x06, 0x00, 0x06, 0x00, 0x06, 0x00, 0x06, 0x00, 0x06, 0x00, 0x02, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x0a, 0x00, 0x0a, 0x00, 0x0a, 0x00, 0x0a, 0x00, 0x0c, 0x00, + 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, + 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x04, 0x00, 0x04, 0x00, + 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x09, 0x00, 0x09, 0x00, 0x06, + 0x00, 0x07, 0x00, 0x06, 0x00, 0x07, 0x00, 0x06, 0x00, 0x07, 0x00, 0x02, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, + 0x02, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x02, 0x00, + 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x03, 0x00, 0x02, 0x00, + 0x04, 0x00, 0x02, 0x00, 0x04, 0x00, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x10, 0x00, 0x0e, 0x00, 0x10, 0x00, 0x0e, 0x00, 0x10, 0x00, 0x0e, 0x00, 0x10, 0x00, 0x0e, 0x00, + 0x10, 0x00, 0x0e, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x05, + 0x00, 0x0a, 0x00, 0x05, 0x00, 0x0a, 0x00, 0x05, 0x00, 0x0a, 0x00, 0x05, 0x00, 0x0a, 0x00, 0x05, 0x00, 0x0a, 0x00, + 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x09, 0x00, 0x0c, 0x00, 0x13, 0x00, 0x0f, 0x00, 0x13, 0x00, 0x0f, + 0x00, 0x13, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x0d, 0x00, 0x0d, 0x00, 0x0d, 0x00, 0x0d, 0x00, 0x0d, 0x00, 0x0d, 0x00, 0x0d, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x08, 0x00, + 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x17, 0x00, 0x0d, 0x00, 0x0d, + 0x00, 0x0d, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x1e, + 0x00, 0x1e, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, + 0x12, 0x00, 0x12, 0x00, 0x24, 0x00, 0x17, 0x00, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, + 0x00, 0x11, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x04, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x00, 0x06, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x00, 0x0b, 0x00, 0x11, 0x00, 0x07, 0x00, 0x01, 0x00, 0x03, 0x00, 0x04, 0x00, 0x03, 0x00, 0x01, 0x00, 0x09, 0x00, + 0x15, 0x00, 0x01, 0x00, 0x03, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x09, 0x00, 0x16, + 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x09, 0x00, 0x14, 0x00, 0x14, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x03, 0x00, 0x06, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x09, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x01, 0x00, 0x0c, 0x00, 0x09, 0x00, 0x00, 0x00, 0x11, 0x00, 0x15, 0x00, 0x00, 0x00, 0x06, 0x00, 0x07, + 0x00, 0x06, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x11, 0x00, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x02, 0x00, 0x04, + 0x00, 0x02, 0x00, 0x01, 0x00, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x00, 0x09, 0x00, 0x22, 0x00, + 0x09, 0x00, 0x22, 0x00, 0x09, 0x00, 0x20, 0x00, 0x21, 0x00, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x06, 0x00, 0x07, + 0x00, 0x06, 0x00, 0x07, 0x00, 0x06, 0x00, 0x07, 0x00, 0x06, 0x00, 0x07, 0x00, 0x06, 0x00, 0x07, 0x00, 0x06, 0x00, + 0x07, 0x00, 0x06, 0x00, 0x07, 0x00, 0x06, 0x00, 0x07, 0x00, 0x06, 0x00, 0x07, 0x00, 0x06, 0x00, 0x07, 0x00, 0x06, + 0x00, 0x07, 0x00, 0x06, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, + 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x04, 0x00, 0x02, 0x00, 0x04, 0x00, 0x02, 0x00, + 0x04, 0x00, 0x02, 0x00, 0x04, 0x00, 0x02, 0x00, 0x04, 0x00, 0x02, 0x00, 0x04, 0x00, 0x02, 0x00, 0x04, 0x00, 0x02, + 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x02, 0x00, 0x04, 0x00, 0x02, 0x00, 0x01, 0x00, + 0x0a, 0x00, 0x05, 0x00, 0x0a, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, + 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x0c, 0x00, 0x09, 0x00, 0x0c, 0x00, 0x09, 0x00, 0x0c, 0x00, + 0x09, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x20, 0x00, 0x21, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x06, 0x00, 0x07, 0x00, + 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, + 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x0e, 0x00, 0x0b, 0x00, 0x00, 0x00, + 0x0a, 0x00, 0x1d, 0x00, 0x09, 0x00, 0x1d, 0x00, 0x09, 0x00, 0x16, 0x00, 0x00, 0x00, 0x13, 0x00, 0x0f, 0x00, 0x00, + 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x17, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x17, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x18, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, + 0x17, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a, 0x01, 0x62, 0x02, 0x92, 0x00, 0x04, 0x44, 0x46, 0x4c, 0x54, 0x00, 0x1a, + 0x63, 0x79, 0x72, 0x6c, 0x00, 0x1a, 0x67, 0x72, 0x65, 0x6b, 0x00, 0x1a, 0x6c, 0x61, 0x74, 0x6e, 0x00, 0x48, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x12, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x04, + 0x00, 0x08, 0x00, 0x0c, 0x00, 0x0d, 0x00, 0x0e, 0x00, 0x0f, 0x00, 0x10, 0x00, 0x11, 0x00, 0x12, 0x00, 0x13, 0x00, + 0x14, 0x00, 0x15, 0x00, 0x16, 0x00, 0x17, 0x00, 0x2e, 0x00, 0x07, 0x41, 0x5a, 0x45, 0x20, 0x00, 0xe4, 0x43, 0x52, + 0x54, 0x20, 0x00, 0xe4, 0x46, 0x52, 0x41, 0x20, 0x00, 0x5a, 0x4d, 0x4f, 0x4c, 0x20, 0x00, 0xb6, 0x4e, 0x41, 0x56, + 0x20, 0x00, 0x88, 0x52, 0x4f, 0x4d, 0x20, 0x00, 0xb6, 0x54, 0x52, 0x4b, 0x20, 0x00, 0xe4, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x13, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x04, 0x00, 0x07, 0x00, 0x08, 0x00, 0x0c, 0x00, + 0x0d, 0x00, 0x0e, 0x00, 0x0f, 0x00, 0x10, 0x00, 0x11, 0x00, 0x12, 0x00, 0x13, 0x00, 0x14, 0x00, 0x15, 0x00, 0x16, + 0x00, 0x17, 0x00, 0x00, 0xff, 0xff, 0x00, 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x04, 0x00, + 0x06, 0x00, 0x08, 0x00, 0x09, 0x00, 0x0c, 0x00, 0x0d, 0x00, 0x0e, 0x00, 0x0f, 0x00, 0x10, 0x00, 0x11, 0x00, 0x12, + 0x00, 0x13, 0x00, 0x14, 0x00, 0x15, 0x00, 0x16, 0x00, 0x17, 0x00, 0x00, 0xff, 0xff, 0x00, 0x14, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x04, 0x00, 0x06, 0x00, 0x08, 0x00, 0x0b, 0x00, 0x0c, 0x00, 0x0d, 0x00, 0x0e, + 0x00, 0x0f, 0x00, 0x10, 0x00, 0x11, 0x00, 0x12, 0x00, 0x13, 0x00, 0x14, 0x00, 0x15, 0x00, 0x16, 0x00, 0x17, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x04, 0x00, 0x06, 0x00, 0x08, + 0x00, 0x0a, 0x00, 0x0c, 0x00, 0x0d, 0x00, 0x0e, 0x00, 0x0f, 0x00, 0x10, 0x00, 0x11, 0x00, 0x12, 0x00, 0x13, 0x00, + 0x14, 0x00, 0x15, 0x00, 0x16, 0x00, 0x17, 0x00, 0x00, 0xff, 0xff, 0x00, 0x13, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, + 0x00, 0x03, 0x00, 0x04, 0x00, 0x05, 0x00, 0x08, 0x00, 0x0c, 0x00, 0x0d, 0x00, 0x0e, 0x00, 0x0f, 0x00, 0x10, 0x00, + 0x11, 0x00, 0x12, 0x00, 0x13, 0x00, 0x14, 0x00, 0x15, 0x00, 0x16, 0x00, 0x17, 0x00, 0x18, 0x63, 0x32, 0x73, 0x63, + 0x00, 0x92, 0x63, 0x63, 0x6d, 0x70, 0x00, 0x98, 0x64, 0x6c, 0x69, 0x67, 0x00, 0xa0, 0x64, 0x6e, 0x6f, 0x6d, 0x00, + 0xa6, 0x66, 0x72, 0x61, 0x63, 0x00, 0xac, 0x6c, 0x69, 0x67, 0x61, 0x00, 0xb6, 0x6c, 0x69, 0x67, 0x61, 0x00, 0xbc, + 0x6c, 0x69, 0x67, 0x61, 0x00, 0xc8, 0x6c, 0x6e, 0x75, 0x6d, 0x00, 0xd0, 0x6c, 0x6f, 0x63, 0x6c, 0x00, 0xd6, 0x6c, + 0x6f, 0x63, 0x6c, 0x00, 0xdc, 0x6c, 0x6f, 0x63, 0x6c, 0x00, 0xe2, 0x6e, 0x75, 0x6d, 0x72, 0x00, 0xe8, 0x6f, 0x6e, + 0x75, 0x6d, 0x00, 0xee, 0x70, 0x6e, 0x75, 0x6d, 0x00, 0xf4, 0x73, 0x6d, 0x63, 0x70, 0x00, 0xfa, 0x73, 0x73, 0x30, + 0x31, 0x01, 0x00, 0x73, 0x73, 0x30, 0x32, 0x01, 0x06, 0x73, 0x73, 0x30, 0x33, 0x01, 0x0c, 0x73, 0x73, 0x30, 0x34, + 0x01, 0x12, 0x73, 0x73, 0x30, 0x35, 0x01, 0x18, 0x73, 0x73, 0x30, 0x36, 0x01, 0x1e, 0x73, 0x73, 0x30, 0x37, 0x01, + 0x24, 0x74, 0x6e, 0x75, 0x6d, 0x01, 0x2a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x02, + 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x18, 0x00, 0x00, 0x00, 0x03, 0x00, + 0x16, 0x00, 0x17, 0x00, 0x19, 0x00, 0x00, 0x00, 0x01, 0x00, 0x09, 0x00, 0x00, 0x00, 0x04, 0x00, 0x08, 0x00, 0x09, + 0x00, 0x08, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02, 0x00, 0x08, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01, 0x00, 0x15, 0x00, + 0x00, 0x00, 0x01, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x06, 0x00, 0x00, + 0x00, 0x01, 0x00, 0x19, 0x00, 0x00, 0x00, 0x01, 0x00, 0x12, 0x00, 0x00, 0x00, 0x01, 0x00, 0x13, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x01, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x0d, 0x00, 0x00, 0x00, 0x01, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x01, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x01, 0x00, + 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x14, 0x00, 0x1a, 0x00, 0x36, 0x04, 0x30, + 0x07, 0xee, 0x08, 0xa0, 0x08, 0xca, 0x0f, 0x6e, 0x0f, 0x84, 0x0f, 0xae, 0x0f, 0xc2, 0x0f, 0xe6, 0x10, 0x10, 0x10, + 0x4c, 0x10, 0x60, 0x10, 0x74, 0x10, 0x88, 0x10, 0x9a, 0x10, 0xb4, 0x10, 0xf6, 0x11, 0x14, 0x11, 0x66, 0x11, 0xac, + 0x12, 0x0e, 0x12, 0x6c, 0x12, 0x80, 0x12, 0xb0, 0x12, 0xd2, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, + 0x02, 0x01, 0xfa, 0x00, 0xfa, 0x01, 0xe7, 0x02, 0x71, 0x01, 0xd1, 0x01, 0xd0, 0x01, 0xcf, 0x01, 0xce, 0x01, 0xcd, + 0x01, 0xcc, 0x01, 0xcb, 0x01, 0xca, 0x01, 0xc9, 0x01, 0xc8, 0x02, 0x33, 0x02, 0x32, 0x02, 0x31, 0x02, 0x30, 0x02, + 0x28, 0x01, 0xe6, 0x01, 0xe5, 0x01, 0xe4, 0x01, 0xe3, 0x01, 0xe2, 0x01, 0xe1, 0x01, 0xe0, 0x01, 0xdf, 0x01, 0xde, + 0x01, 0xdd, 0x01, 0xdc, 0x01, 0xdb, 0x01, 0xda, 0x01, 0xd9, 0x01, 0xd8, 0x01, 0xd7, 0x01, 0xd6, 0x01, 0xd5, 0x01, + 0xd4, 0x01, 0xd3, 0x01, 0xd2, 0x01, 0xe8, 0x01, 0xe9, 0x02, 0x73, 0x02, 0x75, 0x02, 0x74, 0x02, 0x76, 0x02, 0x72, + 0x02, 0x77, 0x02, 0x52, 0x01, 0xea, 0x01, 0xeb, 0x01, 0xec, 0x01, 0xed, 0x01, 0xee, 0x01, 0xef, 0x01, 0xf0, 0x01, + 0xf1, 0x01, 0xf2, 0x01, 0xf3, 0x01, 0xf4, 0x01, 0xf5, 0x01, 0xf6, 0x01, 0xf7, 0x01, 0xf8, 0x01, 0xf9, 0x01, 0xfa, + 0x01, 0xfb, 0x01, 0xfc, 0x01, 0xfd, 0x01, 0xfe, 0x02, 0x00, 0x02, 0x01, 0x04, 0xfe, 0x02, 0x02, 0x02, 0x03, 0x02, + 0x04, 0x02, 0x05, 0x02, 0x06, 0x02, 0x07, 0x02, 0x08, 0x02, 0x09, 0x02, 0x0a, 0x02, 0x0b, 0x02, 0x3b, 0x02, 0x0d, + 0x02, 0x0e, 0x02, 0x0f, 0x02, 0x10, 0x04, 0xf8, 0x02, 0x11, 0x02, 0x13, 0x02, 0x14, 0x02, 0x15, 0x02, 0x16, 0x02, + 0x17, 0x02, 0x18, 0x02, 0x19, 0x02, 0x1b, 0x02, 0x1c, 0x02, 0x1e, 0x02, 0x1d, 0x03, 0x2f, 0x03, 0x30, 0x03, 0x31, + 0x03, 0x32, 0x03, 0x33, 0x03, 0x34, 0x03, 0x35, 0x03, 0x36, 0x03, 0x37, 0x03, 0x38, 0x03, 0x39, 0x03, 0x3a, 0x03, + 0x3b, 0x03, 0x3c, 0x03, 0x3d, 0x03, 0x3e, 0x03, 0x3f, 0x03, 0x40, 0x03, 0x41, 0x03, 0x42, 0x03, 0x43, 0x03, 0x44, + 0x03, 0x45, 0x03, 0x46, 0x03, 0x47, 0x03, 0x48, 0x03, 0x49, 0x03, 0x4a, 0x03, 0x4b, 0x03, 0x4c, 0x03, 0x4d, 0x03, + 0x4e, 0x03, 0x4f, 0x03, 0x50, 0x03, 0x51, 0x03, 0x52, 0x03, 0x53, 0x03, 0x54, 0x03, 0x55, 0x03, 0x56, 0x03, 0x57, + 0x03, 0x58, 0x03, 0x59, 0x03, 0x5a, 0x03, 0x5b, 0x03, 0x5c, 0x03, 0x5d, 0x03, 0x5e, 0x03, 0x5f, 0x03, 0x60, 0x03, + 0x61, 0x03, 0x62, 0x03, 0x63, 0x04, 0xff, 0x03, 0x64, 0x03, 0x65, 0x03, 0x66, 0x03, 0x67, 0x03, 0x68, 0x03, 0x69, + 0x03, 0x6a, 0x03, 0x6b, 0x03, 0x6c, 0x03, 0x6d, 0x03, 0x6e, 0x03, 0x6f, 0x03, 0x70, 0x03, 0x71, 0x03, 0x72, 0x03, + 0x73, 0x03, 0x74, 0x03, 0x75, 0x05, 0x02, 0x03, 0x76, 0x03, 0x77, 0x03, 0x79, 0x03, 0x78, 0x03, 0x7a, 0x03, 0x7b, + 0x03, 0x7c, 0x03, 0x7d, 0x03, 0x7e, 0x03, 0x7f, 0x03, 0x80, 0x03, 0x81, 0x03, 0x82, 0x03, 0x83, 0x03, 0x84, 0x03, + 0x85, 0x05, 0x00, 0x05, 0x01, 0x04, 0xcb, 0x04, 0xcc, 0x04, 0xcd, 0x04, 0xce, 0x04, 0xcf, 0x04, 0xd0, 0x04, 0xd1, + 0x04, 0xd2, 0x04, 0xd3, 0x04, 0xd4, 0x04, 0xd5, 0x04, 0xd6, 0x04, 0xd7, 0x04, 0xd8, 0x04, 0xd9, 0x04, 0xda, 0x04, + 0xdb, 0x04, 0xdc, 0x04, 0xdd, 0x04, 0xde, 0x04, 0xdf, 0x04, 0xe0, 0x04, 0xe1, 0x04, 0xe2, 0x04, 0xe3, 0x04, 0xe4, + 0x04, 0xe5, 0x04, 0xe6, 0x04, 0xe7, 0x01, 0xff, 0x04, 0xe8, 0x04, 0xe9, 0x04, 0xea, 0x04, 0xeb, 0x04, 0xec, 0x04, + 0xed, 0x04, 0xee, 0x04, 0xef, 0x04, 0xf0, 0x04, 0xf1, 0x04, 0xf2, 0x04, 0xf3, 0x04, 0xf4, 0x04, 0xf5, 0x04, 0xf6, + 0x05, 0x03, 0x05, 0x04, 0x05, 0x05, 0x05, 0x06, 0x04, 0xf7, 0x04, 0xf9, 0x04, 0xfa, 0x04, 0xfc, 0x02, 0x1a, 0x04, + 0xfd, 0x04, 0xfb, 0x02, 0x0c, 0x02, 0x12, 0x05, 0x0b, 0x05, 0x0c, 0x00, 0x01, 0x00, 0xfa, 0x00, 0x08, 0x00, 0x0a, + 0x00, 0x14, 0x00, 0x15, 0x00, 0x16, 0x00, 0x17, 0x00, 0x18, 0x00, 0x19, 0x00, 0x1a, 0x00, 0x1b, 0x00, 0x1c, 0x00, + 0x1d, 0x00, 0x25, 0x00, 0x26, 0x00, 0x27, 0x00, 0x28, 0x00, 0x29, 0x00, 0x2a, 0x00, 0x2b, 0x00, 0x2c, 0x00, 0x2d, + 0x00, 0x2e, 0x00, 0x2f, 0x00, 0x30, 0x00, 0x31, 0x00, 0x32, 0x00, 0x33, 0x00, 0x34, 0x00, 0x35, 0x00, 0x36, 0x00, + 0x37, 0x00, 0x38, 0x00, 0x39, 0x00, 0x3a, 0x00, 0x3b, 0x00, 0x3c, 0x00, 0x3d, 0x00, 0x3e, 0x00, 0x65, 0x00, 0x67, + 0x00, 0x81, 0x00, 0x83, 0x00, 0x84, 0x00, 0x8c, 0x00, 0x8f, 0x00, 0x91, 0x00, 0x93, 0x00, 0xb1, 0x00, 0xb2, 0x00, + 0xb3, 0x00, 0xb4, 0x00, 0xb5, 0x00, 0xb6, 0x00, 0xb7, 0x00, 0xb8, 0x00, 0xb9, 0x00, 0xba, 0x00, 0xd2, 0x00, 0xd3, + 0x00, 0xd4, 0x00, 0xd5, 0x00, 0xd6, 0x00, 0xd7, 0x00, 0xd8, 0x00, 0xd9, 0x00, 0xda, 0x00, 0xdb, 0x00, 0xdc, 0x00, + 0xdd, 0x00, 0xde, 0x00, 0xdf, 0x00, 0xe0, 0x00, 0xe1, 0x00, 0xe2, 0x00, 0xe3, 0x00, 0xe4, 0x00, 0xe5, 0x00, 0xe6, + 0x00, 0xe7, 0x00, 0xe8, 0x00, 0xe9, 0x01, 0x2f, 0x01, 0x33, 0x01, 0x35, 0x01, 0x37, 0x01, 0x39, 0x01, 0x3b, 0x01, + 0x41, 0x01, 0x43, 0x01, 0x45, 0x01, 0x49, 0x01, 0x4b, 0x01, 0x4c, 0x01, 0x58, 0x01, 0x59, 0x01, 0x97, 0x01, 0x9d, + 0x01, 0xa2, 0x01, 0xa5, 0x02, 0x7a, 0x02, 0x7b, 0x02, 0x7d, 0x02, 0x7f, 0x02, 0x80, 0x02, 0x81, 0x02, 0x82, 0x02, + 0x83, 0x02, 0x84, 0x02, 0x85, 0x02, 0x86, 0x02, 0x87, 0x02, 0x88, 0x02, 0x89, 0x02, 0x8a, 0x02, 0x8b, 0x02, 0x8c, + 0x02, 0x8d, 0x02, 0x8e, 0x02, 0x8f, 0x02, 0x90, 0x02, 0x91, 0x02, 0x92, 0x02, 0x93, 0x02, 0x94, 0x02, 0x95, 0x02, + 0x96, 0x02, 0x97, 0x02, 0x98, 0x02, 0x99, 0x02, 0xb6, 0x02, 0xb8, 0x02, 0xba, 0x02, 0xbc, 0x02, 0xbe, 0x02, 0xc0, + 0x02, 0xc2, 0x02, 0xc4, 0x02, 0xc6, 0x02, 0xc8, 0x02, 0xca, 0x02, 0xcc, 0x02, 0xce, 0x02, 0xd0, 0x02, 0xd2, 0x02, + 0xd4, 0x02, 0xd6, 0x02, 0xd8, 0x02, 0xda, 0x02, 0xdc, 0x02, 0xde, 0x02, 0xe0, 0x02, 0xe2, 0x02, 0xe3, 0x02, 0xe5, + 0x02, 0xe7, 0x02, 0xe9, 0x02, 0xeb, 0x02, 0xed, 0x02, 0xef, 0x02, 0xf1, 0x02, 0xf3, 0x02, 0xf5, 0x02, 0xf8, 0x02, + 0xfa, 0x02, 0xfc, 0x02, 0xfe, 0x03, 0x00, 0x03, 0x02, 0x03, 0x04, 0x03, 0x06, 0x03, 0x08, 0x03, 0x0a, 0x03, 0x0c, + 0x03, 0x0e, 0x03, 0x10, 0x03, 0x12, 0x03, 0x14, 0x03, 0x16, 0x03, 0x18, 0x03, 0x1a, 0x03, 0x1c, 0x03, 0x1e, 0x03, + 0x20, 0x03, 0x22, 0x03, 0x24, 0x03, 0x25, 0x03, 0x27, 0x03, 0x29, 0x03, 0x2b, 0x03, 0x2d, 0x03, 0x86, 0x03, 0x87, + 0x03, 0x88, 0x03, 0x89, 0x03, 0x8a, 0x03, 0x8b, 0x03, 0x8c, 0x03, 0x8e, 0x03, 0x8f, 0x03, 0x90, 0x03, 0x91, 0x03, + 0x92, 0x03, 0x93, 0x03, 0x94, 0x03, 0x95, 0x03, 0x96, 0x03, 0x97, 0x03, 0x98, 0x03, 0x99, 0x03, 0x9a, 0x03, 0x9b, + 0x03, 0x9c, 0x03, 0x9d, 0x03, 0xad, 0x03, 0xae, 0x03, 0xaf, 0x03, 0xb0, 0x03, 0xb1, 0x03, 0xb2, 0x03, 0xb3, 0x03, + 0xb4, 0x03, 0xb5, 0x03, 0xb6, 0x03, 0xb7, 0x03, 0xb8, 0x03, 0xb9, 0x03, 0xba, 0x03, 0xbb, 0x03, 0xbc, 0x03, 0xbd, + 0x03, 0xbe, 0x03, 0xbf, 0x03, 0xc0, 0x03, 0xc1, 0x03, 0xc2, 0x03, 0xd3, 0x03, 0xd5, 0x03, 0xd7, 0x03, 0xd9, 0x03, + 0xee, 0x03, 0xf0, 0x03, 0xf2, 0x04, 0x07, 0x04, 0x0d, 0x04, 0x13, 0x04, 0x7d, 0x04, 0x82, 0x04, 0x86, 0x05, 0x07, + 0x05, 0x09, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x02, 0x01, 0xdc, 0x00, 0xeb, 0x02, 0x71, 0x02, + 0x33, 0x02, 0x32, 0x02, 0x31, 0x02, 0x30, 0x02, 0x28, 0x01, 0xe6, 0x01, 0xe5, 0x01, 0xe4, 0x01, 0xe3, 0x01, 0xe2, + 0x01, 0xe1, 0x01, 0xe0, 0x01, 0xdf, 0x01, 0xde, 0x01, 0xdd, 0x01, 0xdc, 0x01, 0xdb, 0x01, 0xda, 0x01, 0xd9, 0x01, + 0xd8, 0x01, 0xd7, 0x01, 0xd6, 0x01, 0xd5, 0x01, 0xd4, 0x01, 0xd3, 0x01, 0xd2, 0x02, 0x64, 0x02, 0x73, 0x03, 0x30, + 0x02, 0x75, 0x02, 0x74, 0x03, 0x2f, 0x01, 0xe3, 0x02, 0x72, 0x02, 0x77, 0x02, 0x52, 0x04, 0xd2, 0x04, 0xd3, 0x01, + 0xea, 0x01, 0xeb, 0x04, 0xd4, 0x04, 0xd5, 0x04, 0xd6, 0x01, 0xec, 0x04, 0xd7, 0x01, 0xed, 0x01, 0xee, 0x01, 0xef, + 0x04, 0xdc, 0x01, 0xf0, 0x01, 0xf0, 0x04, 0xdd, 0x04, 0xde, 0x01, 0xf1, 0x01, 0xf2, 0x01, 0xf3, 0x01, 0xfa, 0x04, + 0xeb, 0x04, 0xec, 0x01, 0xfb, 0x01, 0xfc, 0x01, 0xfd, 0x01, 0xfe, 0x01, 0xff, 0x02, 0x00, 0x04, 0xef, 0x04, 0xf0, + 0x04, 0xf2, 0x04, 0xf5, 0x04, 0xfe, 0x02, 0x02, 0x02, 0x03, 0x02, 0x04, 0x02, 0x05, 0x02, 0x06, 0x02, 0x07, 0x02, + 0x08, 0x02, 0x09, 0x02, 0x0a, 0x02, 0x0b, 0x01, 0xf4, 0x01, 0xf5, 0x01, 0xf6, 0x01, 0xf7, 0x01, 0xf8, 0x01, 0xf9, + 0x02, 0x3b, 0x02, 0x0d, 0x02, 0x0e, 0x02, 0x0f, 0x02, 0x10, 0x04, 0xf8, 0x02, 0x11, 0x02, 0x13, 0x02, 0x14, 0x02, + 0x15, 0x02, 0x17, 0x02, 0x19, 0x02, 0x76, 0x03, 0x31, 0x03, 0x32, 0x03, 0x33, 0x03, 0x34, 0x03, 0x35, 0x03, 0x36, + 0x03, 0x37, 0x03, 0x38, 0x03, 0x39, 0x03, 0x3a, 0x03, 0x3b, 0x03, 0x3c, 0x03, 0x3d, 0x03, 0x3e, 0x03, 0x3f, 0x03, + 0x40, 0x03, 0x41, 0x03, 0x42, 0x03, 0x43, 0x03, 0x44, 0x03, 0x45, 0x03, 0x46, 0x03, 0x47, 0x03, 0x48, 0x03, 0x49, + 0x03, 0x4a, 0x03, 0x4b, 0x03, 0x4c, 0x03, 0x82, 0x03, 0x4d, 0x03, 0x4e, 0x03, 0x4f, 0x03, 0x50, 0x03, 0x51, 0x03, + 0x52, 0x03, 0x53, 0x03, 0x54, 0x03, 0x55, 0x03, 0x56, 0x03, 0x57, 0x03, 0x58, 0x03, 0x59, 0x03, 0x5a, 0x03, 0x5b, + 0x03, 0x5c, 0x03, 0x5d, 0x03, 0x5e, 0x03, 0x5f, 0x03, 0x60, 0x03, 0x61, 0x03, 0x62, 0x04, 0xff, 0x03, 0x64, 0x03, + 0x65, 0x03, 0x66, 0x03, 0x67, 0x03, 0x68, 0x03, 0x69, 0x03, 0x6a, 0x03, 0x6b, 0x03, 0x6c, 0x03, 0x6d, 0x03, 0x6e, + 0x03, 0x6f, 0x03, 0x70, 0x03, 0x71, 0x03, 0x72, 0x03, 0x73, 0x03, 0x74, 0x03, 0x75, 0x05, 0x02, 0x03, 0x76, 0x03, + 0x77, 0x03, 0x79, 0x03, 0x78, 0x03, 0x7a, 0x03, 0x7b, 0x03, 0x7c, 0x03, 0x7d, 0x03, 0x7e, 0x03, 0x7f, 0x03, 0x80, + 0x03, 0x81, 0x03, 0x83, 0x03, 0x84, 0x03, 0x85, 0x05, 0x00, 0x05, 0x01, 0x04, 0xcb, 0x04, 0xcc, 0x04, 0xcd, 0x04, + 0xce, 0x04, 0xd8, 0x04, 0xdb, 0x04, 0xd9, 0x04, 0xda, 0x04, 0xdf, 0x04, 0xe0, 0x04, 0xe1, 0x04, 0xcf, 0x04, 0xd0, + 0x04, 0xd1, 0x04, 0xea, 0x04, 0xed, 0x04, 0xee, 0x04, 0xf1, 0x04, 0xf3, 0x04, 0xf4, 0x02, 0x01, 0x04, 0xf6, 0x04, + 0xe2, 0x04, 0xe3, 0x04, 0xe4, 0x04, 0xe5, 0x04, 0xe6, 0x04, 0xe7, 0x04, 0xe8, 0x04, 0xe9, 0x05, 0x03, 0x05, 0x04, + 0x05, 0x05, 0x05, 0x06, 0x04, 0xf7, 0x04, 0xf9, 0x04, 0xfa, 0x02, 0x18, 0x04, 0xfc, 0x02, 0x1a, 0x04, 0xfd, 0x04, + 0xfb, 0x02, 0x16, 0x02, 0x0c, 0x02, 0x12, 0x05, 0x0b, 0x05, 0x0c, 0x00, 0x01, 0x00, 0xeb, 0x00, 0x0a, 0x00, 0x45, + 0x00, 0x46, 0x00, 0x47, 0x00, 0x48, 0x00, 0x49, 0x00, 0x4a, 0x00, 0x4b, 0x00, 0x4c, 0x00, 0x4d, 0x00, 0x4e, 0x00, + 0x4f, 0x00, 0x50, 0x00, 0x51, 0x00, 0x52, 0x00, 0x53, 0x00, 0x54, 0x00, 0x55, 0x00, 0x56, 0x00, 0x57, 0x00, 0x58, + 0x00, 0x59, 0x00, 0x5a, 0x00, 0x5b, 0x00, 0x5c, 0x00, 0x5d, 0x00, 0x5e, 0x00, 0x85, 0x00, 0x86, 0x00, 0x87, 0x00, + 0x89, 0x00, 0x8a, 0x00, 0x8b, 0x00, 0x8d, 0x00, 0x90, 0x00, 0x92, 0x00, 0x94, 0x00, 0xbb, 0x00, 0xbc, 0x00, 0xbd, + 0x00, 0xbe, 0x00, 0xbf, 0x00, 0xc0, 0x00, 0xc1, 0x00, 0xc2, 0x00, 0xc3, 0x00, 0xc4, 0x00, 0xc5, 0x00, 0xc6, 0x00, + 0xc7, 0x00, 0xc8, 0x00, 0xc9, 0x00, 0xca, 0x00, 0xcb, 0x00, 0xcc, 0x00, 0xcd, 0x00, 0xce, 0x00, 0xea, 0x00, 0xeb, + 0x00, 0xec, 0x00, 0xed, 0x00, 0xee, 0x00, 0xef, 0x00, 0xf0, 0x00, 0xf1, 0x00, 0xf2, 0x00, 0xf3, 0x00, 0xf4, 0x00, + 0xf5, 0x00, 0xf6, 0x00, 0xf7, 0x00, 0xf8, 0x00, 0xf9, 0x00, 0xfa, 0x00, 0xfb, 0x00, 0xfc, 0x00, 0xfd, 0x00, 0xfe, + 0x00, 0xff, 0x01, 0x00, 0x01, 0x01, 0x01, 0x02, 0x01, 0x03, 0x01, 0x04, 0x01, 0x05, 0x01, 0x06, 0x01, 0x07, 0x01, + 0x30, 0x01, 0x34, 0x01, 0x36, 0x01, 0x38, 0x01, 0x3a, 0x01, 0x3c, 0x01, 0x42, 0x01, 0x44, 0x01, 0x46, 0x01, 0x4a, + 0x01, 0x4d, 0x01, 0x5a, 0x02, 0x7c, 0x02, 0x7e, 0x02, 0x9a, 0x02, 0x9b, 0x02, 0x9c, 0x02, 0x9d, 0x02, 0x9e, 0x02, + 0x9f, 0x02, 0xa0, 0x02, 0xa1, 0x02, 0xa2, 0x02, 0xa3, 0x02, 0xa4, 0x02, 0xa5, 0x02, 0xa6, 0x02, 0xa7, 0x02, 0xa8, + 0x02, 0xa9, 0x02, 0xaa, 0x02, 0xab, 0x02, 0xac, 0x02, 0xad, 0x02, 0xae, 0x02, 0xaf, 0x02, 0xb0, 0x02, 0xb1, 0x02, + 0xb2, 0x02, 0xb3, 0x02, 0xb4, 0x02, 0xb5, 0x02, 0xb7, 0x02, 0xb9, 0x02, 0xbb, 0x02, 0xbd, 0x02, 0xbf, 0x02, 0xc1, + 0x02, 0xc3, 0x02, 0xc5, 0x02, 0xc7, 0x02, 0xc9, 0x02, 0xcb, 0x02, 0xcd, 0x02, 0xcf, 0x02, 0xd1, 0x02, 0xd3, 0x02, + 0xd5, 0x02, 0xd7, 0x02, 0xd9, 0x02, 0xdb, 0x02, 0xdd, 0x02, 0xdf, 0x02, 0xe1, 0x02, 0xe4, 0x02, 0xe6, 0x02, 0xe8, + 0x02, 0xea, 0x02, 0xec, 0x02, 0xee, 0x02, 0xf0, 0x02, 0xf2, 0x02, 0xf4, 0x02, 0xf6, 0x02, 0xf9, 0x02, 0xfb, 0x02, + 0xfd, 0x02, 0xff, 0x03, 0x01, 0x03, 0x03, 0x03, 0x05, 0x03, 0x07, 0x03, 0x09, 0x03, 0x0b, 0x03, 0x0d, 0x03, 0x0f, + 0x03, 0x11, 0x03, 0x13, 0x03, 0x15, 0x03, 0x17, 0x03, 0x19, 0x03, 0x1b, 0x03, 0x1d, 0x03, 0x1f, 0x03, 0x21, 0x03, + 0x23, 0x03, 0x26, 0x03, 0x28, 0x03, 0x2a, 0x03, 0x2c, 0x03, 0x2e, 0x03, 0x9e, 0x03, 0x9f, 0x03, 0xa0, 0x03, 0xa1, + 0x03, 0xa3, 0x03, 0xa4, 0x03, 0xa5, 0x03, 0xa6, 0x03, 0xa7, 0x03, 0xa8, 0x03, 0xa9, 0x03, 0xaa, 0x03, 0xab, 0x03, + 0xac, 0x03, 0xc3, 0x03, 0xc4, 0x03, 0xc5, 0x03, 0xc6, 0x03, 0xc7, 0x03, 0xc8, 0x03, 0xc9, 0x03, 0xca, 0x03, 0xcb, + 0x03, 0xcc, 0x03, 0xcd, 0x03, 0xce, 0x03, 0xcf, 0x03, 0xd0, 0x03, 0xd1, 0x03, 0xd2, 0x03, 0xd4, 0x03, 0xd6, 0x03, + 0xd8, 0x03, 0xda, 0x03, 0xef, 0x03, 0xf1, 0x03, 0xf3, 0x04, 0x01, 0x04, 0x08, 0x04, 0x0e, 0x04, 0x14, 0x04, 0x7e, + 0x04, 0x7f, 0x04, 0x83, 0x04, 0x87, 0x05, 0x08, 0x05, 0x0a, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x12, 0x00, + 0x2a, 0x00, 0x42, 0x00, 0x5a, 0x00, 0x72, 0x00, 0x8a, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x12, 0x00, 0x01, + 0x00, 0x90, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x01, 0x00, 0x4d, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x12, 0x00, 0x01, 0x00, 0x78, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x01, 0x00, 0x4e, + 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x12, 0x00, 0x01, 0x00, 0x60, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, + 0x01, 0x00, 0x01, 0x02, 0xe1, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x12, 0x00, 0x01, 0x00, 0x48, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x01, 0x03, 0xce, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x12, 0x00, + 0x01, 0x00, 0x30, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x01, 0x03, 0xd0, 0x00, 0x03, 0x00, 0x00, + 0x00, 0x01, 0x00, 0x12, 0x00, 0x01, 0x00, 0x18, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x01, 0x04, + 0x49, 0x00, 0x02, 0x00, 0x02, 0x00, 0xa8, 0x00, 0xac, 0x00, 0x00, 0x01, 0x24, 0x01, 0x27, 0x00, 0x05, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x02, 0x00, 0x12, 0x00, 0x06, 0x02, 0x61, 0x02, 0x5f, 0x02, 0x62, 0x02, + 0x63, 0x02, 0x60, 0x05, 0x0d, 0x00, 0x01, 0x00, 0x06, 0x00, 0x4d, 0x00, 0x4e, 0x02, 0xe1, 0x03, 0xce, 0x03, 0xd0, + 0x04, 0x49, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x06, 0x32, 0x00, 0x36, 0x00, 0x72, 0x00, + 0xa4, 0x00, 0xae, 0x00, 0xb8, 0x00, 0xca, 0x00, 0xfc, 0x01, 0x0e, 0x01, 0x18, 0x01, 0x4a, 0x01, 0x64, 0x01, 0x7e, + 0x01, 0x90, 0x01, 0xba, 0x01, 0xf6, 0x02, 0x00, 0x02, 0x22, 0x02, 0x3c, 0x02, 0x4e, 0x02, 0x8a, 0x02, 0x9c, 0x02, + 0xb6, 0x02, 0xe0, 0x02, 0xf2, 0x03, 0x24, 0x03, 0x2e, 0x03, 0x38, 0x03, 0x4a, 0x03, 0x7c, 0x03, 0x86, 0x03, 0x90, + 0x03, 0x9a, 0x03, 0xb4, 0x03, 0xce, 0x03, 0xe0, 0x04, 0x0a, 0x04, 0x3c, 0x04, 0x46, 0x04, 0x68, 0x04, 0x82, 0x04, + 0x94, 0x04, 0xc6, 0x04, 0xd8, 0x04, 0xf2, 0x05, 0x1c, 0x05, 0x2e, 0x05, 0x38, 0x05, 0x42, 0x05, 0x4c, 0x05, 0x56, + 0x05, 0x80, 0x05, 0xaa, 0x05, 0xd4, 0x05, 0xfe, 0x06, 0x28, 0x00, 0x06, 0x00, 0x0e, 0x00, 0x14, 0x00, 0x1a, 0x00, + 0x20, 0x00, 0x26, 0x00, 0x2c, 0x02, 0x80, 0x00, 0x02, 0x00, 0xa9, 0x04, 0x1e, 0x00, 0x02, 0x00, 0xad, 0x02, 0x7f, + 0x00, 0x02, 0x00, 0xa8, 0x04, 0x20, 0x00, 0x02, 0x00, 0xab, 0x02, 0x82, 0x00, 0x02, 0x00, 0xaa, 0x04, 0x99, 0x00, + 0x02, 0x00, 0xac, 0x00, 0x01, 0x00, 0x04, 0x04, 0xa6, 0x00, 0x02, 0x00, 0xad, 0x00, 0x01, 0x00, 0x04, 0x02, 0xbc, + 0x00, 0x02, 0x00, 0xa9, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0c, 0x04, 0xaa, 0x00, 0x02, 0x01, 0xba, 0x04, 0xa8, 0x00, + 0x02, 0x00, 0xad, 0x00, 0x06, 0x00, 0x0e, 0x00, 0x14, 0x00, 0x1a, 0x00, 0x20, 0x00, 0x26, 0x00, 0x2c, 0x02, 0x88, + 0x00, 0x02, 0x00, 0xa9, 0x04, 0x36, 0x00, 0x02, 0x00, 0xad, 0x02, 0x87, 0x00, 0x02, 0x00, 0xa8, 0x04, 0x38, 0x00, + 0x02, 0x00, 0xab, 0x04, 0x3a, 0x00, 0x02, 0x00, 0xaa, 0x04, 0x9b, 0x00, 0x02, 0x00, 0xac, 0x00, 0x02, 0x00, 0x06, + 0x00, 0x0c, 0x04, 0x95, 0x00, 0x02, 0x00, 0xa9, 0x02, 0xd6, 0x00, 0x02, 0x01, 0xba, 0x00, 0x01, 0x00, 0x04, 0x04, + 0xac, 0x00, 0x02, 0x00, 0xad, 0x00, 0x06, 0x00, 0x0e, 0x00, 0x14, 0x00, 0x1a, 0x00, 0x20, 0x00, 0x26, 0x00, 0x2c, + 0x02, 0x8c, 0x00, 0x02, 0x00, 0xa9, 0x04, 0x48, 0x00, 0x02, 0x00, 0xad, 0x02, 0x8b, 0x00, 0x02, 0x00, 0xa8, 0x04, + 0x46, 0x00, 0x02, 0x00, 0xab, 0x02, 0xda, 0x00, 0x02, 0x00, 0xaa, 0x04, 0x9d, 0x00, 0x02, 0x00, 0xac, 0x00, 0x03, + 0x00, 0x08, 0x00, 0x0e, 0x00, 0x14, 0x04, 0xae, 0x00, 0x02, 0x00, 0xa9, 0x02, 0xe7, 0x00, 0x02, 0x01, 0xba, 0x04, + 0xb0, 0x00, 0x02, 0x00, 0xad, 0x00, 0x03, 0x00, 0x08, 0x00, 0x0e, 0x00, 0x14, 0x02, 0xe9, 0x00, 0x02, 0x00, 0xa9, + 0x02, 0xeb, 0x00, 0x02, 0x01, 0xba, 0x04, 0xb2, 0x00, 0x02, 0x00, 0xad, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0c, 0x03, + 0xe0, 0x00, 0x02, 0x00, 0xa9, 0x04, 0xb4, 0x00, 0x02, 0x00, 0xad, 0x00, 0x05, 0x00, 0x0c, 0x00, 0x12, 0x00, 0x18, + 0x00, 0x1e, 0x00, 0x24, 0x02, 0xf1, 0x00, 0x02, 0x00, 0xa9, 0x02, 0xf3, 0x00, 0x02, 0x01, 0xba, 0x04, 0xb6, 0x00, + 0x02, 0x00, 0xad, 0x04, 0x97, 0x00, 0x02, 0x00, 0xa8, 0x02, 0x8f, 0x00, 0x02, 0x00, 0xaa, 0x00, 0x07, 0x00, 0x10, + 0x00, 0x18, 0x00, 0x1e, 0x00, 0x24, 0x00, 0x2a, 0x00, 0x30, 0x00, 0x36, 0x04, 0xb8, 0x00, 0x03, 0x00, 0xaa, 0x00, + 0xa9, 0x02, 0x91, 0x00, 0x02, 0x00, 0xa9, 0x04, 0x4a, 0x00, 0x02, 0x00, 0xad, 0x02, 0x90, 0x00, 0x02, 0x00, 0xa8, + 0x04, 0x4c, 0x00, 0x02, 0x00, 0xab, 0x02, 0x93, 0x00, 0x02, 0x00, 0xaa, 0x04, 0x9f, 0x00, 0x02, 0x00, 0xac, 0x00, + 0x01, 0x00, 0x04, 0x04, 0xb9, 0x00, 0x02, 0x00, 0xa9, 0x00, 0x04, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x16, 0x00, 0x1c, + 0x02, 0xfe, 0x00, 0x02, 0x00, 0xa9, 0x03, 0x00, 0x00, 0x02, 0x01, 0xba, 0x04, 0xbb, 0x00, 0x02, 0x00, 0xad, 0x04, + 0xa1, 0x00, 0x02, 0x00, 0xac, 0x00, 0x03, 0x00, 0x08, 0x00, 0x0e, 0x00, 0x14, 0x03, 0x04, 0x00, 0x02, 0x00, 0xa9, + 0x03, 0x0a, 0x00, 0x02, 0x01, 0xba, 0x04, 0xbd, 0x00, 0x02, 0x00, 0xad, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0c, 0x03, + 0x0e, 0x00, 0x02, 0x01, 0xba, 0x04, 0xbf, 0x00, 0x02, 0x00, 0xad, 0x00, 0x07, 0x00, 0x10, 0x00, 0x18, 0x00, 0x1e, + 0x00, 0x24, 0x00, 0x2a, 0x00, 0x30, 0x00, 0x36, 0x04, 0xc1, 0x00, 0x03, 0x00, 0xaa, 0x00, 0xa9, 0x02, 0x96, 0x00, + 0x02, 0x00, 0xa9, 0x04, 0x62, 0x00, 0x02, 0x00, 0xad, 0x02, 0x95, 0x00, 0x02, 0x00, 0xa8, 0x04, 0x64, 0x00, 0x02, + 0x00, 0xab, 0x03, 0x14, 0x00, 0x02, 0x00, 0xaa, 0x04, 0xa3, 0x00, 0x02, 0x00, 0xac, 0x00, 0x02, 0x00, 0x06, 0x00, + 0x0c, 0x04, 0xc4, 0x00, 0x02, 0x00, 0xad, 0x04, 0xc2, 0x00, 0x02, 0x00, 0xaa, 0x00, 0x03, 0x00, 0x08, 0x00, 0x0e, + 0x00, 0x14, 0x03, 0xd5, 0x00, 0x02, 0x00, 0xa9, 0x04, 0xc6, 0x00, 0x02, 0x00, 0xad, 0x03, 0xd3, 0x00, 0x02, 0x00, + 0xa8, 0x00, 0x05, 0x00, 0x0c, 0x00, 0x12, 0x00, 0x18, 0x00, 0x1e, 0x00, 0x24, 0x02, 0x99, 0x00, 0x02, 0x00, 0xa9, + 0x04, 0x70, 0x00, 0x02, 0x00, 0xad, 0x03, 0xd9, 0x00, 0x02, 0x00, 0xa8, 0x04, 0x72, 0x00, 0x02, 0x00, 0xab, 0x04, + 0x74, 0x00, 0x02, 0x00, 0xaa, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0c, 0x03, 0x25, 0x00, 0x02, 0x00, 0xa9, 0x04, 0xc8, + 0x00, 0x02, 0x00, 0xad, 0x00, 0x06, 0x00, 0x0e, 0x00, 0x14, 0x00, 0x1a, 0x00, 0x20, 0x00, 0x26, 0x00, 0x2c, 0x02, + 0x9b, 0x00, 0x02, 0x00, 0xa9, 0x04, 0x1f, 0x00, 0x02, 0x00, 0xad, 0x02, 0x9a, 0x00, 0x02, 0x00, 0xa8, 0x04, 0x21, + 0x00, 0x02, 0x00, 0xab, 0x02, 0x9d, 0x00, 0x02, 0x00, 0xaa, 0x04, 0x9a, 0x00, 0x02, 0x00, 0xac, 0x00, 0x01, 0x00, + 0x04, 0x04, 0xa7, 0x00, 0x02, 0x00, 0xad, 0x00, 0x01, 0x00, 0x04, 0x02, 0xbd, 0x00, 0x02, 0x00, 0xa9, 0x00, 0x02, + 0x00, 0x06, 0x00, 0x0c, 0x04, 0xab, 0x00, 0x02, 0x01, 0xba, 0x04, 0xa9, 0x00, 0x02, 0x00, 0xad, 0x00, 0x06, 0x00, + 0x0e, 0x00, 0x14, 0x00, 0x1a, 0x00, 0x20, 0x00, 0x26, 0x00, 0x2c, 0x02, 0xa3, 0x00, 0x02, 0x00, 0xa9, 0x04, 0x37, + 0x00, 0x02, 0x00, 0xad, 0x02, 0xa2, 0x00, 0x02, 0x00, 0xa8, 0x04, 0x39, 0x00, 0x02, 0x00, 0xab, 0x04, 0x3b, 0x00, + 0x02, 0x00, 0xaa, 0x04, 0x9c, 0x00, 0x02, 0x00, 0xac, 0x00, 0x01, 0x00, 0x04, 0x04, 0x96, 0x00, 0x02, 0x00, 0xa9, + 0x00, 0x01, 0x00, 0x04, 0x04, 0xad, 0x00, 0x02, 0x00, 0xad, 0x00, 0x01, 0x00, 0x04, 0x04, 0x49, 0x00, 0x02, 0x00, + 0xad, 0x00, 0x03, 0x00, 0x08, 0x00, 0x0e, 0x00, 0x14, 0x04, 0xaf, 0x00, 0x02, 0x00, 0xa9, 0x02, 0xe8, 0x00, 0x02, + 0x01, 0xba, 0x04, 0xb1, 0x00, 0x02, 0x00, 0xad, 0x00, 0x03, 0x00, 0x08, 0x00, 0x0e, 0x00, 0x14, 0x02, 0xea, 0x00, + 0x02, 0x00, 0xa9, 0x02, 0xec, 0x00, 0x02, 0x01, 0xba, 0x04, 0xb3, 0x00, 0x02, 0x00, 0xad, 0x00, 0x02, 0x00, 0x06, + 0x00, 0x0c, 0x03, 0xe1, 0x00, 0x02, 0x00, 0xa9, 0x04, 0xb5, 0x00, 0x02, 0x00, 0xad, 0x00, 0x05, 0x00, 0x0c, 0x00, + 0x12, 0x00, 0x18, 0x00, 0x1e, 0x00, 0x24, 0x02, 0xf2, 0x00, 0x02, 0x00, 0xa9, 0x02, 0xf4, 0x00, 0x02, 0x01, 0xba, + 0x04, 0xb7, 0x00, 0x02, 0x00, 0xad, 0x04, 0x98, 0x00, 0x02, 0x00, 0xa8, 0x02, 0xaa, 0x00, 0x02, 0x00, 0xaa, 0x00, + 0x06, 0x00, 0x0e, 0x00, 0x14, 0x00, 0x1a, 0x00, 0x20, 0x00, 0x26, 0x00, 0x2c, 0x02, 0xac, 0x00, 0x02, 0x00, 0xa9, + 0x04, 0x4b, 0x00, 0x02, 0x00, 0xad, 0x02, 0xab, 0x00, 0x02, 0x00, 0xa8, 0x04, 0x4d, 0x00, 0x02, 0x00, 0xab, 0x02, + 0xae, 0x00, 0x02, 0x00, 0xaa, 0x04, 0xa0, 0x00, 0x02, 0x00, 0xac, 0x00, 0x01, 0x00, 0x04, 0x04, 0xba, 0x00, 0x02, + 0x00, 0xa9, 0x00, 0x04, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x16, 0x00, 0x1c, 0x02, 0xff, 0x00, 0x02, 0x00, 0xa9, 0x03, + 0x01, 0x00, 0x02, 0x01, 0xba, 0x04, 0xbc, 0x00, 0x02, 0x00, 0xad, 0x04, 0xa2, 0x00, 0x02, 0x00, 0xac, 0x00, 0x03, + 0x00, 0x08, 0x00, 0x0e, 0x00, 0x14, 0x03, 0x05, 0x00, 0x02, 0x00, 0xa9, 0x03, 0x0b, 0x00, 0x02, 0x01, 0xba, 0x04, + 0xbe, 0x00, 0x02, 0x00, 0xad, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0c, 0x03, 0x0f, 0x00, 0x02, 0x01, 0xba, 0x04, 0xc0, + 0x00, 0x02, 0x00, 0xad, 0x00, 0x06, 0x00, 0x0e, 0x00, 0x14, 0x00, 0x1a, 0x00, 0x20, 0x00, 0x26, 0x00, 0x2c, 0x02, + 0xb1, 0x00, 0x02, 0x00, 0xa9, 0x04, 0x63, 0x00, 0x02, 0x00, 0xad, 0x02, 0xb0, 0x00, 0x02, 0x00, 0xa8, 0x04, 0x65, + 0x00, 0x02, 0x00, 0xab, 0x03, 0x15, 0x00, 0x02, 0x00, 0xaa, 0x04, 0xa4, 0x00, 0x02, 0x00, 0xac, 0x00, 0x02, 0x00, + 0x06, 0x00, 0x0c, 0x04, 0xc5, 0x00, 0x02, 0x00, 0xad, 0x04, 0xc3, 0x00, 0x02, 0x00, 0xaa, 0x00, 0x03, 0x00, 0x08, + 0x00, 0x0e, 0x00, 0x14, 0x03, 0xd6, 0x00, 0x02, 0x00, 0xa9, 0x04, 0xc7, 0x00, 0x02, 0x00, 0xad, 0x03, 0xd4, 0x00, + 0x02, 0x00, 0xa8, 0x00, 0x05, 0x00, 0x0c, 0x00, 0x12, 0x00, 0x18, 0x00, 0x1e, 0x00, 0x24, 0x02, 0xb4, 0x00, 0x02, + 0x00, 0xa9, 0x04, 0x71, 0x00, 0x02, 0x00, 0xad, 0x03, 0xda, 0x00, 0x02, 0x00, 0xa8, 0x04, 0x73, 0x00, 0x02, 0x00, + 0xab, 0x04, 0x75, 0x00, 0x02, 0x00, 0xaa, 0x00, 0x02, 0x00, 0x06, 0x00, 0x0c, 0x03, 0x26, 0x00, 0x02, 0x00, 0xa9, + 0x04, 0xc9, 0x00, 0x02, 0x00, 0xad, 0x00, 0x01, 0x00, 0x04, 0x03, 0x2b, 0x00, 0x02, 0x00, 0xa9, 0x00, 0x01, 0x00, + 0x04, 0x03, 0x2d, 0x00, 0x02, 0x00, 0xa9, 0x00, 0x01, 0x00, 0x04, 0x03, 0x2c, 0x00, 0x02, 0x00, 0xa9, 0x00, 0x01, + 0x00, 0x04, 0x03, 0x2e, 0x00, 0x02, 0x00, 0xa9, 0x00, 0x05, 0x00, 0x0c, 0x00, 0x12, 0x00, 0x18, 0x00, 0x1e, 0x00, + 0x24, 0x02, 0xa7, 0x00, 0x02, 0x00, 0xa9, 0x02, 0xa6, 0x00, 0x02, 0x00, 0xa8, 0x04, 0x47, 0x00, 0x02, 0x00, 0xab, + 0x02, 0xdb, 0x00, 0x02, 0x00, 0xaa, 0x04, 0x9e, 0x00, 0x02, 0x00, 0xac, 0x00, 0x05, 0x00, 0x0c, 0x00, 0x12, 0x00, + 0x18, 0x00, 0x1e, 0x00, 0x24, 0x04, 0x58, 0x00, 0x02, 0x00, 0xa9, 0x04, 0x60, 0x00, 0x02, 0x00, 0xad, 0x04, 0x5a, + 0x00, 0x02, 0x00, 0xa8, 0x04, 0x5c, 0x00, 0x02, 0x00, 0xab, 0x04, 0x5e, 0x00, 0x02, 0x00, 0xaa, 0x00, 0x05, 0x00, + 0x0c, 0x00, 0x12, 0x00, 0x18, 0x00, 0x1e, 0x00, 0x24, 0x04, 0x59, 0x00, 0x02, 0x00, 0xa9, 0x04, 0x61, 0x00, 0x02, + 0x00, 0xad, 0x04, 0x5b, 0x00, 0x02, 0x00, 0xa8, 0x04, 0x5d, 0x00, 0x02, 0x00, 0xab, 0x04, 0x5f, 0x00, 0x02, 0x00, + 0xaa, 0x00, 0x05, 0x00, 0x0c, 0x00, 0x12, 0x00, 0x18, 0x00, 0x1e, 0x00, 0x24, 0x04, 0x66, 0x00, 0x02, 0x00, 0xa9, + 0x04, 0x6e, 0x00, 0x02, 0x00, 0xad, 0x04, 0x68, 0x00, 0x02, 0x00, 0xa8, 0x04, 0x6a, 0x00, 0x02, 0x00, 0xab, 0x04, + 0x6c, 0x00, 0x02, 0x00, 0xaa, 0x00, 0x05, 0x00, 0x0c, 0x00, 0x12, 0x00, 0x18, 0x00, 0x1e, 0x00, 0x24, 0x04, 0x67, + 0x00, 0x02, 0x00, 0xa9, 0x04, 0x6f, 0x00, 0x02, 0x00, 0xad, 0x04, 0x69, 0x00, 0x02, 0x00, 0xa8, 0x04, 0x6b, 0x00, + 0x02, 0x00, 0xab, 0x04, 0x6d, 0x00, 0x02, 0x00, 0xaa, 0x00, 0x01, 0x00, 0x04, 0x04, 0xa5, 0x00, 0x02, 0x00, 0xa9, + 0x00, 0x02, 0x00, 0x11, 0x00, 0x25, 0x00, 0x29, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x2d, 0x00, 0x05, 0x00, 0x2f, 0x00, + 0x34, 0x00, 0x08, 0x00, 0x36, 0x00, 0x3b, 0x00, 0x0e, 0x00, 0x3d, 0x00, 0x3e, 0x00, 0x14, 0x00, 0x45, 0x00, 0x49, + 0x00, 0x16, 0x00, 0x4b, 0x00, 0x4d, 0x00, 0x1b, 0x00, 0x4f, 0x00, 0x54, 0x00, 0x1e, 0x00, 0x56, 0x00, 0x5b, 0x00, + 0x24, 0x00, 0x5d, 0x00, 0x5e, 0x00, 0x2a, 0x00, 0x81, 0x00, 0x81, 0x00, 0x2c, 0x00, 0x83, 0x00, 0x83, 0x00, 0x2d, + 0x00, 0x86, 0x00, 0x86, 0x00, 0x2e, 0x00, 0x89, 0x00, 0x89, 0x00, 0x2f, 0x00, 0x8d, 0x00, 0x8d, 0x00, 0x30, 0x00, + 0x98, 0x00, 0x9b, 0x00, 0x31, 0x00, 0xd0, 0x00, 0xd0, 0x00, 0x35, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, + 0x00, 0x01, 0x00, 0x06, 0x00, 0x02, 0x00, 0x01, 0x00, 0x02, 0x03, 0x08, 0x03, 0x09, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x08, 0x00, 0x02, 0x00, 0x12, 0x00, 0x06, 0x05, 0x07, 0x05, 0x08, 0x05, 0x09, 0x05, 0x0a, 0x05, 0x0b, + 0x05, 0x0c, 0x00, 0x01, 0x00, 0x06, 0x02, 0xba, 0x02, 0xbb, 0x02, 0xcc, 0x02, 0xcd, 0x03, 0x4f, 0x03, 0x58, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x06, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x01, 0x7b, + 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x40, 0x00, 0x01, 0x00, 0x08, 0x00, 0x02, 0x00, + 0x06, 0x00, 0x0e, 0x01, 0xbe, 0x00, 0x03, 0x00, 0x4a, 0x00, 0x4d, 0x01, 0xbc, 0x00, 0x02, 0x00, 0x4d, 0x00, 0x04, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x1c, 0x00, 0x01, 0x00, 0x08, 0x00, 0x02, 0x00, 0x06, 0x00, + 0x0e, 0x01, 0xbf, 0x00, 0x03, 0x00, 0x4a, 0x00, 0x50, 0x01, 0xbd, 0x00, 0x02, 0x00, 0x50, 0x00, 0x01, 0x00, 0x01, + 0x00, 0x4a, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x2a, 0x00, 0x03, 0x00, 0x0c, 0x00, + 0x16, 0x00, 0x20, 0x00, 0x01, 0x00, 0x04, 0x01, 0xbb, 0x00, 0x02, 0x00, 0x4a, 0x00, 0x01, 0x00, 0x04, 0x01, 0xc1, + 0x00, 0x02, 0x00, 0x58, 0x00, 0x01, 0x00, 0x04, 0x01, 0xc0, 0x00, 0x02, 0x00, 0x58, 0x00, 0x01, 0x00, 0x03, 0x00, + 0x4a, 0x00, 0x57, 0x00, 0x95, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x06, 0x01, 0xde, + 0x00, 0x01, 0x00, 0x01, 0x00, 0x4b, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x06, 0x01, + 0x6f, 0x00, 0x01, 0x00, 0x01, 0x00, 0xbb, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x06, + 0x01, 0xf5, 0x00, 0x01, 0x00, 0x01, 0x00, 0x36, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x02, 0x00, + 0x1c, 0x00, 0x02, 0x02, 0x2c, 0x02, 0x2d, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x02, 0x00, 0x0a, + 0x00, 0x02, 0x02, 0x2e, 0x02, 0x2f, 0x00, 0x01, 0x00, 0x02, 0x00, 0x2f, 0x00, 0x4f, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x08, 0x00, 0x02, 0x00, 0x1e, 0x00, 0x0c, 0x02, 0x45, 0x02, 0x47, 0x02, 0x46, 0x02, 0x48, 0x02, 0x49, + 0x02, 0x67, 0x02, 0x68, 0x02, 0x69, 0x02, 0x6a, 0x02, 0x6b, 0x02, 0x6c, 0x02, 0x6d, 0x00, 0x01, 0x00, 0x0c, 0x00, + 0x27, 0x00, 0x28, 0x00, 0x2b, 0x00, 0x33, 0x00, 0x35, 0x00, 0x46, 0x00, 0x47, 0x00, 0x48, 0x00, 0x4b, 0x00, 0x53, + 0x00, 0x54, 0x00, 0x55, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x02, 0x00, 0x0c, 0x00, 0x03, 0x02, + 0x6e, 0x02, 0x6f, 0x02, 0x6f, 0x00, 0x01, 0x00, 0x03, 0x00, 0x49, 0x00, 0x4b, 0x02, 0x6a, 0x00, 0x01, 0x00, 0x00, + 0x00, 0x01, 0x00, 0x08, 0x00, 0x02, 0x00, 0x2e, 0x00, 0x14, 0x02, 0x5a, 0x02, 0x5e, 0x02, 0x58, 0x02, 0x55, 0x02, + 0x57, 0x02, 0x56, 0x02, 0x5b, 0x02, 0x59, 0x02, 0x5d, 0x02, 0x5c, 0x02, 0x4f, 0x02, 0x4a, 0x02, 0x4b, 0x02, 0x4c, + 0x02, 0x4d, 0x02, 0x4e, 0x00, 0x1a, 0x00, 0x1c, 0x02, 0x53, 0x02, 0x65, 0x00, 0x02, 0x00, 0x04, 0x00, 0x14, 0x00, + 0x1d, 0x00, 0x00, 0x02, 0x66, 0x02, 0x66, 0x00, 0x0a, 0x02, 0x70, 0x02, 0x70, 0x00, 0x0b, 0x04, 0x8d, 0x04, 0x94, + 0x00, 0x0c, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x02, 0x00, 0x2e, 0x00, 0x14, 0x04, 0x94, 0x02, + 0x70, 0x04, 0x8d, 0x04, 0x8e, 0x04, 0x8f, 0x04, 0x90, 0x04, 0x91, 0x02, 0x66, 0x04, 0x92, 0x04, 0x93, 0x02, 0x4c, + 0x02, 0x4e, 0x02, 0x4d, 0x02, 0x4b, 0x02, 0x4f, 0x02, 0x65, 0x00, 0x1a, 0x02, 0x53, 0x00, 0x1c, 0x02, 0x4a, 0x00, + 0x02, 0x00, 0x02, 0x00, 0x14, 0x00, 0x1d, 0x00, 0x00, 0x02, 0x55, 0x02, 0x5e, 0x00, 0x0a, 0x00, 0x01, 0x00, 0x00, + 0x00, 0x01, 0x00, 0x08, 0x00, 0x02, 0x00, 0x2e, 0x00, 0x14, 0x02, 0x5b, 0x02, 0x5d, 0x02, 0x5e, 0x02, 0x58, 0x02, + 0x55, 0x02, 0x57, 0x02, 0x56, 0x02, 0x59, 0x02, 0x5c, 0x02, 0x5a, 0x00, 0x1b, 0x00, 0x15, 0x00, 0x16, 0x00, 0x17, + 0x00, 0x18, 0x00, 0x19, 0x00, 0x1a, 0x00, 0x1c, 0x00, 0x1d, 0x00, 0x14, 0x00, 0x01, 0x00, 0x14, 0x00, 0x1a, 0x00, + 0x1c, 0x02, 0x4a, 0x02, 0x4b, 0x02, 0x4c, 0x02, 0x4d, 0x02, 0x4e, 0x02, 0x4f, 0x02, 0x53, 0x02, 0x65, 0x02, 0x66, + 0x02, 0x70, 0x04, 0x8d, 0x04, 0x8e, 0x04, 0x8f, 0x04, 0x90, 0x04, 0x91, 0x04, 0x92, 0x04, 0x93, 0x04, 0x94, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x02, 0x00, 0x2e, 0x00, 0x14, 0x04, 0x91, 0x04, 0x92, 0x02, 0x70, + 0x04, 0x8d, 0x04, 0x8e, 0x04, 0x8f, 0x04, 0x90, 0x02, 0x66, 0x04, 0x93, 0x00, 0x17, 0x00, 0x19, 0x00, 0x18, 0x00, + 0x16, 0x00, 0x1b, 0x00, 0x14, 0x00, 0x1a, 0x00, 0x1d, 0x00, 0x1c, 0x00, 0x15, 0x04, 0x94, 0x00, 0x02, 0x00, 0x06, + 0x00, 0x1a, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x1c, 0x00, 0x01, 0x02, 0x4a, 0x02, 0x4f, 0x00, 0x02, 0x02, + 0x53, 0x02, 0x53, 0x00, 0x08, 0x02, 0x55, 0x02, 0x5e, 0x00, 0x09, 0x02, 0x65, 0x02, 0x65, 0x00, 0x13, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x06, 0x01, 0x81, 0x00, 0x01, 0x00, 0x01, 0x00, 0x13, 0x00, + 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x03, 0x00, 0x01, 0x00, 0x12, 0x00, 0x01, 0x00, 0x6c, 0x00, 0x00, + 0x00, 0x01, 0x00, 0x00, 0x00, 0x18, 0x00, 0x02, 0x00, 0x03, 0x01, 0x94, 0x01, 0x94, 0x00, 0x00, 0x01, 0xc5, 0x01, + 0xc7, 0x00, 0x01, 0x02, 0x1f, 0x02, 0x25, 0x00, 0x04, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x02, + 0x00, 0x3c, 0x00, 0x0a, 0x01, 0xc7, 0x01, 0xc6, 0x01, 0xc5, 0x02, 0x1f, 0x02, 0x20, 0x02, 0x21, 0x02, 0x22, 0x02, + 0x23, 0x02, 0x24, 0x02, 0x25, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x02, 0x00, 0x1a, 0x00, 0x0a, + 0x02, 0x3e, 0x00, 0x7a, 0x00, 0x73, 0x00, 0x74, 0x02, 0x3f, 0x02, 0x40, 0x02, 0x41, 0x02, 0x42, 0x02, 0x43, 0x02, + 0x44, 0x00, 0x02, 0x00, 0x01, 0x00, 0x14, 0x00, 0x1d, 0x00, 0x00, +}; \ No newline at end of file diff --git a/nvpro_core_legacy/nvvkhl/shaders/bsdf_functions.h b/nvpro_core_legacy/nvvkhl/shaders/bsdf_functions.h new file mode 100644 index 0000000..f7a387a --- /dev/null +++ b/nvpro_core_legacy/nvvkhl/shaders/bsdf_functions.h @@ -0,0 +1,1191 @@ +/* + * Copyright (c) 2019-2025, NVIDIA CORPORATION. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-FileCopyrightText: Copyright (c) 2019-2025, NVIDIA CORPORATION. + * SPDX-License-Identifier: Apache-2.0 + */ + +#ifndef NVVKHL_BSDF_FUNCTIONS_H +#define NVVKHL_BSDF_FUNCTIONS_H 1 + +/* @DOC_START +> Implements bidirectional scattering distribution functions (BSDFs) for +> physically-based rendering systems. + +To use this code, include `bsdf_functions.h`. When a ray hits a surface: +* Create a `PbrMaterial` describing the material at that point +* Call `bsdfEvaluate()` to evaluate the scattering from one direction to + another, or `bsdfSample()` to choose the next ray in the light path. + See these functions' documentation for more information on their parameters + and return values. + +See the vk_gltf_renderer and vk_mini_samples/gltf_raytrace samples for examples +where these functions are used in a Monte Carlo path tracer. + +The returned BSDF values and weights have the cosine term from the rendering +equation included; e.g. the Lambert lobe returns `max(0.0f, cos(N, k1)) / pi`. + +Advanced users can use some of the other functions in this file to evaluate +and sample individual lobes, or subsets of lobes. + +This file also provides `bsdfEvaluateSimple()` and `bsdfSampleSimple()`, which +implement a simpler and faster, though less fully-featured BSDF model. The +simple model only has diffuse, specular, and metallic lobes, while the full +model includes diffuse, transmission, specular, metal, sheen, and clearcoat +lobes (plus support for most glTF extensions). + +Since GLSL doesn't have a distinction between public and private functions, +only functions that are part of the "public API" will have annotations to +appear in README.md. + +This file (and files that it depends on) should be a GLSL/C++ polyglot, and +work so long as GLM has been included: + +```cpp +#undef GLM_FORCE_XYZW_ONLY +#define GLM_FORCE_SWIZZLE +#include +using namespace glm; + +#include +``` + +## Technical Notes + +NVVKHL's BSDFs are based on [the glTF 2.0 specification](https://github.com/KhronosGroup/glTF) and +[the NVIDIA MDL SDK's BSDF implementations](https://github.com/NVIDIA/MDL-SDK/blob/203d5140b1dee89de17b26e828c4333571878629/src/mdl/jit/libbsdf/libbsdf.cpp). + +The largest divergence from the above is that NVVKHL's BSDF model uses a +Fresnel term that depends only on the view and normal vectors, instead of the +half vector. This allows it to compute weights for lobes independently, while +BSDF code would normally need to sample a half vector for layer `i` to +determine the Fresnel weight for layer `i+1`. This can result in slightly +different glossy/diffuse blend weights (e.g. slightly differently shaped +highlights on leather surfaces). + +All lobes are energy conserving (their integral over the sphere is at most 1) +and probability distribution functions (PDFs) integrate to 1 (except for areas +where the sampled direction results in an absorption event). + +All lobes use single-scattering BSDFs. Multiple-scattering lobes are a +potential future improvement. + +Most lobes use GGX normal distribution functions (NDFs) and the uncorrelated +Smith shadowing-maskiung function, except for the diffuse lobe (Lambert BRDF) +and the sheen lobe ([Conty and Kulla's "Charlie" sheen](https://blog.selfshadow.com/publications/s2017-shading-course/#course_content) +and a V-cavity shadowing-masking function). + +@DOC_END */ + +#include "func.h" // cosineSampleHemisphere +#include "ggx.h" // brdfLambertian, .. +#include "bsdf_structs.h" // Bsdf*, +#include "pbr_mat_struct.h" // PbrMaterial + +#ifdef __cplusplus +#define OUT_TYPE(T) T& +#define INOUT_TYPE(T) T& +#define ARRAY_TYPE(T, N, name) std::array name +#else +#define OUT_TYPE(T) out T +#define INOUT_TYPE(T) inout T +#define ARRAY_TYPE(T, N, name) T name[N] +#endif + +/* @DOC_START +# `DIRAC` Define +> Special PDF value returned by `bsdfSample()` to represent an infinite impulse +> or singularity. +@DOC_END */ +#define DIRAC -1.0F + + +/** @DOC_START +# Function `absorptionCoefficient` +> Returns the absorption coefficient of the material. +@DOC_END */ +vec3 absorptionCoefficient(PbrMaterial mat) +{ + return -log(max(mat.attenuationColor, vec3(0.001))) / max(mat.attenuationDistance, 0.001); +} + +/* @DOC_START +# `LOBE_*` Defines +> Indices for lobe weights returned by `computeLobeWeights()`. +@DOC_END */ +#define LOBE_DIFFUSE_REFLECTION 0 +#define LOBE_SPECULAR_TRANSMISSION 1 +#define LOBE_SPECULAR_REFLECTION 2 +#define LOBE_METAL_REFLECTION 3 +#define LOBE_SHEEN_REFLECTION 4 +#define LOBE_CLEARCOAT_REFLECTION 5 +#define LOBE_DIFFUSE_TRANSMISSION 6 +#define LOBE_COUNT 7 + +// The Fresnel factor depends on the cosine between the view vector k1 and the +// half vector, H = normalize(k1 + k2). But during sampling, we don't have k2 +// until we sample a microfacet. So instead, we approximate it. +// For a mirror surface, we have H == N. For a perfectly diffuse surface, k2 +// is sampled in a cosine distribution around N, so H ~ normalize(k1 + N). +// We ad-hoc interpolate between them using the roughness. +float fresnelCosineApproximation(float VdotN, float roughness) +{ + return mix(VdotN, sqrt(0.5F + 0.5F * VdotN), sqrt(roughness)); +} + +/* @DOC_START +# Function `computeLobeWeights` +>Calculates the weights of the individual lobes inside the standard PBR material. + +Returns an array which can be indexed using the `LOBE_*` defines. This can be +used to perform your own lobe sampling. + +Note that `tint` will be changed if the material has iridescence! (It's +convenient to compute the iridescence factor here.) This means you should avoid +passing a material parameter to the `tint` field. Make a temporary instead: +```glsl +vec3 tint = mat.baseColor; +float[LOBE_COUNT] weights = computeLobeWeights(mat, dot(k1, mat.N), tint); +``` +@DOC_END */ +ARRAY_TYPE(float, LOBE_COUNT, ) computeLobeWeights(PbrMaterial mat, float VdotN, INOUT_TYPE(vec3) tint) +{ + float frCoat = 0.0F; + if(mat.clearcoat > 0.0f) + { + float frCosineClearcoat = fresnelCosineApproximation(VdotN, mat.clearcoatRoughness); + frCoat = mat.clearcoat * ior_fresnel(1.5f / mat.ior1, frCosineClearcoat); + } + + // This Fresnel value defines the weighting between dielectric specular reflection and + // the base dielectric BSDFs (diffuse reflection and specular transmission). + float frDielectric = 0; + if(mat.specular > 0) + { + float frCosineDielectric = fresnelCosineApproximation(VdotN, (mat.roughness.x + mat.roughness.y) * 0.5F); + frDielectric = ior_fresnel(mat.ior2 / mat.ior1, frCosineDielectric); + frDielectric *= mat.specular; + } + + // Estimate the iridescence Fresnel factor with the angle to the normal, and + // blend it in. That's good enough for specular reflections. + if(mat.iridescence > 0.0f) + { + // When there is iridescence enabled, use the maximum of the estimated iridescence factor. (Estimated with VdotN, no half-vector H here.) + // With the thinfilm decision this handles the mix between non-iridescence and iridescence strength automatically. + vec3 frIridescence = thin_film_factor(mat.iridescenceThickness, mat.iridescenceIor, mat.ior2, mat.ior1, VdotN); + frDielectric = mix(frDielectric, max(frIridescence.x, max(frIridescence.y, frIridescence.z)), mat.iridescence); + // Modulate the dielectric base lobe (diffuse, transmission) colors by the inverse of the iridescence factor, + // though use the maximum component to not actually generate inverse colors. + tint = mix_rgb(tint, mat.specularColor, frIridescence * mat.iridescence); + } + + float sheen = 0.0f; + if((mat.sheenColor.r != 0.0F || mat.sheenColor.g != 0.0F || mat.sheenColor.b != 0.0F)) + { + sheen = pow(1.0f - abs(VdotN), mat.sheenRoughness); // * luminance(mat.sheenColor); + sheen = sheen / (sheen + 0.5F); + } + + /* + Our model consists of 6 layers. Each layer handles a fraction + of light that didn't hit any layers above it: + + - Clearcoat : clearcoat * schlickFresnel(1.5, VdotN) + - Sheen : sheen + - Metal : metallic + - Specular : specular * schlickFresnel(ior, VdotN) + - Transmission : transmission } + - Diffuse : 1.0 } These two are technically parallel layers + */ + + ARRAY_TYPE(float, LOBE_COUNT, weightLobe); + weightLobe[LOBE_CLEARCOAT_REFLECTION] = 0; + weightLobe[LOBE_SHEEN_REFLECTION] = 0; + weightLobe[LOBE_METAL_REFLECTION] = 0; + weightLobe[LOBE_SPECULAR_REFLECTION] = 0; + weightLobe[LOBE_SPECULAR_TRANSMISSION] = 0; + weightLobe[LOBE_DIFFUSE_TRANSMISSION] = 0; + weightLobe[LOBE_DIFFUSE_REFLECTION] = 0; + + float weightBase = 1.0F; + + weightLobe[LOBE_CLEARCOAT_REFLECTION] = frCoat; // BRDF clearcoat reflection (GGX-Smith) + weightBase *= 1.0f - frCoat; + + weightLobe[LOBE_SHEEN_REFLECTION] = weightBase * sheen; // BRDF sheen reflection (Lambert) + weightBase *= 1.0f - sheen; + + weightLobe[LOBE_METAL_REFLECTION] = weightBase * mat.metallic; // BRDF metal (GGX-Smith) + weightBase *= 1.0f - mat.metallic; + + weightLobe[LOBE_SPECULAR_REFLECTION] = weightBase * frDielectric; // BRDF dielectric specular reflection (GGX-Smith) + weightBase *= 1.0f - frDielectric; + + weightLobe[LOBE_SPECULAR_TRANSMISSION] = weightBase * mat.transmission; // BTDF dielectric specular transmission (GGX-Smith) + + float remainingWeight = weightBase * (1.0f - mat.transmission); + weightLobe[LOBE_DIFFUSE_TRANSMISSION] = remainingWeight * mat.diffuseTransmissionFactor; + weightLobe[LOBE_DIFFUSE_REFLECTION] = remainingWeight * (1.0f - mat.diffuseTransmissionFactor); + + return weightLobe; +} + +/* @DOC_START +# Function `findLobe` +> Calculates the weights of the individual lobes inside the standard PBR material +> and randomly selects one. +@DOC_END */ +int findLobe(PbrMaterial mat, float VdotN, float rndVal, INOUT_TYPE(vec3) tint) +{ + ARRAY_TYPE(float, LOBE_COUNT, weightLobe) = computeLobeWeights(mat, VdotN, tint); + + int lobe = LOBE_COUNT; + float weight = 0.0f; + // Stops when lobe reaches 0! No need to look at weightLobe[0] since we know + // light will always scatter on one lobe. + while(--lobe > 0) + { + weight += weightLobe[lobe]; + if(rndVal < weight) + { + break; // Sample and evaluate this lobe! + } + } + + return lobe; +} + +// Evaluates a diffuse lobe. +void brdf_diffuse_eval(INOUT_TYPE(BsdfEvaluateData) data, PbrMaterial mat, vec3 tint) +{ + // If the incoming light direction is on the backside, there is nothing to evaluate for a BRDF. + // Note that the state normals have been flipped to the ray side by the caller. + // Include edge-on (== 0.0f) as "no light" case. + if(dot(data.k2, mat.Ng) <= 0.0f) // if (backside) + { + return; // absorb + } + + data.pdf = max(0.0f, dot(data.k2, mat.N) * M_1_PI); + + // For a white Lambert material, the bxdf components match the evaluation pdf. (See MDL_renderer.) + data.bsdf_diffuse = tint * data.pdf; +} + +void brdf_diffuse_eval(INOUT_TYPE(BsdfEvaluateData) data, PbrMaterial mat) +{ + brdf_diffuse_eval(data, mat, mat.baseColor); +} + +// Samples a diffuse lobe. +void brdf_diffuse_sample(INOUT_TYPE(BsdfSampleData) data, PbrMaterial mat, vec3 tint) +{ + data.k2 = cosineSampleHemisphere(data.xi.x, data.xi.y); + data.k2 = mat.T * data.k2.x + mat.B * data.k2.y + mat.N * data.k2.z; + data.k2 = normalize(data.k2); + data.pdf = dot(data.k2, mat.N) * M_1_PI; + + data.bsdf_over_pdf = tint; // bsdf * dot(wi, normal) / pdf; + data.event_type = (0.0f < dot(data.k2, mat.Ng)) ? BSDF_EVENT_DIFFUSE_REFLECTION : BSDF_EVENT_ABSORB; +} + +void brdf_diffuse_sample(INOUT_TYPE(BsdfSampleData) data, PbrMaterial mat) +{ + brdf_diffuse_sample(data, mat, mat.baseColor); +} + +void brdf_diffuse_transmission_eval(INOUT_TYPE(BsdfEvaluateData) data, PbrMaterial mat, vec3 tint) +{ + // If the incoming light direction is on the same side as the surface normal, + // there is no diffuse transmission to evaluate. Absorb light in this case. + if(dot(data.k2, -mat.Ng) <= 0.0f) + { + return; // absorb + } + + data.pdf = max(0.0f, dot(data.k2, -mat.N) * M_1_PI); + + // For a white Lambert material, the bxdf components match the evaluation pdf. (See MDL_renderer.) + data.bsdf_diffuse = tint * data.pdf * mat.diffuseTransmissionColor; +} + +void brdf_diffuse_transmission_sample(INOUT_TYPE(BsdfSampleData) data, PbrMaterial mat, vec3 tint) +{ + // Sample a direction on the opposite hemisphere (relative to -mat.N). + vec3 sampledDir = cosineSampleHemisphere(data.xi.x, data.xi.y); + data.k2 = mat.T * sampledDir.x + mat.B * sampledDir.y - mat.N * sampledDir.z; // Flip the normal + data.k2 = normalize(data.k2); + + // Compute the PDF for this direction. + data.pdf = max(0.0f, dot(data.k2, -mat.N) * M_1_PI); + + // Ensure energy conservation by considering the diffuse transmission tint. + data.bsdf_over_pdf = tint * mat.diffuseTransmissionColor; + + // Determine the event type based on the direction relative to the geometric normal. + data.event_type = (dot(data.k2, -mat.Ng) > 0.0f) ? BSDF_EVENT_DIFFUSE_TRANSMISSION : BSDF_EVENT_ABSORB; +} + + +// Evaluates a reflective lobe with a GGX NDF and an uncorrelated Smith +// scattering-masking function. +void brdf_ggx_smith_eval(INOUT_TYPE(BsdfEvaluateData) data, PbrMaterial mat, const int lobe, vec3 tint) +{ + // BRDF or BTDF eval? + // If the incoming light direction is on the backface. + // Include edge-on (== 0.0f) as "no light" case. + const bool backside = (dot(data.k2, mat.Ng) <= 0.0f); + // Nothing to evaluate for given directions? + // MDL uses "&& scatter_reflect" here; since this only handles reflection, `scatter_reflect` is false. + if(backside && false) + { + data.pdf = 0.0f; + data.bsdf_glossy = vec3(0.0f); + return; + } + + const float nk1 = abs(dot(data.k1, mat.N)); + const float nk2 = abs(dot(data.k2, mat.N)); + + // compute_half_vector() for scatter_reflect. + const vec3 h = normalize(data.k1 + data.k2); + + // Invalid for reflection / refraction? + const float nh = dot(mat.N, h); + const float k1h = dot(data.k1, h); + const float k2h = dot(data.k2, h); + + // nk1 and nh must not be 0.0f or state.pdf == NaN. + if(nk1 <= 0.0f || nh <= 0.0f || k1h < 0.0f || k2h < 0.0f) + { + data.pdf = 0.0f; + data.bsdf_glossy = vec3(0.0f); + return; + } + + // Compute BSDF and pdf. + const vec3 h0 = vec3(dot(mat.T, h), dot(mat.B, h), nh); + + data.pdf = hvd_ggx_eval(1.0f / mat.roughness, h0); + float G1; + float G2; + + float G12; + G12 = ggx_smith_shadow_mask(G1, G2, vec3(dot(mat.T, data.k1), dot(mat.B, data.k1), nk1), + vec3(dot(mat.T, data.k2), dot(mat.B, data.k2), nk2), mat.roughness); + + data.pdf *= 0.25f / (nk1 * nh); + + vec3 bsdf = vec3(G12 * data.pdf); + + data.pdf *= G1; + + if(mat.iridescence > 0.0f) + { + const vec3 factor = thin_film_factor(mat.iridescenceThickness, mat.iridescenceIor, mat.ior2, mat.ior1, k1h); + + switch(lobe) + { + case LOBE_SPECULAR_REFLECTION: + tint *= mix(vec3(1.f), factor, mat.iridescence); + break; + + case LOBE_METAL_REFLECTION: + tint = mix_rgb(tint, mat.specularColor, factor * mat.iridescence); + break; + } + } + + // eval output: (glossy part of the) bsdf * dot(k2, normal) + data.bsdf_glossy = bsdf * tint; +} + +// Samples a reflective lobe with a GGX NDF and an uncorrelated Smith +// scattering-masking function. +void brdf_ggx_smith_sample(INOUT_TYPE(BsdfSampleData) data, PbrMaterial mat, const int lobe, vec3 tint) +{ + // When the sampling returns eventType = BSDF_EVENT_ABSORB, the path ends inside the ray generation program. + // Make sure the returned values are valid numbers when manipulating the PRD. + data.bsdf_over_pdf = vec3(0.0f); + data.pdf = 0.0f; + + // Transform to local coordinate system + const float nk1 = dot(data.k1, mat.N); + if(nk1 <= 0.0f) + { + data.event_type = BSDF_EVENT_ABSORB; + return; + } + const vec3 k10 = vec3(dot(data.k1, mat.T), dot(data.k1, mat.B), nk1); + + // Sample half-vector, microfacet normal. + const vec3 h0 = hvd_ggx_sample_vndf(k10, mat.roughness, data.xi.xy); + if(h0.z == 0.0f) + { + data.event_type = BSDF_EVENT_ABSORB; + return; + } + + // Transform to world + const vec3 h = h0.x * mat.T + h0.y * mat.B + h0.z * mat.N; + const float kh = dot(data.k1, h); + + if(kh <= 0.0f) + { + data.event_type = BSDF_EVENT_ABSORB; + return; + } + + // BRDF: reflect + data.k2 = (2.0f * kh) * h - data.k1; + + // Check if the resulting direction is on the correct side of the actual geometry + const float gnk2 = dot(data.k2, mat.Ng); + + if(gnk2 <= 0.0f) + { + data.event_type = BSDF_EVENT_ABSORB; + return; + } + + const float nk2 = abs(dot(data.k2, mat.N)); + const float k2h = abs(dot(data.k2, h)); + + float G1; + float G2; + + float G12 = ggx_smith_shadow_mask(G1, G2, k10, vec3(dot(data.k2, mat.T), dot(data.k2, mat.B), nk2), mat.roughness); + + if(G12 <= 0.0f) + { + data.event_type = BSDF_EVENT_ABSORB; + return; + } + + data.bsdf_over_pdf = vec3(G2); + data.event_type = BSDF_EVENT_GLOSSY_REFLECTION; + + // Compute pdf + data.pdf = hvd_ggx_eval(1.0f / mat.roughness, h0) * G1; + data.pdf *= 0.25f / (nk1 * h0.z); + + if(mat.iridescence > 0.0f) + { + const vec3 factor = thin_film_factor(mat.iridescenceThickness, mat.iridescenceIor, mat.ior2, mat.ior1, kh); + + switch(lobe) + { + case LOBE_SPECULAR_REFLECTION: + tint *= mix(vec3(1.f), factor, mat.iridescence); + break; + + case LOBE_METAL_REFLECTION: + tint = mix_rgb(tint, mat.specularColor, factor * mat.iridescence); + break; + } + } + + data.bsdf_over_pdf *= tint; +} + +/* + * In rare cases (mainly dispersion), we need to get an additional random + * number. This function takes a random number and applies the hash function + * from pcg_output_rxs_m_xs_32_32 to it. + * Its quality hasn't been tested and it's not very principled, but it's better + * than using a random number that's correlated with material sampling. +*/ +float rerandomize(float v) +{ + uint word = floatBitsToUint(v); + word = ((word >> ((word >> 28) + 4)) ^ word) * 277803737U; + word = (word >> 22) ^ word; + return float(word) / uintBitsToFloat(0x4f800000U); +} + +/* @DOC_START +# Function `computeDispersedIOR` +> Calculates the IOR at a given wavelength (in nanometers) given the base IOR +> and glTF dispersion factor. + +See https://github.com/KhronosGroup/glTF/tree/0251c5c0cce8daec69bd54f29f891e3d0cdb52c8/extensions/2.0/Khronos/KHR_materials_dispersion. +@DOC_END */ +float computeDispersedIOR(float base_ior, float dispersion, float wavelength_nm) +{ + // Since the glTF extension stores 20 / V_d + float abbeNumber = 20.0F / dispersion; + // Last equation of https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_dispersion + return max(base_ior + (base_ior - 1.0F) * (523655.0F / (wavelength_nm * wavelength_nm) - 1.5168F) / abbeNumber, 1.0F); +} + +/* @DOC_START +# Function `wavelengthToRGB` +> Given a wavelength of light, returns an approximation to the linear RGB +> color of a D65 illuminant (sRGB whitepoint) sampled at a wavelength of `x` +> nanometers, using the CIE 2015 2-degree Standard Observer Color Matching Functions. + +This is normalized so that +`sum(wavelengthToRGB(i), {i, WAVELENGTH_MIN, WAVELENGTH_MAX}) == vec3(1.)`, +which means that the values it returns are usually low. You'll need to multiply +by an appropriate normalization factor if you're randomly sampling it. + +The colors here are clamped to only positive sRGB values, in case renderers +have problems with colors with negative sRGB components (i.e. are valid +colors but are out-of-gamut). +@DOC_END */ +#define WAVELENGTH_MIN 399.43862850585765F +#define WAVELENGTH_MAX 668.6617899434457F +vec3 wavelengthToRGB(float x) +{ + // This uses a piecewise-linear approximation generated using the CIE 2015 + // 2-degree standard observer times the D65 illuminant, minimizing the L2 + // norm, then normalized to have an integral of 1. + vec3 rgb = vec3(0.); + if(399.43862850585765 < x) + { + if(x < 435.3450352446586) + rgb.r = 2.6268757476158464e-05 * x + -0.010492756458829732; + else if(x < 452.7741480943567) + rgb.r = -5.383671438883332e-05 * x + 0.024380763013525125; + else if(x < 550.5919453498173) + rgb.r = 1.2536207000814165e-07 * x + -5.187018452935683e-05; + else if(x < 600.8694441891222) + rgb.r = 0.00032842519537482 * x + -0.18081111406184644; + else if(x < 668.6617899434457) + rgb.r = -0.0002438262071743009 * x + 0.16303726812428945; + } + if(467.41924217251835 < x) + { + if(x < 532.3927928594046) + rgb.g = 0.00020126149345609334 * x + -0.0940734947497564; + else if(x < 552.5312202450474) + rgb.g = -4.3718474429905034e-05 * x + 0.03635207454767751; + else if(x < 605.5304635656746) + rgb.g = -0.00023012125757884968 * x + 0.13934543177803685; + } + if(400.68666327204835 < x) + { + if(x < 447.59688835108466) + rgb.b = 0.00042519082480799777 * x + -0.1703682928462067; + else if(x < 501.2110070697423) + rgb.b = -0.00037202508909921054 * x + 0.18646306956262593; + } + return rgb; +} + + +// Evaluates the transmission lobe. +void btdf_ggx_smith_eval(INOUT_TYPE(BsdfEvaluateData) data, PbrMaterial mat, vec3 tint) +{ + bool isThinWalled = (mat.isThinWalled); + + vec2 ior = vec2(mat.ior1, mat.ior2); + if(mat.dispersion > 0.0f) + { + // Randomly choose a wavelength; for now, uniformly choose from 399-669 nm. + float wavelength = mix(WAVELENGTH_MIN, WAVELENGTH_MAX, rerandomize(data.xi.z)); + ior.x = computeDispersedIOR(ior.x, mat.dispersion, wavelength); + tint *= (WAVELENGTH_MAX - WAVELENGTH_MIN) * wavelengthToRGB(wavelength); + } + + const float nk1 = abs(dot(data.k1, mat.N)); + const float nk2 = abs(dot(data.k2, mat.N)); + + // BRDF or BTDF eval? + // If the incoming light direction is on the backface. + // Do NOT include edge-on (== 0.0f) as backside here to take the reflection path. + const bool backside = (dot(data.k2, mat.Ng) < 0.0f); + + const vec3 h = compute_half_vector(data.k1, data.k2, mat.N, ior, nk2, backside, isThinWalled); + + // Invalid for reflection / refraction? + const float nh = dot(mat.N, h); + const float k1h = dot(data.k1, h); + const float k2h = dot(data.k2, h) * (backside ? -1.0f : 1.0f); + + // nk1 and nh must not be 0.0f or state.pdf == NaN. + if(nk1 <= 0.0f || nh <= 0.0f || k1h < 0.0f || k2h < 0.0f) + { + data.pdf = 0.0f; // absorb + data.bsdf_glossy = vec3(0.0f); + return; + } + + float fr; + + if(!backside) + { + // For scatter_transmit: Only allow TIR with BRDF eval. + if(!isTIR(ior, k1h)) + { + data.pdf = 0.0f; // absorb + data.bsdf_glossy = vec3(0.0f); + return; + } + else + { + fr = 1.0f; + } + } + else + { + fr = 0.0f; + } + + // Compute BSDF and pdf + const vec3 h0 = vec3(dot(mat.T, h), dot(mat.B, h), nh); + data.pdf = hvd_ggx_eval(1.0f / mat.roughness, h0); + + float G1; + float G2; + float G12 = ggx_smith_shadow_mask(G1, G2, vec3(dot(mat.T, data.k1), dot(mat.B, data.k1), nk1), + vec3(dot(mat.T, data.k2), dot(mat.B, data.k2), nk2), mat.roughness); + + if(!isThinWalled && backside) // Refraction? + { + // Refraction pdf and BTDF + const float tmp = k1h * ior.x - k2h * ior.y; + + data.pdf *= k1h * k2h / (nk1 * nh * tmp * tmp); + } + else + { + // Reflection pdf and BRDF (and pseudo-BTDF for thin-walled) + data.pdf *= 0.25f / (nk1 * nh); + } + + const float prob = (backside) ? 1.0f - fr : fr; + + const vec3 bsdf = vec3(prob * G12 * data.pdf); + + data.pdf *= prob * G1; + + // eval output: (glossy part of the) bsdf * dot(k2, normal) + data.bsdf_glossy = bsdf * tint; +} + + +// Samples the transmission lobe. +void btdf_ggx_smith_sample(INOUT_TYPE(BsdfSampleData) data, PbrMaterial mat, vec3 tint) +{ + bool isThinWalled = (mat.isThinWalled); + + // When the sampling returns eventType = BSDF_EVENT_ABSORB, the path ends inside the ray generation program. + // Make sure the returned values are valid numbers when manipulating the PRD. + data.bsdf_over_pdf = vec3(0.0f); + data.pdf = 0.0f; + + vec2 ior = vec2(mat.ior1, mat.ior2); + if(mat.dispersion > 0.0f) + { + // Randomly choose a wavelength; for now, uniformly choose from 361-716 nm. + float wavelength = mix(WAVELENGTH_MIN, WAVELENGTH_MAX, rerandomize(data.xi.z)); + ior.x = computeDispersedIOR(ior.x, mat.dispersion, wavelength); + tint *= (WAVELENGTH_MAX - WAVELENGTH_MIN) * wavelengthToRGB(wavelength); + } + + const float nk1 = abs(dot(data.k1, mat.N)); + + const vec3 k10 = vec3(dot(data.k1, mat.T), dot(data.k1, mat.B), nk1); + + // Sample half-vector, microfacet normal. + const vec3 h0 = hvd_ggx_sample_vndf(k10, mat.roughness, data.xi.xy); + + if(abs(h0.z) == 0.0f) + { + data.event_type = BSDF_EVENT_ABSORB; + return; + } + + // Transform to world + const vec3 h = h0.x * mat.T + h0.y * mat.B + h0.z * mat.N; + + const float kh = dot(data.k1, h); + + if(kh <= 0.0f) + { + data.event_type = BSDF_EVENT_ABSORB; + return; + } + + // Case scatter_transmit + bool tir = false; + if(isThinWalled) // No refraction! + { + // pseudo-BTDF: flip a reflected reflection direction to the back side + data.k2 = (2.0f * kh) * h - data.k1; + data.k2 = normalize(data.k2 - 2.0f * mat.N * dot(data.k2, mat.N)); + } + else + { + // BTDF: refract + data.k2 = refract(data.k1, h, ior.x / ior.y, kh, tir); + } + + data.bsdf_over_pdf = vec3(1.0f); // Was: (vec3(1.0f) - fr) / prob; // PERF Always white with the original setup. + data.event_type = (tir) ? BSDF_EVENT_GLOSSY_REFLECTION : BSDF_EVENT_GLOSSY_TRANSMISSION; + + // Check if the resulting direction is on the correct side of the actual geometry + const float gnk2 = dot(data.k2, mat.Ng) * ((data.event_type == BSDF_EVENT_GLOSSY_REFLECTION) ? 1.0f : -1.0f); + + if(gnk2 <= 0.0f || isnan(data.k2.x)) + { + data.event_type = BSDF_EVENT_ABSORB; + return; + } + + + const float nk2 = abs(dot(data.k2, mat.N)); + const float k2h = abs(dot(data.k2, h)); + + float G1; + float G2; + float G12 = ggx_smith_shadow_mask(G1, G2, k10, vec3(dot(data.k2, mat.T), dot(data.k2, mat.B), nk2), mat.roughness); + + if(G12 <= 0.0f) + { + data.event_type = BSDF_EVENT_ABSORB; + return; + } + + data.bsdf_over_pdf *= G2; + + // Compute pdf + data.pdf = hvd_ggx_eval(1.0f / mat.roughness, h0) * G1; // * prob; + + + if(!isThinWalled && (data.event_type == BSDF_EVENT_GLOSSY_TRANSMISSION)) // if (refraction) + { + const float tmp = kh * ior.x - k2h * ior.y; + if(tmp > 0) + { + data.pdf *= kh * k2h / (nk1 * h0.z * tmp * tmp); + } + } + else + { + data.pdf *= 0.25f / (nk1 * h0.z); + } + + data.bsdf_over_pdf *= tint; +} + + +// Evaluates the sheen lobe. +void brdf_sheen_eval(INOUT_TYPE(BsdfEvaluateData) data, PbrMaterial mat) +{ + // BRDF or BTDF eval? + // If the incoming light direction is on the backface. + // Include edge-on (== 0.0f) as "no light" case. + const bool backside = (dot(data.k2, mat.Ng) <= 0.0f); + // Nothing to evaluate for given directions? + if(backside) // && scatter_reflect + { + return; // absorb + } + + const float nk1 = abs(dot(data.k1, mat.N)); + const float nk2 = abs(dot(data.k2, mat.N)); + + // compute_half_vector() for scatter_reflect. + const vec3 h = normalize(data.k1 + data.k2); + + // Invalid for reflection / refraction? + const float nh = dot(mat.N, h); + const float k1h = dot(data.k1, h); + const float k2h = dot(data.k2, h); + + // nk1 and nh must not be 0.0f or state.pdf == NaN. + if(nk1 <= 0.0f || nh <= 0.0f || k1h < 0.0f || k2h < 0.0f) + { + return; // absorb + } + + const float invRoughness = 1.0f / (mat.sheenRoughness * mat.sheenRoughness); // Perceptual roughness to alpha G. + + // Compute BSDF and pdf + const vec3 h0 = vec3(dot(mat.T, h), dot(mat.B, h), nh); + + data.pdf = hvd_sheen_eval(invRoughness, h0.z); + + float G1; + float G2; + + const float G12 = vcavities_shadow_mask(G1, G2, h0.z, vec3(dot(mat.T, data.k1), dot(mat.B, data.k1), nk1), k1h, + vec3(dot(mat.T, data.k2), dot(mat.B, data.k2), nk2), k2h); + data.pdf *= 0.25f / (nk1 * nh); + + const vec3 bsdf = vec3(G12 * data.pdf); + + data.pdf *= G1; + + // eval output: (glossy part of the) bsdf * dot(k2, normal) + data.bsdf_glossy = bsdf * mat.sheenColor; +} + + +// Samples the sheen lobe. +void brdf_sheen_sample(INOUT_TYPE(BsdfSampleData) data, PbrMaterial mat) +{ + // When the sampling returns eventType = BSDF_EVENT_ABSORB, the path ends inside the ray generation program. + // Make sure the returned values are valid numbers when manipulating the PRD. + data.bsdf_over_pdf = vec3(0.0f); + data.pdf = 0.0f; + + const float invRoughness = 1.0f / (mat.sheenRoughness * mat.sheenRoughness); // Perceptual roughness to alpha G. + + const float nk1 = abs(dot(data.k1, mat.N)); + + const vec3 k10 = vec3(dot(data.k1, mat.T), dot(data.k1, mat.B), nk1); + + float xiFlip = data.xi.z; + const vec3 h0 = flip(hvd_sheen_sample(data.xi.xy, invRoughness), k10, xiFlip); + + if(abs(h0.z) == 0.0f) + { + data.event_type = BSDF_EVENT_ABSORB; + return; + } + + // Transform to world + const vec3 h = h0.x * mat.T + h0.y * mat.B + h0.z * mat.N; + + const float k1h = dot(data.k1, h); + + if(k1h <= 0.0f) + { + data.event_type = BSDF_EVENT_ABSORB; + return; + } + + // BRDF: reflect + data.k2 = (2.0f * k1h) * h - data.k1; + data.bsdf_over_pdf = vec3(1.0f); // PERF Always white with the original setup. + data.event_type = BSDF_EVENT_GLOSSY_REFLECTION; + + // Check if the resulting reflection direction is on the correct side of the actual geometry. + const float gnk2 = dot(data.k2, mat.Ng); + + if(gnk2 <= 0.0f) + { + data.event_type = BSDF_EVENT_ABSORB; + return; + } + + const float nk2 = abs(dot(data.k2, mat.N)); + const float k2h = abs(dot(data.k2, h)); + + float G1; + float G2; + + const float G12 = vcavities_shadow_mask(G1, G2, h0.z, k10, k1h, vec3(dot(data.k2, mat.T), dot(data.k2, mat.B), nk2), k2h); + if(G12 <= 0.0f) + { + data.event_type = BSDF_EVENT_ABSORB; + return; + } + + data.bsdf_over_pdf *= G12 / G1; + + // Compute pdf. + data.pdf = hvd_sheen_eval(invRoughness, h0.z) * G1; + + data.pdf *= 0.25f / (nk1 * h0.z); + + data.bsdf_over_pdf *= mat.sheenColor; +} + + +/** @DOC_START +# Function `bsdfEvaluate` +> Evaluates the full BSDF model for the given material and set of directions. + +You must provide `BsdfEvaluateData`'s `k1`, `k2`, and `xi` parameters. +(Evaluation is stochastic because this code randomly samples lobes depending on +`xi`; this is valid to do in a Monte Carlo path tracer.) + +The diffuse lobe evaluation and the sum of the specular lobe evaluations +(including the cosine term from the rendering equation) will be returned in +`data.bsdf_diffuse` and `data.bsdf_glossy`. Additionally, the probability that +the sampling code will return this direction will be returned in `data.pdf`. +@DOC_END */ +void bsdfEvaluate(INOUT_TYPE(BsdfEvaluateData) data, PbrMaterial mat) +{ + vec3 tint = mat.baseColor; + float VdotN = dot(data.k1, mat.N); + int lobe = findLobe(mat, VdotN, data.xi.z, tint); + data.bsdf_diffuse = vec3(0, 0, 0); + data.bsdf_glossy = vec3(0, 0, 0); + data.pdf = 0.0; + + if(lobe == LOBE_DIFFUSE_REFLECTION) + { + brdf_diffuse_eval(data, mat, tint); + } + else if(lobe == LOBE_DIFFUSE_TRANSMISSION) + { + brdf_diffuse_transmission_eval(data, mat, tint); + } + else if(lobe == LOBE_SPECULAR_REFLECTION) + { + brdf_ggx_smith_eval(data, mat, LOBE_SPECULAR_REFLECTION, mat.specularColor); + } + else if(lobe == LOBE_SPECULAR_TRANSMISSION) + { + btdf_ggx_smith_eval(data, mat, tint); + } + else if(lobe == LOBE_METAL_REFLECTION) + { + brdf_ggx_smith_eval(data, mat, LOBE_METAL_REFLECTION, mat.baseColor); + } + else if(lobe == LOBE_CLEARCOAT_REFLECTION) + { + mat.roughness = vec2(mat.clearcoatRoughness * mat.clearcoatRoughness); + mat.N = mat.Nc; + mat.iridescence = 0.0f; + brdf_ggx_smith_eval(data, mat, LOBE_CLEARCOAT_REFLECTION, vec3(1, 1, 1)); + } + else if(lobe == LOBE_SHEEN_REFLECTION) + { + brdf_sheen_eval(data, mat); + } + + // Occlusion effect (glTF occlusion texture) + data.bsdf_diffuse *= mat.occlusion; + data.bsdf_glossy *= mat.occlusion; +} + +/** @DOC_START +# Function `bsdfSample` + +> Samples the full BSDF model for the given material and input direction. + +You must provide `BsdfSampleData`'s `k1` and `xi` parameters. This function +will set the other parameters of `BsdfSampleData`. + +There are two things you should check after calling this function: +* Is `data.event_type` equal to `BSDF_EVENT_ABSORB`? If so, the sampler sampled + an output direction that would be absorbed by the material (e.g. it chose a + reflective lobe but sampled a vector below the surface). + The light path ends here. +* Is `data.pdf` equal to `DIRAC`? If so, this sampled a perfectly specular lobe. + If you're using Multiple Importance Sampling weights, you should compute them + as if `data.pdf` was infinity. + +@DOC_END */ +void bsdfSample(INOUT_TYPE(BsdfSampleData) data, PbrMaterial mat) +{ + vec3 tint = mat.baseColor; + float VdotN = dot(data.k1, mat.N); + int lobe = findLobe(mat, VdotN, data.xi.z, tint); + data.pdf = 0; + data.bsdf_over_pdf = vec3(0.0F); + data.event_type = BSDF_EVENT_ABSORB; + + if(lobe == LOBE_DIFFUSE_REFLECTION) + { + brdf_diffuse_sample(data, mat, tint); + } + else if(lobe == LOBE_DIFFUSE_TRANSMISSION) + { + brdf_diffuse_transmission_sample(data, mat, tint); + } + else if(lobe == LOBE_SPECULAR_REFLECTION) + { + brdf_ggx_smith_sample(data, mat, LOBE_SPECULAR_REFLECTION, mat.specularColor); + } + else if(lobe == LOBE_SPECULAR_TRANSMISSION) + { + btdf_ggx_smith_sample(data, mat, tint); + } + else if(lobe == LOBE_METAL_REFLECTION) + { + brdf_ggx_smith_sample(data, mat, LOBE_METAL_REFLECTION, mat.baseColor); + } + else if(lobe == LOBE_CLEARCOAT_REFLECTION) + { + mat.roughness = vec2(mat.clearcoatRoughness * mat.clearcoatRoughness); + mat.N = mat.Nc; + mat.B = normalize(cross(mat.N, mat.T)); // Assumes Nc and Tc are not collinear! + mat.T = cross(mat.B, mat.N); + mat.iridescence = 0.0f; + brdf_ggx_smith_sample(data, mat, LOBE_CLEARCOAT_REFLECTION, vec3(1, 1, 1)); + } + else if(lobe == LOBE_SHEEN_REFLECTION) + { + // Sheen is using the state.sheenColor and state.sheenInvRoughness values directly. + // Only brdf_sheen_sample needs a third random sample for the v-cavities flip. Put this as argument. + brdf_sheen_sample(data, mat); + } + + // Avoid internal reflection + if(data.pdf <= 0.00001F || any(isnan(data.bsdf_over_pdf))) + { + data.event_type = BSDF_EVENT_ABSORB; + } + if((isnan(data.pdf) || isinf(data.pdf)) && data.event_type != BSDF_EVENT_ABSORB) + { + // Treat as a perfectly specular bounce; change GLOSSY to IMPULSE + data.event_type = (data.event_type & (~BSDF_EVENT_GLOSSY)) | BSDF_EVENT_IMPULSE; + data.pdf = DIRAC; + } +} + +/* @DOC_START +# Simple BSDF Model +The functions below are used to evaluate and sample the BSDF for a simple PBR material, +without any additional lobes like clearcoat, sheen, etc. and without the need of random numbers. +This is based on the metallic/roughness BRDF in Appendix B of the glTF specification. +@DOC_END */ + +// Returns the probability that bsdfSampleSimple samples a glossy lobe. +float bsdfSimpleGlossyProbability(float NdotV, float metallic) +{ + return mix(schlickFresnel(0.04F, 1.0F, NdotV), 1.0F, metallic); +} + +/* @DOC_START +# Function `bsdfEvaluateSimple` +> Evaluates the simple BSDF model using the given material and input and output directions. + +You must provide `data.k1` and `data.k2`, but do not need to provide `data.xi`. +@DOC_END */ +void bsdfEvaluateSimple(INOUT_TYPE(BsdfEvaluateData) data, PbrMaterial mat) +{ + // Specular reflection + vec3 H = normalize(data.k1 + data.k2); + float NdotV = clampedDot(mat.N, data.k1); + float NdotL = clampedDot(mat.N, data.k2); + float VdotH = clampedDot(data.k1, H); + float NdotH = clampedDot(mat.N, H); + + if(NdotV == 0.0f || NdotL == 0.0f || VdotH == 0.0f || NdotH == 0.0f) + { + data.bsdf_diffuse = data.bsdf_glossy = vec3(0.0f); + data.pdf = 0.0f; + return; + } + + // We combine the metallic and specular lobes into a single glossy lobe. + // The metallic weight is metallic * fresnel(f0 = baseColor) + // The specular weight is (1-metallic) * fresnel(f0 = c_min_reflectance) + // The diffuse weight is (1-metallic) * (1-fresnel(f0 = c_min_reflectance)) * baseColor + + // Fresnel terms + float c_min_reflectance = 0.04F; + vec3 f0 = mix(vec3(c_min_reflectance), mat.baseColor, mat.metallic); + vec3 fGlossy = schlickFresnel(f0, vec3(1.0F), VdotH); // Metallic + specular + float fDiffuse = schlickFresnel(1.0F - c_min_reflectance, 0.0F, VdotH) * (1.0F - mat.metallic); + + // Specular GGX + vec3 localH = vec3(dot(mat.T, H), dot(mat.B, H), NdotH); + float d = hvd_ggx_eval(1.0f / mat.roughness, localH); + vec3 localK1 = vec3(dot(mat.T, data.k1), dot(mat.B, data.k1), NdotV); + vec3 localK2 = vec3(dot(mat.T, data.k2), dot(mat.B, data.k2), NdotL); + float G1 = 0.0f, G2 = 0.0f; + ggx_smith_shadow_mask(G1, G2, localK1, localK2, mat.roughness); + + float diffusePdf = M_1_PI * NdotL; + float specularPdf = G1 * d * 0.25f / (NdotV * NdotH); + data.pdf = mix(diffusePdf, specularPdf, bsdfSimpleGlossyProbability(NdotV, mat.metallic)); + + data.bsdf_diffuse = mat.baseColor * fDiffuse * diffusePdf; // Lambertian + data.bsdf_glossy = fGlossy * G2 * specularPdf; // GGX-Smith +} + +/* @DOC_START +# Function `bsdfSampleSimple` +> Evaluates the simple BSDF model using the given material and input and output directions. + +You must provide `data.k1` and `data.xi`. For one sample of pure reflection +(e.g. vk_mini_samples/ray_trace), use `data.xi == vec2(0,0)`. + +After calling this function, you should check if `data.event_type` is +`BSDF_EVENT_ABSORB`. If so, the sampling code sampled a direction below the +surface, and the light path ends here (it should be treated as a reflectance of 0). + +This code cannot currently return a PDF of `DIRAC`, but that might change in +the future. +@DOC_END */ +void bsdfSampleSimple(INOUT_TYPE(BsdfSampleData) data, PbrMaterial mat) +{ + vec3 tint = mat.baseColor; + data.bsdf_over_pdf = vec3(0.0F); + + float nk1 = clampedDot(mat.N, data.k1); + if(data.xi.z <= bsdfSimpleGlossyProbability(nk1, mat.metallic)) + { + // Glossy GGX + data.event_type = BSDF_EVENT_GLOSSY_REFLECTION; + // Transform to local space + vec3 localK1 = vec3(dot(mat.T, data.k1), dot(mat.B, data.k1), nk1); + vec3 halfVector = hvd_ggx_sample_vndf(localK1, mat.roughness, data.xi.xy); + // Transform from local space + halfVector = mat.T * halfVector.x + mat.B * halfVector.y + mat.N * halfVector.z; + data.k2 = reflect(-data.k1, halfVector); + } + else + { + // Diffuse + data.event_type = BSDF_EVENT_DIFFUSE_REFLECTION; + vec3 localDir = cosineSampleHemisphere(data.xi.x, data.xi.y); + data.k2 = mat.T * localDir.x + mat.B * localDir.y + mat.N * localDir.z; + } + + BsdfEvaluateData evalData; + evalData.k1 = data.k1; + evalData.k2 = data.k2; + bsdfEvaluateSimple(evalData, mat); + data.pdf = evalData.pdf; + vec3 bsdf_total = evalData.bsdf_diffuse + evalData.bsdf_glossy; + if(data.pdf <= 0.00001F || any(isnan(bsdf_total))) + { + data.bsdf_over_pdf = vec3(0.0f); + data.event_type = BSDF_EVENT_ABSORB; + } + else + { + data.bsdf_over_pdf = bsdf_total / data.pdf; + } +} + +/* @DOC_START +# Function `bsdfSimpleAverageReflectance` +> Returns the approximate average reflectance of the Simple BSDF -- that is, +> `average_over_k2(f(k1, k2))` -- if GGX didn't lose energy. + +This is useful for things like the variance reduction algorithm in +Tomasz Stachowiak's *Stochastic Screen-Space Reflections*; see also +Ray-Tracing Gems 1, chapter 32, *Accurate Real-Time Specular Reflections +with Radiance Caching*. +@DOC_END */ +vec3 bsdfSimpleAverageReflectance(vec3 k1, PbrMaterial mat) +{ + float NdotV = clampedDot(mat.N, k1); + float c_min_reflectance = 0.04F; + vec3 f0 = mix(vec3(c_min_reflectance), mat.baseColor, mat.metallic); + // This is approximate because + // average_over_k2(fresnel(f0, 1.0f, VdotH)) != fresnel(f0, 1.0f, NdotV). + vec3 bsdf_glossy_average = schlickFresnel(f0, vec3(1.0F), NdotV); + vec3 bsdf_diffuse_average = mat.baseColor * schlickFresnel(1.0F - c_min_reflectance, 0.0F, NdotV) * (1.0F - mat.metallic); + return bsdf_glossy_average + bsdf_diffuse_average; +} + +#undef OUT_TYPE +#undef INOUT_TYPE +#undef ARRAY_TYPE + +#endif // NVVKHL_BSDF_FUNCTIONS_H diff --git a/nvpro_core_legacy/nvvkhl/shaders/bsdf_structs.h b/nvpro_core_legacy/nvvkhl/shaders/bsdf_structs.h new file mode 100644 index 0000000..9ea42b0 --- /dev/null +++ b/nvpro_core_legacy/nvvkhl/shaders/bsdf_structs.h @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2023-2024, NVIDIA CORPORATION. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-FileCopyrightText: Copyright (c) 2023-2024, NVIDIA CORPORATION. + * SPDX-License-Identifier: Apache-2.0 + */ + +#ifndef NVVKHL_BSDF_STRUCTS_H +#define NVVKHL_BSDF_STRUCTS_H 1 + +/* @DOC_START +# `BSDF_EVENT*` Defines +> These are the flags of the `BsdfSampleData::event_type` bitfield, which +> indicates the type of lobe that was sampled. + +This terminology is based on McGuire et al., "A Taxonomy of Bidirectional +Scattering Distribution Function Lobes for Rendering Engineers", +https://casual-effects.com/research/McGuire2020BSDF/McGuire2020BSDF.pdf. +@DOC_END */ + +// Individual flags: +#define BSDF_EVENT_ABSORB 0 // 0: invalid sample; path should be discarded (radiance 0) +#define BSDF_EVENT_DIFFUSE 1 // 1: e.g. Lambert. Lobe is always centered on the surface normal. +#define BSDF_EVENT_GLOSSY (1 << 1) // 2; Center of lobe depends on viewing angle; not perfectly specular reflection. +#define BSDF_EVENT_IMPULSE (1 << 2) // 4; "Perfectly specular" or "mirror-like" reflection or transmission. +#define BSDF_EVENT_REFLECTION (1 << 3) // 8; Both view and light directions are on the same side of the geometric normal. +#define BSDF_EVENT_TRANSMISSION (1 << 4) // 16; View and light directions are on opposite sides of the geometric normal. + +// Combinations: +#define BSDF_EVENT_DIFFUSE_REFLECTION (BSDF_EVENT_DIFFUSE | BSDF_EVENT_REFLECTION) // 9 +#define BSDF_EVENT_DIFFUSE_TRANSMISSION (BSDF_EVENT_DIFFUSE | BSDF_EVENT_TRANSMISSION) // 17 +#define BSDF_EVENT_GLOSSY_REFLECTION (BSDF_EVENT_GLOSSY | BSDF_EVENT_REFLECTION) // 10 +#define BSDF_EVENT_GLOSSY_TRANSMISSION (BSDF_EVENT_GLOSSY | BSDF_EVENT_TRANSMISSION) // 18 +#define BSDF_EVENT_IMPULSE_REFLECTION (BSDF_EVENT_IMPULSE | BSDF_EVENT_REFLECTION) // 12 +#define BSDF_EVENT_IMPULSE_TRANSMISSION (BSDF_EVENT_IMPULSE | BSDF_EVENT_TRANSMISSION) // 20 + +/** @DOC_START +# struct `BsdfEvaluateData` +> Data structure for evaluating a BSDF. See the file for parameter documentation. +@DOC_END */ +struct BsdfEvaluateData +{ + vec3 k1; // [in] Toward the incoming ray + vec3 k2; // [in] Toward the sampled light + vec3 xi; // [in] 3 random [0..1] + vec3 bsdf_diffuse; // [out] Diffuse contribution + vec3 bsdf_glossy; // [out] Specular contribution + float pdf; // [out] PDF +}; + +/** @DOC_START +# struct `BsdfSampleData` +> Data structure for sampling a BSDF. See the file for parameter documentation. +@DOC_END */ +struct BsdfSampleData +{ + vec3 k1; // [in] Toward the incoming ray + vec3 k2; // [out] Toward the sampled light + vec3 xi; // [in] 3 random [0..1] + float pdf; // [out] PDF + vec3 bsdf_over_pdf; // [out] contribution / PDF + int event_type; // [out] one of the event above +}; + +#endif // NVVKHL_BSDF_STRUCTS_H diff --git a/nvpro_core_legacy/nvvkhl/shaders/constants.h b/nvpro_core_legacy/nvvkhl/shaders/constants.h new file mode 100644 index 0000000..e516c0b --- /dev/null +++ b/nvpro_core_legacy/nvvkhl/shaders/constants.h @@ -0,0 +1,73 @@ +/* + * Copyright (c) 2024, NVIDIA CORPORATION. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION + * SPDX-License-Identifier: Apache-2.0 + */ + + +#ifndef CONSTANTS_GLSL +#define CONSTANTS_GLSL + +/* @DOC_START +Useful mathematical constants: +* `M_PI` (pi) +* `M_TWO_PI` (2*pi) +* `M_PI_2` (pi/2) +* `M_PI_4` (pi/4) +* `M_1_OVER_PI` (1/pi) +* `M_2_OVER_PI` (2/pi) +* `M_1_PI` (also 1/pi) +* `INFINITE` (infinity) +@DOC_END */ + +#ifndef __cplusplus +precision highp float; +#endif + + +#ifndef M_PI +const float M_PI = 3.1415926535897F; // PI +#endif + +#ifndef M_TWO_PI +const float M_TWO_PI = 6.2831853071795F; // 2*PI +#endif + +#ifndef M_PI_2 +const float M_PI_2 = 1.5707963267948F; // PI/2 +#endif + +#ifndef M_PI_4 +const float M_PI_4 = 0.7853981633974F; // PI/4 +#endif + +#ifndef M_1_OVER_PI +const float M_1_OVER_PI = 0.3183098861837F; // 1/PI +#endif + +#ifndef M_2_OVER_PI +const float M_2_OVER_PI = 0.6366197723675F; // 2/PI +#endif + +#ifndef M_1_PI +const float M_1_PI = 0.3183098861837F; // 1/PI +#endif + +#ifndef INFINITE +const float INFINITE = 1e32F; +#endif + +#endif // CONSTANTS_GLSL \ No newline at end of file diff --git a/nvpro_core_legacy/nvvkhl/shaders/dh_comp.h b/nvpro_core_legacy/nvvkhl/shaders/dh_comp.h new file mode 100644 index 0000000..423d961 --- /dev/null +++ b/nvpro_core_legacy/nvvkhl/shaders/dh_comp.h @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2022-2024, NVIDIA CORPORATION. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-FileCopyrightText: Copyright (c) 2022-2024, NVIDIA CORPORATION. + * SPDX-License-Identifier: Apache-2.0 + */ + + +#ifndef DH_COMP_H +#define DH_COMP_H 1 + +/* @DOC_START +# Device/Host Polyglot Overview +Files in nvvkhl named "*.h" are designed to be compiled by both C++ and GLSL +code, so that they can share structure and function definitions. +Not all functions will be available in both C++ and GLSL. +@DOC_END */ + +/* @DOC_START +# `WORKGROUP_SIZE` Define +> The number of threads per workgroup in X and Y used by 2D compute shaders. + +Generally, all nvvkhl compute shaders use the same workgroup size. (Workgroup +sizes of 128, 256, or 512 threads are generally good choices across GPUs.) +@DOC_END */ +#define WORKGROUP_SIZE 16 + +#ifdef __cplusplus + +/** @DOC_START +# Function `getGroupCounts` +> Returns the number of workgroups needed to cover `size` threads. +@DOC_END */ +inline VkExtent2D getGroupCounts(const VkExtent2D& size, int workgroupSize = WORKGROUP_SIZE) +{ + return VkExtent2D{(size.width + (workgroupSize - 1)) / workgroupSize, (size.height + (workgroupSize - 1)) / workgroupSize}; +} +#endif // __cplusplus + +#endif // DH_COMP_H diff --git a/nvpro_core_legacy/nvvkhl/shaders/dh_scn_desc.h b/nvpro_core_legacy/nvvkhl/shaders/dh_scn_desc.h new file mode 100644 index 0000000..1384a6a --- /dev/null +++ b/nvpro_core_legacy/nvvkhl/shaders/dh_scn_desc.h @@ -0,0 +1,226 @@ +/* + * Copyright (c) 2022-2025, NVIDIA CORPORATION. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-FileCopyrightText: Copyright (c) 2022-2025, NVIDIA CORPORATION. + * SPDX-License-Identifier: Apache-2.0 + */ + +#ifndef DH_SCN_DESC_H +#define DH_SCN_DESC_H 1 + +/* @DOC_START +Common structures used to store glTF scenes in GPU buffers. +@DOC_END */ + +#ifdef __cplusplus +#define INLINE inline +namespace nvvkhl_shaders { +using mat4 = glm::mat4; +using mat3 = glm::mat3; +using mat2x3 = glm::mat2x3; +using vec4 = glm::vec4; +using vec3 = glm::vec3; +using vec2 = glm::vec2; +#else +#define INLINE +#endif // __cplusplus + +// This is the GLTF Node structure, but flattened +struct RenderNode +{ + mat4 objectToWorld; + mat4 worldToObject; + int materialID; + int renderPrimID; +}; + +// This is all the information about a vertex buffer +struct VertexBuffers +{ + uint64_t positionAddress; + uint64_t normalAddress; + uint64_t colorAddress; + uint64_t tangentAddress; + uint64_t texCoord0Address; + uint64_t texCoord1Address; +}; + +// This is the GLTF Primitive structure +struct RenderPrimitive +{ + uint64_t indexAddress; + VertexBuffers vertexBuffer; +}; + + +// The scene description is a pointer to the material, render node and render primitive +// The buffers are all arrays of the above structures +struct SceneDescription +{ + uint64_t materialAddress; + uint64_t renderNodeAddress; + uint64_t renderPrimitiveAddress; + uint64_t lightAddress; + int numLights; // number of punctual lights +}; + +// alphaMode +#define ALPHA_OPAQUE 0 +#define ALPHA_MASK 1 +#define ALPHA_BLEND 2 +struct GltfTextureInfo +{ + mat2x3 uvTransform; // 24 bytes (2x3 matrix) + int index; // 4 bytes + int texCoord; // 4 bytes +}; // Total: 32 bytes + +struct GltfShadeMaterial +{ + vec4 pbrBaseColorFactor; // offset 0 - 16 bytes - glTF Core + vec3 emissiveFactor; // offset 16 - 12 bytes + float normalTextureScale; // offset 28 - 4 bytes + float pbrRoughnessFactor; // offset 32 - 4 bytes + float pbrMetallicFactor; // offset 36 - 4 bytes + int alphaMode; // offset 40 - 4 bytes + float alphaCutoff; // offset 44 - 4 bytes + float transmissionFactor; // offset 48 - 4 bytes - KHR_materials_transmission + float ior; // offset 52 - 4 bytes - KHR_materials_ior + vec3 attenuationColor; // offset 56 - 12 bytes - KHR_materials_volume + float thicknessFactor; // offset 68 - 4 bytes + float attenuationDistance; // offset 72 - 4 bytes + float clearcoatFactor; // offset 76 - 4 bytes - KHR_materials_clearcoat + float clearcoatRoughness; // offset 80 - 4 bytes + vec3 specularColorFactor; // offset 84 - 12 bytes - KHR_materials_specular + float specularFactor; // offset 96 - 4 bytes + int unlit; // offset 100 - 4 bytes - KHR_materials_unlit + float iridescenceFactor; // offset 104 - 4 bytes - KHR_materials_iridescence + float iridescenceThicknessMaximum; // offset 108 - 4 bytes + float iridescenceThicknessMinimum; // offset 112 - 4 bytes + float iridescenceIor; // offset 116 - 4 bytes + float anisotropyStrength; // offset 120 - 4 bytes - KHR_materials_anisotropy + vec2 anisotropyRotation; // offset 124 - 8 bytes + float sheenRoughnessFactor; // offset 132 - 4 bytes - KHR_materials_sheen + vec3 sheenColorFactor; // offset 136 - 12 bytes + float occlusionStrength; // offset 148 - 4 bytes + float dispersion; // offset 152 - 4 bytes - KHR_materials_dispersion + vec4 pbrDiffuseFactor; // offset 156 - 16 bytes - KHR_materials_pbrSpecularGlossiness + vec3 pbrSpecularFactor; // offset 172 - 12 bytes + int usePbrSpecularGlossiness; // offset 184 - 4 bytes + float pbrGlossinessFactor; // offset 188 - 4 bytes + vec3 diffuseTransmissionColor; // offset 192 - 12 bytes - KHR_materials_diffuse_transmission + float diffuseTransmissionFactor; // offset 204 - 4 bytes + int pad; // offset 208 - 4 bytes (padding for alignment) + + // Texture infos (32 bytes each) + GltfTextureInfo pbrBaseColorTexture; + GltfTextureInfo normalTexture; + GltfTextureInfo pbrMetallicRoughnessTexture; + GltfTextureInfo emissiveTexture; + GltfTextureInfo transmissionTexture; + GltfTextureInfo thicknessTexture; + GltfTextureInfo clearcoatTexture; + GltfTextureInfo clearcoatRoughnessTexture; + GltfTextureInfo clearcoatNormalTexture; + GltfTextureInfo specularTexture; + GltfTextureInfo specularColorTexture; + GltfTextureInfo iridescenceTexture; + GltfTextureInfo iridescenceThicknessTexture; + GltfTextureInfo anisotropyTexture; + GltfTextureInfo sheenColorTexture; + GltfTextureInfo sheenRoughnessTexture; + GltfTextureInfo occlusionTexture; + GltfTextureInfo pbrDiffuseTexture; + GltfTextureInfo pbrSpecularGlossinessTexture; + GltfTextureInfo diffuseTransmissionTexture; // + GltfTextureInfo diffuseTransmissionColorTexture; // +}; // Total size: 884 bytes + +INLINE GltfTextureInfo defaultGltfTextureInfo() +{ + GltfTextureInfo t; + t.uvTransform = mat2x3(1); + t.index = -1; + t.texCoord = 0; + return t; +} + +INLINE GltfShadeMaterial defaultGltfMaterial() +{ + GltfShadeMaterial m; + m.pbrBaseColorFactor = vec4(1, 1, 1, 1); + m.emissiveFactor = vec3(0, 0, 0); + m.normalTextureScale = 1; + m.pbrRoughnessFactor = 1; + m.pbrMetallicFactor = 1; + m.alphaMode = ALPHA_OPAQUE; + m.alphaCutoff = 0.5; + m.transmissionFactor = 0; + m.ior = 1.5; + m.attenuationColor = vec3(1, 1, 1); + m.thicknessFactor = 0; + m.attenuationDistance = 0; + m.clearcoatFactor = 0; + m.clearcoatRoughness = 0; + m.specularFactor = 0; + m.specularColorFactor = vec3(1, 1, 1); + m.unlit = 0; + m.iridescenceFactor = 0; + m.iridescenceThicknessMaximum = 100; + m.iridescenceThicknessMinimum = 400; + m.iridescenceIor = 1.3f; + m.anisotropyStrength = 0; + m.anisotropyRotation = vec2(0, 0); + m.sheenRoughnessFactor = 0; + m.sheenColorFactor = vec3(0, 0, 0); + m.occlusionStrength = 1; + m.dispersion = 0; + m.usePbrSpecularGlossiness = 0; + m.pbrDiffuseFactor = vec4(1); + m.pbrSpecularFactor = vec3(1); + m.pbrGlossinessFactor = 1; + m.diffuseTransmissionColor = vec3(1, 1, 1); + m.diffuseTransmissionFactor = 0; + + m.pbrBaseColorTexture = defaultGltfTextureInfo(); + m.normalTexture = defaultGltfTextureInfo(); + m.pbrMetallicRoughnessTexture = defaultGltfTextureInfo(); + m.emissiveTexture = defaultGltfTextureInfo(); + m.transmissionTexture = defaultGltfTextureInfo(); + m.thicknessTexture = defaultGltfTextureInfo(); + m.clearcoatTexture = defaultGltfTextureInfo(); + m.clearcoatRoughnessTexture = defaultGltfTextureInfo(); + m.clearcoatNormalTexture = defaultGltfTextureInfo(); + m.specularTexture = defaultGltfTextureInfo(); + m.specularColorTexture = defaultGltfTextureInfo(); + m.iridescenceTexture = defaultGltfTextureInfo(); + m.iridescenceThicknessTexture = defaultGltfTextureInfo(); + m.anisotropyTexture = defaultGltfTextureInfo(); + m.sheenColorTexture = defaultGltfTextureInfo(); + m.sheenRoughnessTexture = defaultGltfTextureInfo(); + m.occlusionTexture = defaultGltfTextureInfo(); + m.pbrDiffuseTexture = defaultGltfTextureInfo(); + m.pbrSpecularGlossinessTexture = defaultGltfTextureInfo(); + m.diffuseTransmissionTexture = defaultGltfTextureInfo(); + m.diffuseTransmissionColorTexture = defaultGltfTextureInfo(); + + return m; +} + +#ifdef __cplusplus +} // namespace nvvkhl_shaders +#endif + +#endif diff --git a/nvpro_core_legacy/nvvkhl/shaders/dh_sky.h b/nvpro_core_legacy/nvvkhl/shaders/dh_sky.h new file mode 100644 index 0000000..522a961 --- /dev/null +++ b/nvpro_core_legacy/nvvkhl/shaders/dh_sky.h @@ -0,0 +1,808 @@ +/* + * Copyright (c) 2022-2025, NVIDIA CORPORATION. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-FileCopyrightText: Copyright (c) 2022-2025, NVIDIA CORPORATION. + * SPDX-License-Identifier: Apache-2.0 + */ + +#ifndef DH_SKY_H +#define DH_SKY_H 1 + +/* @DOC_START +> Contains structures and functions for procedural sky models. + +This file includes two sky models: a simple sky that is fast to compute, and +a more complex "physical sky" model based on a model from Mental Ray and later +modernized in the MDL SDK starting [here](https://github.com/NVIDIA/MDL-SDK/blob/203d5140b1dee89de17b26e828c4333571878629/src/shaders/mdl/base/base.mdl#L1180) +customized for nvpro-samples. +@DOC_END */ + +#ifdef __cplusplus +#define OUT_TYPE(T) T& +#define INOUT_TYPE(T) T& +#else +#define OUT_TYPE(T) out T +#define INOUT_TYPE(T) inout T +#endif + +#ifndef M_PIf +#define M_PIf 3.1415926535f +#endif + +#ifdef __cplusplus +namespace nvvkhl_shaders { +using glm::acos; +using glm::clamp; +using glm::degrees; +using glm::dot; +using glm::fract; +using glm::mat3; +using glm::mat4; +using glm::max; +using glm::min; +using glm::mix; +using glm::radians; +using glm::smoothstep; +using glm::vec2; +using glm::vec3; +using glm::vec4; +#else +#define static +#define inline +#endif // __cplusplus + + +#ifndef WORKGROUP_SIZE +#define WORKGROUP_SIZE 16 // Grid size used by compute shaders +#endif + +// clang-format off +#ifdef __cplusplus // Descriptor binding helper for C++ and GLSL +#define START_BINDING(a) enum a { +#define END_BINDING() } +#else +#define START_BINDING(a) const uint +#define END_BINDING() +#endif + +START_BINDING(SkyBindings) +eSkyOutImage = 0, +eSkyParam = 1 +END_BINDING(); +// clang-format on + +/* @DOC_START +# Struct `SkySamplingResult` +> Contains the resulting direction, probability density function, and radiance +> from sampling the procedural sky. +@DOC_END */ +struct SkySamplingResult +{ + vec3 direction; // Direction to the sampled light + float pdf; // Probability Density Function value + vec3 radiance; // Light intensity +}; + +/* @DOC_START +# Struct `SkyPushConstant` +> Used by shaders that bake the procedural sky to a texture. +@DOC_END */ +struct SkyPushConstant +{ + mat4 mvp; +}; + +/* @DOC_START +# Struct `SimpleSkyParameters` +> Parameters for the simple sky model. +@DOC_END */ +struct SimpleSkyParameters +{ + vec3 directionToLight; + float angularSizeOfLight; + + vec3 sunColor; + float glowSize; + + vec3 skyColor; + float glowIntensity; + + vec3 horizonColor; + float horizonSize; + + vec3 groundColor; + float glowSharpness; + + vec3 directionUp; + float sunIntensity; + + vec3 lightRadiance; + float brightness; +}; + + +/** @DOC_START +# Function `initSimpleSkyParameters` +> Initializes `SimpleSkyParameters` with default values. +@DOC_END */ +inline SimpleSkyParameters initSimpleSkyParameters() +{ + SimpleSkyParameters p; + p.directionToLight = vec3(0.0F, 0.707F, 0.707F); + p.angularSizeOfLight = 0.059F; + p.sunColor = vec3(1.0F, 1.0F, 1.0F); + p.sunIntensity = 0.01093f; + p.skyColor = vec3(0.17F, 0.37F, 0.65F); + p.horizonColor = vec3(0.50F, 0.70F, 0.92F); + p.groundColor = vec3(0.62F, 0.59F, 0.55F); + p.directionUp = vec3(0.F, 1.F, 0.F); + p.horizonSize = 0.5F; // +/- degrees + p.glowSize = 0.091F; // degrees, starting from the edge of the light disk + p.glowIntensity = 0.9F; // [0-1] relative to light intensity + p.glowSharpness = 4.F; // [1-10] is the glow power exponent + p.brightness = 1.0F; // [0-1] overall brightness + p.lightRadiance = vec3(1.0F, 1.0F, 1.0F); + + return p; +} + +/** @DOC_START +# Function `evalSimpleSky` +> Returns the radiance of the simple sky model in a given view direction. +@DOC_END */ +inline vec3 evalSimpleSky(SimpleSkyParameters params, vec3 direction) +{ + vec3 skyColor = params.skyColor * params.brightness; + vec3 horizonColor = params.horizonColor * params.brightness; + vec3 groundColor = params.groundColor * params.brightness; + + // Sky + float elevation = asin(clamp(dot(direction, params.directionUp), -1.0F, 1.0F)); + float top = smoothstep(0.F, params.horizonSize, elevation); + float bottom = smoothstep(0.F, params.horizonSize, -elevation); + vec3 environment = mix(mix(horizonColor, groundColor, bottom), skyColor, top); + + // Sun + float angleToLight = acos(clamp(dot(direction, params.directionToLight), 0.0F, 1.0F)); + float halfAngularSize = params.angularSizeOfLight * 0.5F; + float glowInput = + clamp(2.0F * (1.0F - smoothstep(halfAngularSize - params.glowSize, halfAngularSize + params.glowSize, angleToLight)), + 0.0F, 1.0F); + float glowIntensity = params.glowIntensity * pow(glowInput, params.glowSharpness); + vec3 sunLight = glowIntensity * params.lightRadiance; + + return environment + sunLight; +} + +/** @DOC_START +# Function `sampleSimpleSky` +> Samples the simple sky model using two random values, returning a `SkySamplingResult`. +@DOC_END */ +inline SkySamplingResult sampleSimpleSky(SimpleSkyParameters params, vec2 randVal) +{ + SkySamplingResult result; + + // Constants + const float sunWeight = 0.95f; // 95.0% weight for the sun + const float skyWeight = 1.0f - sunWeight; + + // Decide whether to sample the sun or the sky + if(randVal.x < sunWeight) + { + float sunAngularRadius = params.angularSizeOfLight * 0.5f; + + // Sample the sun + float theta = sunAngularRadius * sqrt(randVal.y); + float phi = 2.0f * M_PIf * randVal.x; + + vec3 sunLocalDir; + float sinTheta = sin(theta); + sunLocalDir.x = sinTheta * cos(phi); + sunLocalDir.y = sinTheta * sin(phi); + sunLocalDir.z = cos(theta); + + // Transform sun_local_dir to world space + vec3 up = vec3(0, 0, 1); + vec3 right = cross(up, params.directionToLight); + up = cross(params.directionToLight, right); + + result.direction = sunLocalDir.x * right + sunLocalDir.y * up + sunLocalDir.z * params.directionToLight; + + // Compute the PDF + result.pdf = sunWeight; // / (M_TWO_PI * (1.0f - cos(angular_size))); + + // Compute the light intensity (assuming uniform sun disk) + result.radiance = params.lightRadiance; + } + else + { + // Sample the sky (simple uniform sampling of the upper hemisphere) + float cosTheta = sqrt(1.0f - randVal.y); + float sinTheta = sqrt(randVal.y); + float phi = 2.0f * M_PIf * randVal.x; + + result.direction = vec3(sinTheta * cos(phi), cosTheta, sinTheta * sin(phi)); + + // Ensure the sampled direction is in the upper hemisphere + if(dot(result.direction, params.directionUp) < 0.0f) + { + result.direction.y = -result.direction.y; + } + + // Compute the PDF (uniform sampling of hemisphere) + result.pdf = skyWeight; // / M_TWO_PI; + + // Compute sky color (simplified version of proceduralSky function) + float elevation = asin(clamp(dot(result.direction, params.directionUp), -1.0f, 1.0f)); + float t = smoothstep(0.0f, params.horizonSize, elevation); + result.radiance = mix(params.horizonColor, params.skyColor, t); + } + + return result; +} + + +//////////////////////////////////////////////////////////////////////// +// Physical Sky +//////////////////////////////////////////////////////////////////////// + +/* @DOC_START +# Struct `PhysicalSkyParameters` +> Parameters for the physical sky model. +@DOC_END */ +struct PhysicalSkyParameters +{ + vec3 rgbUnitConversion; + float multiplier; + + float haze; + float redblueshift; + float saturation; + float horizonHeight; + + vec3 groundColor; + float horizonBlur; + + vec3 nightColor; + float sunDiskIntensity; + + vec3 sunDirection; + float sunDiskScale; + + float sunGlowIntensity; + int yIsUp; +}; + + +/* @DOC_START +# Function `initPhysicalSkyParameters` +> Initializes `PhysicalSkyParameters` with default, realistic parameters. +@DOC_END */ +inline PhysicalSkyParameters initPhysicalSkyParameters() +{ + PhysicalSkyParameters ss; + + // Default RGB unit conversion (assuming standard sRGB primaries) + ss.rgbUnitConversion = vec3(1.0f / 80000.0f); + + // Default multiplier (overall intensity scaling) + ss.multiplier = 0.10f; + + // Default atmospheric conditions + ss.haze = 0.1f; + ss.redblueshift = 0.1f; + ss.saturation = 1.0f; + + // Default horizon settings + ss.horizonHeight = 0.0f; + ss.horizonBlur = 0.3f; + + // Default ground color (neutral gray) + ss.groundColor = vec3(0.4f); + + // Default night sky settings + ss.nightColor = vec3(0.0f, 0.0f, 0.01f); + + // Default sun settings + ss.sunDiskIntensity = 1.0f; + ss.sunDiskScale = 1.0f; + ss.sunGlowIntensity = 1.0f; + + // Default sun direction (45 degrees above horizon, facing south) + float elevation = radians(45.0f); + ss.sunDirection = vec3(0.0f, sin(elevation), cos(elevation)); + + // Default coordinate system (Y is up) + ss.yIsUp = 1; + + return ss; +} + + +/*helper functions for sun_and_sky*/ + +// Function to calculate the luminance of an RGB color +inline float rgbLuminance(vec3 rgb) +{ + return 0.2126f * rgb.x + 0.7152f * rgb.y + 0.0722f * rgb.z; // Rec. 709 luminance coefficients +} + +// Function to transform local coordinates (x, y, z) to a direction vector aligned with in_main +inline vec3 localCoordsToDir(vec3 mainVec, float x, float y, float z) +{ + vec3 u = + normalize(abs(mainVec.x) < abs(mainVec.y) ? vec3(0.0f, -mainVec.z, mainVec.y) : vec3(mainVec.z, 0.0f, -mainVec.x)); + vec3 v = cross(mainVec, u); + return x * u + y * v + z * mainVec; +} + +// Equal-area transformation of the square [0,1]^2 to the disk +// {(x, y) | x^2 + y^2 <= 1}. +inline vec2 squareToDisk(float inX, float inY) +{ + float localX = 2.0f * inX - 1.0f; + float localY = 2.0f * inY - 1.0f; + if(localX == 0.0f && localY == 0.0f) + return vec2(0.0f); + + float r, phi; + if(localX > -localY) + { + if(localX > localY) + { + r = localX; + phi = (M_PIf / 4.0f) * (1.0f + localY / localX); + } + else + { + r = localY; + phi = (M_PIf / 4.0f) * (3.0f - localX / localY); + } + } + else + { + if(localX < localY) + { + r = -localX; + phi = (M_PIf / 4.0f) * (5.0f + localY / localX); + } + else + { + r = -localY; + phi = (M_PIf / 4.0f) * (7.0f - localX / localY); + } + } + return vec2(r, phi); +} + +// Function to calculate a diffuse reflection direction based on an input normal and sample +inline vec3 reflectionDirDiffuseX(vec3 inNormal, vec2 inSample) +{ + vec2 rPhi = squareToDisk(inSample.x, inSample.y); // Map the 2D sample point to a disk + float x = rPhi.x * cos(rPhi.y); // Calculate the x component of the reflection direction + float y = rPhi.x * sin(rPhi.y); // Calculate the y component of the reflection direction + float z = sqrt(max(0.0f, 1.0f - x * x - y * y)); // Calculate the z component, ensuring it is non-negative + return localCoordsToDir(inNormal, x, y, z); // Convert the local direction to the world space direction using the normal +} + +// Function to calculate the color of the sun based on its direction and atmospheric turbidity +inline vec3 calcSunColor(vec3 sunDir, float turbidity) +{ + if(sunDir.z <= 0.0f) + return vec3(0.0f); + + vec3 ko = vec3(12.0f, 8.5f, 0.9f); // Optical depth constants for ozone + vec3 wavelength = vec3(0.610f, 0.550f, 0.470f); // Wavelength of light (in micrometers) for RGB channels + vec3 solRad = vec3(1.0f, 0.992f, 0.911f) * (127500.0f / 0.9878f); // Solar radiance adjusted for atmospheric effects + + float m = 1.0f / (sunDir.z + 0.15f * pow(93.885f - degrees(acos(sunDir.z)), -1.253f)); // Optical air mass calculation (simplified relative air mass formula) + float beta = 0.04608f * turbidity - 0.04586f; // Beta coefficient for Rayleigh scattering based on turbidity + vec3 ta = exp(-m * beta * pow(wavelength, vec3(-1.3f))); // Attenuation due to aerosol (Rayleigh) scattering + vec3 to = exp(-m * ko * 0.0035f); // Attenuation due to ozone absorption + vec3 tr = exp(-m * 0.008735f * pow(wavelength, vec3(-4.08f))); // Attenuation due to Rayleigh scattering + + return tr * ta * to * solRad; // Calculate the final sun color based on the combined effects +} + +// Function to calculate the color of the sky based on the sun's direction and atmospheric turbidity +inline vec3 skyColorXyz(vec3 inDir, vec3 inSunPos, float inTurbidity, float inLuminance) +{ + vec3 xyz; + float A, B, C, D, E; + float cosGamma = dot(inSunPos, inDir); + if(cosGamma > 1.0f) + { + cosGamma = 2.0f - cosGamma; + } + float gamma = acos(cosGamma); + float cosTheta = inDir.z; + float cosThetaSun = inSunPos.z; + float thetaSun = acos(cosThetaSun); + float t2 = inTurbidity * inTurbidity; + float ts2 = thetaSun * thetaSun; + float ts3 = ts2 * thetaSun; + // determine x and y at zenith + float zenithX = ((+0.001650f * ts3 - 0.003742f * ts2 + 0.002088f * thetaSun + 0) * t2 + + (-0.029028f * ts3 + 0.063773f * ts2 - 0.032020f * thetaSun + 0.003948f) * inTurbidity + + (+0.116936f * ts3 - 0.211960f * ts2 + 0.060523f * thetaSun + 0.258852f)); + float zenithY = ((+0.002759f * ts3 - 0.006105f * ts2 + 0.003162f * thetaSun + 0) * t2 + + (-0.042149f * ts3 + 0.089701f * ts2 - 0.041536f * thetaSun + 0.005158f) * inTurbidity + + (+0.153467f * ts3 - 0.267568f * ts2 + 0.066698f * thetaSun + 0.266881f)); + xyz.y = inLuminance; + // TODO: Preetham/Utah + + // use flags (see above) + A = -0.019257f * inTurbidity - (0.29f - pow(cosThetaSun, 0.5f) * 0.09f); + B = -0.066513f * inTurbidity + 0.000818f; + C = -0.000417f * inTurbidity + 0.212479f; + D = -0.064097f * inTurbidity - 0.898875f; + E = -0.003251f * inTurbidity + 0.045178f; + + float x = (((1.f + A * exp(B / cosTheta)) * (1.f + C * exp(D * gamma) + E * cosGamma * cosGamma)) + / ((1 + A * exp(B / 1.0f)) * (1 + C * exp(D * thetaSun) + E * cosThetaSun * cosThetaSun))); + + A = -0.016698f * inTurbidity - 0.260787f; + B = -0.094958f * inTurbidity + 0.009213f; + C = -0.007928f * inTurbidity + 0.210230f; + D = -0.044050f * inTurbidity - 1.653694f; + E = -0.010922f * inTurbidity + 0.052919f; + + float y = (((1 + A * exp(B / cosTheta)) * (1 + C * exp(D * gamma) + E * cosGamma * cosGamma)) + / ((1 + A * exp(B / 1.0f)) * (1 + C * exp(D * thetaSun) + E * cosThetaSun * cosThetaSun))); + + float localSaturation = 1.0f; + + x = zenithX * ((x * localSaturation) + (1.0f - localSaturation)); + y = zenithY * ((y * localSaturation) + (1.0f - localSaturation)); + + // convert chromaticities x and y to CIE + xyz.x = (x / y) * xyz.y; + xyz.z = ((1.0f - x - y) / y) * xyz.y; + return xyz; +} + +inline float skyLuminance(vec3 inDir, vec3 inSunPos, float inTurbidity) +{ + float cosGamma = clamp(dot(inSunPos, inDir), 0.0f, 1.0f); + float gamma = acos(cosGamma); + float cosTheta = inDir.z; + float cosThetaSun = inSunPos.z; + float thetaSun = acos(cosThetaSun); + + float A = 0.178721f * inTurbidity - 1.463037f; + float B = -0.355402f * inTurbidity + 0.427494f; + float C = -0.022669f * inTurbidity + 5.325056f; + float D = 0.120647f * inTurbidity - 2.577052f; + float E = -0.066967f * inTurbidity + 0.370275f; + + return (((1 + A * exp(B / cosTheta)) * (1 + C * exp(D * gamma) + E * cosGamma * cosGamma)) + / ((1 + A * exp(B / 1.0f)) * (1 + C * exp(D * thetaSun) + E * cosThetaSun * cosThetaSun))); +} + + +inline vec3 calcSkyColor(vec3 inSunDir, vec3 inDir, float inTurbidity) +{ + float thetaSun = acos(inSunDir.z); + float chi = (4.0f / 9.0f - inTurbidity / 120.0f) * (M_PIf - 2.0f * thetaSun); + float luminance = 1000.0f * ((4.0453f * inTurbidity - 4.9710f) * tan(chi) - 0.2155f * inTurbidity + 2.4192f); + luminance *= skyLuminance(inDir, inSunDir, inTurbidity); + + vec3 xyz = skyColorXyz(inDir, inSunDir, inTurbidity, luminance); + vec3 envColor = vec3(3.241f * xyz.x - 1.537f * xyz.y - 0.499f * xyz.z, -0.969f * xyz.x + 1.876f * xyz.y + 0.042f * xyz.z, + 0.056f * xyz.x - 0.204f * xyz.y + 1.057f * xyz.z); + return envColor * M_PIf; +} + +inline vec3 calcSkyIrradiance(vec3 inDataSunDir, float inDataSunDirHaze) +{ + vec3 colSum = vec3(0.0f); + vec3 nuStateNormal = vec3(0.0f, 0.0f, 1.0f); + + for(float u = 0.1f; u < 1.0f; u += 0.2f) + { + for(float v = 0.1f; v < 1.0f; v += 0.2f) + { + vec3 diff = reflectionDirDiffuseX(nuStateNormal, vec2(u, v)); + colSum += calcSkyColor(inDataSunDir, diff, inDataSunDirHaze); + } + } + return colSum / 25.0f; +} + +inline float tweakSaturation(float inSaturation, float inHaze) +{ + if(inSaturation > 1.0f) + return 1.0f; + + float lowSat = inSaturation * inSaturation * inSaturation; // Compute the low saturation value + float localHaze = clamp((inHaze - 2.0f) / 15.0f, 0.0f, 1.0f); // Normalize the local haze value + localHaze *= localHaze * localHaze; // Adjust haze to the power of 3 + return mix(inSaturation, lowSat, localHaze); // Blend the input saturation with the low saturation value based on local haze +} + + +inline vec3 tweakVector(vec3 dir, int yIsUp, float horizHeight) +{ + vec3 outDir = dir; + if(yIsUp == 1) + { + outDir = vec3(dir.x, dir.z, dir.y); + } + if(horizHeight != 0) + { + outDir.z -= horizHeight; + outDir = normalize(outDir); + } + return outDir; +} + + +inline vec3 tweakColor(vec3 tint, float saturation, float redness) +{ + float intensity = rgbLuminance(tint); + vec3 outTint = (saturation <= 0.0f) ? vec3(intensity) : mix(vec3(intensity), tint, saturation); + outTint *= vec3(1.0f + redness, 1.0f, 1.0f - redness); + return max(outTint, vec3(0.0f)); +} + + +inline vec2 calcPhysicalScale(float sunDiskScale, float sunGlowIntensity, float sunDiskIntensity) +{ + float sunAngularRadius = 0.00465f; + float sunDiskRadius = sunAngularRadius * sunDiskScale; + float sunGlowRadius = sunDiskRadius * 10.0f; + + /* We calculate the integral of the glow intensity function */ + float glowFuncIntegral = sunGlowIntensity + * ((4.0f * M_PIf) - (24.0f * M_PIf) / (sunGlowRadius * sunGlowRadius) + + (24.0f * M_PIf) * sin(sunGlowRadius) / (sunGlowRadius * sunGlowRadius * sunGlowRadius)); + + + /* Calculate the target sun disk intensity integral (the value towards which + we must scale to attain a physically-scaled sun intensity */ + float targetSundiskIntegral = sunDiskIntensity * M_PIf; + + /* Subtract the glow integral from the target disk integral, + limiting the glow power to 50% of the sun disk */ + float skySunglowScale = 1.0f; + float maxGlowIntegral = 0.5f * targetSundiskIntegral; + if(glowFuncIntegral > maxGlowIntegral) + { + skySunglowScale *= maxGlowIntegral / glowFuncIntegral; + targetSundiskIntegral -= maxGlowIntegral; + } + else + { + targetSundiskIntegral -= glowFuncIntegral; + } + + float sundiskArea = 2 * M_PIf * (1 - cos(sunDiskRadius)); + float targetSundiskIntensity = targetSundiskIntegral / sundiskArea; + + /* Calculate the actual sun disk intensity, before scaling is applied */ + float actualSundiskIntegral = 1.0f * sundiskArea; + /* approximation! needs to be re-calculated from the integral of the function */ + float actualSundiskIntensity = sunDiskIntensity * 100.0f * actualSundiskIntegral / sundiskArea; + /* Apply the proper scaling to get to the target value */ + return vec2((targetSundiskIntensity == 0.0f) ? 0.0f : targetSundiskIntensity / actualSundiskIntensity, skySunglowScale); +} + + +inline float nightBrightnessAdjustment(vec3 sunDir) +{ + float lmt = 0.30901699437494742410229341718282f; // ~ cos(72°) or 18° below the horizon + if(sunDir.z <= -lmt) + return 0.0f; + float factor = (sunDir.z + lmt) / lmt; + factor *= factor; + factor *= factor; + return factor; +} + +/* @DOC_START +# Function `evalPhysicalSky` +> Returns the radiance of the physical sky model in a given direction. +@DOC_END */ +inline vec3 evalPhysicalSky(PhysicalSkyParameters ss, vec3 inDirection) +{ + if(ss.multiplier <= 0.0f) + return vec3(0.0f); + + vec3 result = vec3(0.0f); + float factor = 1.0f; + float nightFactor = 1.0f; + vec3 outColor = vec3(0.0f); + vec3 rgbScale = ss.rgbUnitConversion * ss.multiplier; + float heightAdjusted = (ss.horizonHeight + ss.horizonBlur) / 10.0f; + vec3 dir = tweakVector(inDirection, ss.yIsUp, heightAdjusted); + float localHaze = max(2.0f, 2.0f + ss.haze); + float localSaturation = tweakSaturation(ss.saturation, localHaze); + + // Calculate the "downness" of the direction (how much it points downward) + float downness = dir.z; + vec3 realDir = dir; + if(dir.z < 0.001f) + { + dir.z = 0.001f; + dir = normalize(dir); + } + + // Adjust the sun direction similarly to the input direction + vec3 sunDir = ss.sunDirection; + sunDir = tweakVector(sunDir, ss.yIsUp, heightAdjusted); + vec3 realSunDir = sunDir; + if(sunDir.z < 0.001f) + { + // Adjust brightness for night time + factor = nightBrightnessAdjustment(sunDir); + sunDir.z = 0.001f; + sunDir = normalize(sunDir); + } + + // Calculate the sun and sky color + vec3 tint = (factor > 0.0f) ? calcSkyColor(sunDir, dir, localHaze) * factor : vec3(0.0f); + vec3 dataSunColor = calcSunColor(sunDir, (downness > 0) ? localHaze : 2.0f); + + // Add the sun disk and glow if enabled + if(ss.sunDiskIntensity > 0.0f && ss.sunDiskScale > 0.0f) + { + float sunAngle = acos(dot(realDir, realSunDir)); + float glowRadius = 0.00465f * ss.sunDiskScale * 10.0f; + if(sunAngle < glowRadius) + { + vec2 scales = calcPhysicalScale(ss.sunDiskScale, ss.sunGlowIntensity, ss.sunDiskIntensity); + // A value of 0 is at the edge of the glow disk; a value of 1 is in the + // center of the sun. + float centerProximity = (1.0f - sunAngle / glowRadius); + float glowFactor = pow(centerProximity, 3.0f) * 2.0f * ss.sunGlowIntensity * scales.y; + float diskFactor = + smoothstep(0.85f, 0.95f + (localHaze / 500.0f), centerProximity) * 100.0f * ss.sunDiskIntensity * scales.x; + tint += dataSunColor * (glowFactor + diskFactor); + } + } + outColor = tint * rgbScale; + + // Add ground color if the direction is pointing downward + if(downness <= 0.0f) + { + vec3 irrad = calcSkyIrradiance(sunDir, 2.0f); + vec3 downColor = ss.groundColor * (irrad + dataSunColor * sunDir.z) * rgbScale; + downColor *= factor; + float horBlur = ss.horizonBlur / 10.0f; + if(horBlur > 0.0f) + { + // Blend between sky and ground color at the horizon + float dness = smoothstep(0.0f, 1.0f, -downness / horBlur); + outColor = mix(outColor, downColor, dness); + nightFactor = 1.0f - dness; + } + else + { + outColor = downColor; + nightFactor = 0.0f; + } + } + + // Adjusting the color based on the saturation and red-blue shift + outColor = tweakColor(outColor, localSaturation, ss.redblueshift); + result = outColor * M_PIf; + + // Adding the night sky color + if(nightFactor > 0.0f) + { + vec3 night = ss.nightColor * nightFactor; + result = max(result, night); + } + + return result; +} + +// Uniformly samples a spherical cap: the part of the surface of a sphere +// where z ranges from z_min to 1. If randomSample.y is sampled in the closed +// interval [0,1], this samples z in [z_min, 1] and a closed cap will be sampled; +// if randomSample.y is sampled in the half-open interval [0,1), then z is in +// (z_min, 1] and an open cap will be sampled. +inline vec3 sampleSphericalCap(float z_min, vec2 xi) +{ + float z = mix(1.F, z_min, xi.y); + float r = sqrt(max(0.F, 1.F - z * z)); + float phi = 2.0f * M_PIf * xi.x; + float x = r * cos(phi); + float y = r * sin(phi); + return vec3(x, y, z); +} + +// Probability that samplePhysicalSky samples the sun. +// If the sun is too small, we never sample it. +inline float physicalSkySunProbability(PhysicalSkyParameters ss) +{ + float sunElevation = ss.sunDirection.z; + return (ss.sunDiskScale > 1e-5f) ? clamp(ss.sunDiskIntensity * sunElevation * 0.5f + 0.5f, 0.1f, 0.9f) : 0.0f; +} + +/* @DOC_START +# Function `samplePhysicalSkyPDF` +> Returns the probability that `samplePhysicalSky` samples a certain direction. +@DOC_END */ +inline float samplePhysicalSkyPDF(PhysicalSkyParameters ss, vec3 inDirection) +{ + const float sunAngularRadius = 0.00465f * ss.sunDiskScale; + // If we choose the sky, this is the probability of choosing a given direction: + const float skyPdf = 1.0f / (2.0f * M_PIf); + // This factor of 1.5f is because of the lower bound on the sun's + // smoothstep when computing `diskFactor` in `evalPhysicalSky`. + const float sunSampleAngularRadius = 1.5f * sunAngularRadius; + // Use first-degree Taylor series expansion around 0 for better precision + const float sunSampleSolidAngle = (sunSampleAngularRadius < 0.001f) ? + M_PIf * sunSampleAngularRadius * sunSampleAngularRadius : + 2.0f * M_PIf * (1.0f - cos(sunSampleAngularRadius)); + // If we choose the sun, this is the probability of choosing a given direction: + const float sunPdf = (dot(inDirection, ss.sunDirection) >= cos(sunSampleAngularRadius)) ? 1.0f / sunSampleSolidAngle : 0.0f; + return mix(skyPdf, sunPdf, physicalSkySunProbability(ss)); +} + +/* @DOC_START +# Function `samplePhysicalSky` +> Samples the physical sky model using two random values, returning a `SkySamplingResult`. +@DOC_END */ +inline SkySamplingResult samplePhysicalSky(PhysicalSkyParameters ss, vec2 randomSample) +{ + SkySamplingResult result; + + // Decide whether to sample sun or sky + float sunProb = physicalSkySunProbability(ss); + float z_min = 0.0f; // Minimum z-value of the spherical cap we'll sample + bool sampleSun = randomSample.x < sunProb; + if(sampleSun) + { + // Adjust the range of the random value so we can use it again: + randomSample.x = randomSample.x / sunProb; + // Sample the sun by doing uniform spherical cap sampling around the +z + // axis, then rotating the +z axis so that it points towards the sun. + const float sunSampleAngularRadius = 1.5f * 0.00465f * ss.sunDiskScale; + z_min = cos(sunSampleAngularRadius); + } + else + { + // Adjust the range of the random value so we can use it again: + randomSample.x = (randomSample.x - sunProb) / (1.0f - sunProb); + } + + result.direction = sampleSphericalCap(z_min, randomSample); + + if(sampleSun) + { + // Transform the sun from +z to ss.sunDirection + vec3 up = vec3(0, 0, 1); + vec3 right = normalize(cross(up, ss.sunDirection)); + up = cross(ss.sunDirection, right); + + result.direction = result.direction.x * right // + + result.direction.y * up // + + result.direction.z * ss.sunDirection; + } + + // Evaluate the sky model + result.radiance = evalPhysicalSky(ss, result.direction); + result.pdf = samplePhysicalSkyPDF(ss, result.direction); + return result; +} + +#ifdef __cplusplus +} // namespace nvvkhl_shaders +#endif + + +#endif // DH_SKY_H diff --git a/nvpro_core_legacy/nvvkhl/shaders/dh_tonemap.h b/nvpro_core_legacy/nvvkhl/shaders/dh_tonemap.h new file mode 100644 index 0000000..155fd31 --- /dev/null +++ b/nvpro_core_legacy/nvvkhl/shaders/dh_tonemap.h @@ -0,0 +1,302 @@ +/* + * Copyright (c) 2022-2024, NVIDIA CORPORATION. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-FileCopyrightText: Copyright (c) 2022-2024 NVIDIA CORPORATION + * SPDX-License-Identifier: Apache-2.0 + */ + + +#ifndef DH_TONEMAMP_H +#define DH_TONEMAMP_H 1 + +/* @DOC_START +> Contains implementations for several local tone mappers. +@DOC_END */ + +#ifdef __cplusplus +#include +#include +namespace nvvkhl_shaders { +using mat3 = glm::mat3; +using uint = uint32_t; +using vec2 = glm::vec2; +using vec3 = glm::vec3; +#define INLINE inline +#else +#define INLINE +#endif + + +const int eTonemapFilmic = 0; +const int eTonemapUncharted2 = 1; +const int eTonemapClip = 2; +const int eTonemapACES = 3; +const int eTonemapAgX = 4; +const int eTonemapKhronosPBR = 5; + + +/* @DOC_START +# Struct `Tonemapper` +> Tonemapper settings. +@DOC_END */ +struct Tonemapper +{ + int method; // One of the `eTonemap` values above. + int isActive; + float exposure; + float brightness; + float contrast; + float saturation; + float vignette; +}; + +/* @DOC_START +# Struct `defaultTonemapper` +> Returns default tonemapper settings: filmic tone mapping, no additional color +> correction. +@DOC_END */ +INLINE Tonemapper defaultTonemapper() +{ + Tonemapper t; + t.method = 0; + t.isActive = 1; + t.exposure = 1.0F; + t.brightness = 1.0F; + t.contrast = 1.0F; + t.saturation = 1.0F; + t.vignette = 0.0F; + return t; +} + +// Bindings +const int eTonemapperInput = 0; +const int eTonemapperOutput = 1; + +/** @DOC_START +# Function `toSrgb` +> Converts a color from linear RGB to sRGB. +@DOC_END */ +INLINE vec3 toSrgb(vec3 rgb) +{ + vec3 low = rgb * 12.92f; + vec3 high = fma(pow(rgb, vec3(1.0F / 2.4F)), vec3(1.055F), vec3(-0.055F)); + return mix(low, high, greaterThan(rgb, vec3(0.0031308F))); +} + +/** @DOC_START +# Function `toLinear` +> Converts a color from sRGB to linear RGB. +@DOC_END */ +INLINE vec3 toLinear(vec3 srgb) +{ + vec3 low = srgb / 12.92F; + vec3 high = pow((srgb + vec3(0.055F)) / 1.055F, vec3(2.4F)); + return mix(low, high, greaterThan(srgb, vec3(0.04045F))); +} + +/** @DOC_START +# Function `tonemapFilmic` +> Filmic tonemapping operator by Jim Hejl and Richard Burgess-Dawson, +> approximating the Digital Fusion Cineon mode, but more saturated and with +> darker midtones. sRGB correction is built in. + +http://filmicworlds.com/blog/filmic-tonemapping-operators/ +@DOC_END */ +INLINE vec3 tonemapFilmic(vec3 color) +{ + vec3 temp = max(vec3(0.0F), color - vec3(0.004F)); + vec3 result = (temp * (vec3(6.2F) * temp + vec3(0.5F))) / (temp * (vec3(6.2F) * temp + vec3(1.7F)) + vec3(0.06F)); + return result; +} + +/** @DOC_START +# Function `tonemapUncharted` +> Tone mapping operator from Uncharted 2 by John Hable. sRGB correction is built in. + +See: http://filmicworlds.com/blog/filmic-tonemapping-operators/ +@DOC_END */ + +INLINE vec3 tonemapUncharted2Impl(vec3 color) +{ + const float a = 0.15F; + const float b = 0.50F; + const float c = 0.10F; + const float d = 0.20F; + const float e = 0.02F; + const float f = 0.30F; + return ((color * (a * color + c * b) + d * e) / (color * (a * color + b) + d * f)) - e / f; +} + +INLINE vec3 tonemapUncharted2(vec3 color) +{ + const float W = 11.2F; + const float exposure_bias = 2.0F; + color = tonemapUncharted2Impl(color * exposure_bias); + vec3 white_scale = vec3(1.0F) / tonemapUncharted2Impl(vec3(W)); + // We apply pow() here instead of calling toSrgb to match the + // original implementation. + return pow(color * white_scale, vec3(1.0F / 2.2F)); +} + +/** @DOC_START +# Function `tonemapACES` +> An approximation by Stephen Hill to the Academy Color Encoding System's +> filmic curve for displaying HDR images on LDR output devices. + +From https://github.com/TheRealMJP/BakingLab/blob/master/BakingLab/ACES.hlsl, +via https://knarkowicz.wordpress.com/2016/01/06/aces-filmic-tone-mapping-curve/ +@DOC_END */ +INLINE vec3 tonemapACES(vec3 color) +{ + // Input transform + const mat3 ACESInputMat = mat3(0.59719F, 0.07600F, 0.02840F, // Column 1 + 0.35458F, 0.90834F, 0.13383F, // Column 2 + 0.04823F, 0.01566F, 0.83777F); // Column 3 + color = ACESInputMat * color; + // RRT and ODT fit + vec3 a = color * (color + vec3(0.0245786F)) - vec3(0.000090537F); + vec3 b = color * (vec3(0.983729F) * color + vec3(0.4329510F)) + vec3(0.238081F); + color = a / b; // Always OK because of the large constant term in b's polynomial + // Output transform + const mat3 ACESOutputMat = mat3(1.60475F, -0.10208F, -0.00327F, // + -0.53108F, 1.10813F, -0.07276F, // + -0.07367F, -0.00605F, 1.07602F); + color = ACESOutputMat * color; + return toSrgb(color); +} + +/** @DOC_START +# Function `tonemapAgX` +> Benjamin Wrensch's approximation to the AgX tone mapping curve by Troy Sobotka. + +From https://iolite-engine.com/blog_posts/minimal_agx_implementation +@DOC_END */ +INLINE vec3 tonemapAgX(vec3 color) +{ + // Input transform + const mat3 agx_mat = mat3(0.842479062253094F, 0.0423282422610123F, 0.0423756549057051F, // + 0.0784335999999992F, 0.878468636469772F, 0.0784336F, // + 0.0792237451477643F, 0.0791661274605434F, 0.879142973793104F); + color = agx_mat * color; + + // Log2 space encoding + const float min_ev = -12.47393f; + const float max_ev = 4.026069f; + color = clamp(log2(color), min_ev, max_ev); + color = (color - min_ev) / (max_ev - min_ev); + + // Apply 6th-order sigmoid function approximation + vec3 v = fma(vec3(15.5F), color, vec3(-40.14F)); + v = fma(color, v, vec3(31.96F)); + v = fma(color, v, vec3(-6.868F)); + v = fma(color, v, vec3(0.4298F)); + v = fma(color, v, vec3(0.1191F)); + v = fma(color, v, vec3(-0.0023F)); + + // Output transform + const mat3 agx_mat_inv = mat3(1.19687900512017F, -0.0528968517574562F, -0.0529716355144438F, // + -0.0980208811401368F, 1.15190312990417F, -0.0980434501171241F, // + -0.0990297440797205F, -0.0989611768448433F, 1.15107367264116F); + v = agx_mat_inv * v; + + // Skip the pow(..., vec3(2.2)), because we want sRGB output here. + return v; +} + +/** @DOC_START +# Function `tonemapKhronosPBR` +> The Khronos PBR neutral tone mapper. + +Adapted from https://github.com/KhronosGroup/ToneMapping/blob/main/PBR_Neutral/pbrNeutral.glsl +@DOC_END */ +INLINE vec3 tonemapKhronosPBR(vec3 color) +{ + const float startCompression = 0.8F - 0.04F; + const float desaturation = 0.15F; + +#ifdef __cplusplus + float x = glm::min(color.x, glm::min(color.y, color.z)); + float peak = glm::max(color.x, glm::max(color.y, color.z)); +#else + float x = min(color.x, min(color.y, color.z)); + float peak = max(color.x, max(color.y, color.z)); +#endif + + float offset = x < 0.08F ? x * (-6.25F * x + 1.F) : 0.04F; + color -= offset; + + if(peak >= startCompression) + { + const float d = 1.F - startCompression; + float newPeak = 1.F - d * d / (peak + d - startCompression); + color *= newPeak / peak; + + float g = 1.F - 1.F / (desaturation * (peak - newPeak) + 1.F); + color = mix(color, vec3(newPeak), g); + } + return toSrgb(color); +} + +/* @DOC_START +> Applies the given tone mapper and color grading settings to a given color. + +Requires the UV coordinate so that it can apply vignetting. +@DOC_END */ +INLINE vec3 applyTonemap(Tonemapper tm, vec3 color, vec2 uv) +{ + // Exposure + color *= tm.exposure; + vec3 c; + // Tonemap + switch(tm.method) + { + case eTonemapFilmic: + c = tonemapFilmic(color); + break; + case eTonemapUncharted2: + c = tonemapUncharted2(color); + break; + case eTonemapClip: + c = toSrgb(color); + break; + case eTonemapACES: + c = tonemapACES(color); + break; + case eTonemapAgX: + c = tonemapAgX(color); + break; + case eTonemapKhronosPBR: + c = tonemapKhronosPBR(color); + break; + } + // contrast and clamp + c = clamp(mix(vec3(0.5F), c, vec3(tm.contrast)), vec3(0.F), vec3(1.F)); + // brightness + c = pow(c, vec3(1.0F / tm.brightness)); + // saturation + vec3 i = vec3(dot(c, vec3(0.299F, 0.587F, 0.114F))); + c = mix(i, c, tm.saturation); + // vignette + vec2 center_uv = ((uv)-vec2(0.5F)) * vec2(2.0F); + c *= 1.0F - dot(center_uv, center_uv) * tm.vignette; + + return c; +} + +#ifdef __cplusplus +} // namespace nvvkhl_shaders +#endif + +#endif // DH_TONEMAMP_H diff --git a/nvpro_core_legacy/nvvkhl/shaders/func.h b/nvpro_core_legacy/nvvkhl/shaders/func.h new file mode 100644 index 0000000..e2f4922 --- /dev/null +++ b/nvpro_core_legacy/nvvkhl/shaders/func.h @@ -0,0 +1,267 @@ +/* + * Copyright (c) 2022-2024, NVIDIA CORPORATION. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-FileCopyrightText: Copyright (c) 2022-2024, NVIDIA CORPORATION. + * SPDX-License-Identifier: Apache-2.0 + */ + +#ifndef NVVKHL_FUNC_H +#define NVVKHL_FUNC_H 1 + +/* @DOC_START +Useful utility functions for shaders. +@DOC_END */ + +#include "constants.h" + +#ifdef __cplusplus +#ifndef OUT_TYPE +#define OUT_TYPE(T) T& +#endif +using glm::atan; +using glm::clamp; +using glm::cross; +using glm::dot; +using glm::mat4; +using glm::max; +using glm::mix; +using glm::normalize; +using glm::sqrt; +using glm::vec2; +using glm::vec3; +using glm::vec4; +#else +#define OUT_TYPE(T) out T +precision highp float; +#define static +#define inline +#endif + + +inline float square(float x) +{ + return x * x; +} + +/* @DOC_START +# Function `saturate` +> Clamps a value to the range [0,1]. +@DOC_END */ +inline float saturate(float x) +{ + return clamp(x, 0.0F, 1.0F); +} + +inline vec3 saturate(vec3 x) +{ + return clamp(x, vec3(0.0F), vec3(1.0F)); +} + +/* @DOC_START +# Function `luminance` +> Returns the luminance of a linear RGB color, using Rec. 709 coefficients. +@DOC_END */ +inline float luminance(vec3 color) +{ + return color.x * 0.2126F + color.y * 0.7152F + color.z * 0.0722F; +} + +/* @DOC_START +# Function `clampedDot` +> Takes the dot product of two values and clamps the result to [0,1]. +@DOC_END */ +inline float clampedDot(vec3 x, vec3 y) +{ + return clamp(dot(x, y), 0.0F, 1.0F); +} + +/* @DOC_START +# Function `orthonormalBasis` +> Builds an orthonormal basis: given only a normal vector, returns a +tangent and bitangent. + +This uses the technique from "Improved accuracy when building an orthonormal +basis" by Nelson Max, https://jcgt.org/published/0006/01/02. + +Any tangent-generating algorithm must produce at least one discontinuity +when operating on a sphere (due to the hairy ball theorem); this has a +small ring-shaped discontinuity at `normal.z == -0.99998796`. +@DOC_END */ +inline void orthonormalBasis(vec3 normal, OUT_TYPE(vec3) tangent, OUT_TYPE(vec3) bitangent) +{ + if(normal.z < -0.99998796F) // Handle the singularity + { + tangent = vec3(0.0F, -1.0F, 0.0F); + bitangent = vec3(-1.0F, 0.0F, 0.0F); + return; + } + float a = 1.0F / (1.0F + normal.z); + float b = -normal.x * normal.y * a; + tangent = vec3(1.0F - normal.x * normal.x * a, b, -normal.x); + bitangent = vec3(b, 1.0f - normal.y * normal.y * a, -normal.y); +} + +/* @DOC_START +# Function `makeFastTangent` +> Like `orthonormalBasis()`, but returns a tangent and tangent sign that matches +> the glTF convention. +@DOC_END */ +inline vec4 makeFastTangent(vec3 normal) +{ + vec3 tangent, unused; + orthonormalBasis(normal, tangent, unused); + // The glTF bitangent sign here is 1.f since for + // normal == vec3(0.0F, 0.0F, 1.0F), we get + // tangent == vec3(1.0F, 0.0F, 0.0F) and bitangent == vec3(0.0F, 1.0F, 0.0F), + // so bitangent = cross(normal, tangent). + return vec4(tangent, 1.f); +} + +/* @DOC_START +# Function `rotate` +> Rotates the vector `v` around the unit direction `k` by an angle of `theta`. + +At `theta == pi/2`, returns `cross(k, v) + k * dot(k, v)`. This means that +rotations are clockwise in right-handed coordinate systems and +counter-clockwise in left-handed coordinate systems. +@DOC_END */ +inline vec3 rotate(vec3 v, vec3 k, float theta) +{ + float cos_theta = cos(theta); + float sin_theta = sin(theta); + + return (v * cos_theta) + (cross(k, v) * sin_theta) + (k * dot(k, v)) * (1.0F - cos_theta); +} + + +/* @DOC_START +# Function `getSphericalUv` +> Given a direction, returns the UV coordinate of an environment map for that +> direction using a spherical projection. +@DOC_END */ +inline vec2 getSphericalUv(vec3 v) +{ + float gamma = asin(-v.y); + float theta = atan(v.z, v.x); + + vec2 uv = vec2(theta * M_1_OVER_PI * 0.5F, gamma * M_1_OVER_PI) + 0.5F; + return uv; +} + +/* @DOC_START +# Function `mixBary` +> Interpolates between 3 values, using the barycentric coordinates of a triangle. +@DOC_END */ +inline vec2 mixBary(vec2 a, vec2 b, vec2 c, vec3 bary) +{ + return a * bary.x + b * bary.y + c * bary.z; +} + +inline vec3 mixBary(vec3 a, vec3 b, vec3 c, vec3 bary) +{ + return a * bary.x + b * bary.y + c * bary.z; +} + +inline vec4 mixBary(vec4 a, vec4 b, vec4 c, vec3 bary) +{ + return a * bary.x + b * bary.y + c * bary.z; +} + +/* @DOC_START +# Function `cosineSampleHemisphere +> Samples a hemisphere using a cosine-weighted distribution. + +See https://www.realtimerendering.com/raytracinggems/unofficial_RayTracingGems_v1.4.pdf, +section 16.6.1, "COSINE-WEIGHTED HEMISPHERE ORIENTED TO THE Z-AXIS". +@DOC_END */ +inline vec3 cosineSampleHemisphere(float r1, float r2) +{ + float r = sqrt(r1); + float phi = M_TWO_PI * r2; + vec3 dir; + dir.x = r * cos(phi); + dir.y = r * sin(phi); + dir.z = sqrt(1.F - r1); + return dir; +} + +/* @DOC_START +# Function `powerHeuristic` +> The power heuristic for multiple importance sampling, with `beta = 2`. + +See equation 9.13 of https://graphics.stanford.edu/papers/veach_thesis/thesis.pdf. +@DOC_END */ +inline float powerHeuristic(float a, float b) +{ + const float t = a * a; + return t / (b * b + t); +} + +/* @DOC_START +# Function `sampleBlur` +> Samples a texture with a Gaussian blur kernel. +@DOC_END */ + +#ifndef __cplusplus +#extension GL_EXT_control_flow_attributes : require +vec4 sampleBlur(sampler2D texture, vec2 uv, float lodLevel) +{ + // G(x, y) = (1 / (2 * pi * sigma^2)) * exp(-(x^2 + y^2) / (2 * sigma^2)) + // Gaussian blur kernel normalized + const mat3 WEIGHTS_2D = mat3(0.0625, 0.125, 0.0625, 0.125, 0.25, 0.125, 0.0625, 0.125, 0.0625); + + vec2 texelSize = 1.0 / textureSize(texture, int(lodLevel)); + + vec4 color = vec4(0.0); + [[unroll]] for(int i = 0; i < 3; i++) + { + [[unroll]] for(int j = 0; j < 3; j++) + { + vec2 offsetUV = vec2(i - 1, j - 1) * texelSize; + color += textureLod(texture, uv + offsetUV, lodLevel) * WEIGHTS_2D[i][j]; + } + } + return color; +} + +/* @DOC_START +# Function `smoothHDRBlur` +> Samples a texture with a Gaussian blur kernel, using multiple LOD levels. +* The blur amount controls the blending between the two LOD levels. +@DOC_END */ +vec4 smoothHDRBlur(sampler2D texture, vec2 uv, float blurAmount) +{ + // Calculate the maximum LOD level + float maxLOD = float(textureQueryLevels(texture)) - 1.0; + + // Calculate two adaptive LOD levels + float lod0 = max(0, (maxLOD * blurAmount) - 2); + float lod1 = maxLOD * blurAmount; + + // Sample multiple adaptive mip levels + vec4 color0 = sampleBlur(texture, uv, lod0); + vec4 color1 = sampleBlur(texture, uv, lod1); + + // Blend between two mip levels, each of which depend on `blurAmount`. + float blurMix = 1.0 - pow(1.0 - blurAmount, 1.0 / 1.5); + vec4 blendedColor = mix(color0, color1, 0.5); + + return blendedColor; +} + +#endif // __cplusplus + +#undef OUT_TYPE +#endif // NVVKHL_FUNC_H \ No newline at end of file diff --git a/nvpro_core_legacy/nvvkhl/shaders/ggx.h b/nvpro_core_legacy/nvvkhl/shaders/ggx.h new file mode 100644 index 0000000..38d9fed --- /dev/null +++ b/nvpro_core_legacy/nvvkhl/shaders/ggx.h @@ -0,0 +1,458 @@ +/* + * Copyright (c) 2022-2024, NVIDIA CORPORATION. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-FileCopyrightText: Copyright (c) 2022-2024, NVIDIA CORPORATION. + * SPDX-License-Identifier: Apache-2.0 + */ + + +#ifndef NVVKHL_GGX_H +#define NVVKHL_GGX_H 1 + +/* @DOC_START +Lower-level mathematical functions used for BSDFs. This file is named after the +GGX normal distribution, which is the basis for much of nvvkhl's BSDF code, but +includes Fresnel, shadowing-masking, sheen, and thin-film functions as well. +@DOC_END */ + +#include "constants.h" + +#ifdef __cplusplus +#define OUT_TYPE(T) T& +#define INOUT_TYPE(T) T& +#else +#define OUT_TYPE(T) out T +#define INOUT_TYPE(T) inout T +#endif + +float schlickFresnel(float F0, float F90, float VdotH) +{ + return F0 + (F90 - F0) * pow(1.0F - VdotH, 5.0F); +} + +vec3 schlickFresnel(vec3 F0, vec3 F90, float VdotH) +{ + return F0 + (F90 - F0) * pow(1.0F - VdotH, 5.0F); +} + +float schlickFresnel(float ior, float VdotH) +{ + // Calculate reflectance at normal incidence (R0) + float R0 = pow((1.0F - ior) / (1.0F + ior), 2.0F); + + // Fresnel reflectance using Schlick's approximation + return R0 + (1.0F - R0) * pow(1.0F - VdotH, 5.0F); +} + + +//----------------------------------------------------------------------- +// MDL-based functions +//----------------------------------------------------------------------- + +vec3 mix_rgb(const vec3 base, const vec3 layer, const vec3 factor) +{ + return (1.0f - max(factor.x, max(factor.y, factor.z))) * base + factor * layer; +} + +// Square the input +float sqr(float x) +{ + return x * x; +} + +// Check for total internal reflection. `kh` is the dot product of the view +// vector and the half vector. +bool isTIR(const vec2 ior, const float kh) +{ + const float b = ior.x / ior.y; + return (1.0f < (b * b * (1.0f - kh * kh))); +} + + +/* @DOC_START +# Function `hvd_ggx_eval` +> Evaluates anisotropic GGX distribution on the non-projected hemisphere (i.e. +> +z is up) +@DOC_END */ +float hvd_ggx_eval(const vec2 invRoughness, + const vec3 h) // == vec3(dot(tangent, h), dot(bitangent, h), dot(normal, h)) +{ + const float x = h.x * invRoughness.x; + const float y = h.y * invRoughness.y; + const float aniso = x * x + y * y; + const float f = aniso + h.z * h.z; + + return M_1_PI * invRoughness.x * invRoughness.y * h.z / (f * f); +} + +/* @DOC_START +# Function `hvd_ggx_sample_vndf` +> Samples Samples a visible (Smith-masked) half vector according to the anisotropic GGX distribution. + +See Eric Heitz, "A Simpler and Exact Sampling Routine for the GGX Distribution of Visible Normals". + +The input and output will be in local space: +`vec3(dot(T, k1), dot(B, k1), dot(N, k1))`. +@DOC_END */ +vec3 hvd_ggx_sample_vndf(vec3 k, vec2 roughness, vec2 xi) +{ + const vec3 v = normalize(vec3(k.x * roughness.x, k.y * roughness.y, k.z)); + + const vec3 t1 = (v.z < 0.99999f) ? normalize(cross(v, vec3(0.0f, 0.0f, 1.0f))) : vec3(1.0f, 0.0f, 0.0f); + const vec3 t2 = cross(t1, v); + + const float a = 1.0f / (1.0f + v.z); + const float r = sqrt(xi.x); + + const float phi = (xi.y < a) ? xi.y / a * M_PI : M_PI + (xi.y - a) / (1.0f - a) * M_PI; + float sp = sin(phi); + float cp = cos(phi); + const float p1 = r * cp; + const float p2 = r * sp * ((xi.y < a) ? 1.0f : v.z); + + vec3 h = p1 * t1 + p2 * t2 + sqrt(max(0.0f, 1.0f - p1 * p1 - p2 * p2)) * v; + + h.x *= roughness.x; + h.y *= roughness.y; + h.z = max(0.0f, h.z); + return normalize(h); +} + +float smith_shadow_or_mask(const vec3 k, const vec2 roughness) +{ + float kz2 = k.z * k.z; + if(kz2 == 0.0f) + { + return 0.0f; // Totally shadowed + } + const float ax = k.x * roughness.x; + const float ay = k.y * roughness.y; + const float inv_a2 = (ax * ax + ay * ay) / kz2; + + return 2.0f / (1.0f + sqrt(1.0f + inv_a2)); +} + +/* @DOC_START +# Function `ggx_smith_shadow_mask` +> The uncorrelated Smith shadowing-masking function. + +Note that the joint Smith shadowing-masking function may be more realistic. +@DOC_END */ +float ggx_smith_shadow_mask(OUT_TYPE(float) G1, OUT_TYPE(float) G2, const vec3 k1, const vec3 k2, const vec2 roughness) +{ + G1 = smith_shadow_or_mask(k1, roughness); + G2 = smith_shadow_or_mask(k2, roughness); + + return G1 * G2; +} + + +// Computes the squared norm of s/p polarized Fresnel reflection coefficients and phase shifts in complex unit circle. +// +// See Max Born and Emil Wolf, "Principles of Optics", section 13.4.1, +// "An absorbing film on a transparent substrate". +// +// This comes from MDL, and is a different approach than the example +// implementation in KHR_materials_iridescence. +vec2 fresnel_conductor(OUT_TYPE(vec2) phase_shift_sin, + OUT_TYPE(vec2) phase_shift_cos, + const float n_a, + const float n_b, + const float k_b, + const float cos_a, + const float sin_a_sqd) +{ + const float k_b2 = k_b * k_b; + const float n_b2 = n_b * n_b; + const float n_a2 = n_a * n_a; + const float tmp0 = n_b2 - k_b2; + const float half_U = 0.5f * (tmp0 - n_a2 * sin_a_sqd); + const float half_V = sqrt(max(0.0f, half_U * half_U + k_b2 * n_b2)); + + const float u_b2 = half_U + half_V; + const float v_b2 = half_V - half_U; + const float u_b = sqrt(max(0.0f, u_b2)); + const float v_b = sqrt(max(0.0f, v_b2)); + + const float tmp1 = tmp0 * cos_a; + const float tmp2 = n_a * u_b; + const float tmp3 = (2.0f * n_b * k_b) * cos_a; + const float tmp4 = n_a * v_b; + const float tmp5 = n_a * cos_a; + + const float tmp6 = (2.0f * tmp5) * v_b; + const float tmp7 = (u_b2 + v_b2) - tmp5 * tmp5; + + const float tmp8 = (2.0f * tmp5) * ((2.0f * n_b * k_b) * u_b - tmp0 * v_b); + const float tmp9 = sqr((n_b2 + k_b2) * cos_a) - n_a2 * (u_b2 + v_b2); + + const float tmp67 = tmp6 * tmp6 + tmp7 * tmp7; + const float inv_sqrt_x = (0.0f < tmp67) ? (1.0f / sqrt(tmp67)) : 0.0f; + const float tmp89 = tmp8 * tmp8 + tmp9 * tmp9; + const float inv_sqrt_y = (0.0f < tmp89) ? (1.0f / sqrt(tmp89)) : 0.0f; + + phase_shift_cos = vec2(tmp7 * inv_sqrt_x, tmp9 * inv_sqrt_y); + phase_shift_sin = vec2(tmp6 * inv_sqrt_x, tmp8 * inv_sqrt_y); + + return vec2((sqr(tmp5 - u_b) + v_b2) / (sqr(tmp5 + u_b) + v_b2), + (sqr(tmp1 - tmp2) + sqr(tmp3 - tmp4)) / (sqr(tmp1 + tmp2) + sqr(tmp3 + tmp4))); +} + + +// Simplified for dielectric, no phase shift computation. +vec2 fresnel_dielectric(const float n_a, const float n_b, const float cos_a, const float cos_b) +{ + const float naca = n_a * cos_a; + const float nbcb = n_b * cos_b; + const float r_s = (naca - nbcb) / (naca + nbcb); + + const float nacb = n_a * cos_b; + const float nbca = n_b * cos_a; + const float r_p = (nbca - nacb) / (nbca + nacb); + + return vec2(r_s * r_s, r_p * r_p); +} + + +vec3 thin_film_factor(float coating_thickness, const float coating_ior, const float base_ior, const float incoming_ior, const float kh) +{ + coating_thickness = max(0.0f, coating_thickness); + + const float sin0_sqr = max(0.0f, 1.0f - kh * kh); + const float eta01 = incoming_ior / coating_ior; + const float eta01_sqr = eta01 * eta01; + const float sin1_sqr = eta01_sqr * sin0_sqr; + + if(1.0f < sin1_sqr) // TIR at first interface + { + return vec3(1.0f); + } + + const float cos1 = sqrt(max(0.0f, 1.0f - sin1_sqr)); + const vec2 R01 = fresnel_dielectric(incoming_ior, coating_ior, kh, cos1); + + vec2 phi12_sin, phi12_cos; + const vec2 R12 = fresnel_conductor(phi12_sin, phi12_cos, coating_ior, base_ior, /* base_k = */ 0.0f, cos1, sin1_sqr); + + const float tmp = (4.0f * M_PI) * coating_ior * coating_thickness * cos1; + + const float R01R12_s = max(0.0f, R01.x * R12.x); + const float r01r12_s = sqrt(R01R12_s); + + const float R01R12_p = max(0.0f, R01.y * R12.y); + const float r01r12_p = sqrt(R01R12_p); + + vec3 xyz = vec3(0.0f); + + //!! using low res color matching functions here + float lambda_min = 400.0f; + float lambda_step = ((700.0f - 400.0f) / 16.0f); + + const vec3 cie_xyz[16] = {{0.02986f, 0.00310f, 0.13609f}, {0.20715f, 0.02304f, 0.99584f}, + {0.36717f, 0.06469f, 1.89550f}, {0.28549f, 0.13661f, 1.67236f}, + {0.08233f, 0.26856f, 0.76653f}, {0.01723f, 0.48621f, 0.21889f}, + {0.14400f, 0.77341f, 0.05886f}, {0.40957f, 0.95850f, 0.01280f}, + {0.74201f, 0.97967f, 0.00060f}, {1.03325f, 0.84591f, 0.00000f}, + {1.08385f, 0.62242f, 0.00000f}, {0.79203f, 0.36749f, 0.00000f}, + {0.38751f, 0.16135f, 0.00000f}, {0.13401f, 0.05298f, 0.00000f}, + {0.03531f, 0.01375f, 0.00000f}, {0.00817f, 0.00317f, 0.00000f}}; + + float lambda = lambda_min + 0.5f * lambda_step; + + for(int i = 0; i < 16; ++i) + { + const float phi = tmp / lambda; + + float phi_s = sin(phi); + float phi_c = cos(phi); + + const float cos_phi_s = phi_c * phi12_cos.x - phi_s * phi12_sin.x; // cos(a+b) = cos(a) * cos(b) - sin(a) * sin(b) + const float tmp_s = 2.0f * r01r12_s * cos_phi_s; + const float R_s = (R01.x + R12.x + tmp_s) / (1.0f + R01R12_s + tmp_s); + + const float cos_phi_p = phi_c * phi12_cos.y - phi_s * phi12_sin.y; // cos(a+b) = cos(a) * cos(b) - sin(a) * sin(b) + const float tmp_p = 2.0f * r01r12_p * cos_phi_p; + const float R_p = (R01.y + R12.y + tmp_p) / (1.0f + R01R12_p + tmp_p); + + xyz += cie_xyz[i] * (0.5f * (R_s + R_p)); + + lambda += lambda_step; + } + + xyz *= (1.0f / 16.0f); + + // ("normalized" such that the loop for no shifted wave gives reflectivity (1,1,1)) + return clamp(vec3(xyz.x * (3.2406f / 0.433509f) + xyz.y * (-1.5372f / 0.433509f) + xyz.z * (-0.4986f / 0.433509f), + xyz.x * (-0.9689f / 0.341582f) + xyz.y * (1.8758f / 0.341582f) + xyz.z * (0.0415f / 0.341582f), + xyz.x * (0.0557f / 0.32695f) + xyz.y * (-0.204f / 0.32695f) + xyz.z * (1.057f / 0.32695f)), + 0.0f, 1.0f); +} + + +// Compute half vector (convention: pointing to outgoing direction, like shading normal) +vec3 compute_half_vector(const vec3 k1, const vec3 k2, const vec3 normal, const vec2 ior, const float nk2, const bool transmission, const bool thinwalled) +{ + vec3 h; + + if(transmission) + { + if(thinwalled) // No refraction! + { + h = k1 + (normal * (nk2 + nk2) + k2); // Use corresponding reflection direction. + } + else + { + h = k2 * ior.y + k1 * ior.x; // Points into thicker medium. + + if(ior.y > ior.x) + { + h *= -1.0f; // Make pointing to outgoing direction's medium. + } + } + } + else + { + h = k1 + k2; // unnormalized half-vector + } + + return normalize(h); +} + +vec3 refract(const vec3 k, // direction (pointing from surface) + const vec3 n, // normal + const float b, // (reflected side IOR) / (transmitted side IOR) + const float nk, // dot(n, k) + OUT_TYPE(bool) tir) // total internal reflection +{ + const float refraction = b * b * (1.0f - nk * nk); + + tir = (1.0f <= refraction); + + return (tir) ? (n * (nk + nk) - k) : normalize((-k * b + n * (b * nk - sqrt(1.0f - refraction)))); +} + + +/* @DOC_START +# Function `ior_fresnel` +> Fresnel equation for an equal mix of polarization. +@DOC_END */ +float ior_fresnel(const float eta, // refracted / reflected ior + const float kh) // cosine of angle between normal/half-vector and direction +{ + float costheta = 1.0f - (1.0f - kh * kh) / (eta * eta); + + if(costheta <= 0.0f) + { + return 1.0f; + } + + costheta = sqrt(costheta); // refracted angle cosine + + const float n1t1 = kh; + const float n1t2 = costheta; + const float n2t1 = kh * eta; + const float n2t2 = costheta * eta; + const float r_p = (n1t2 - n2t1) / (n1t2 + n2t1); + const float r_o = (n1t1 - n2t2) / (n1t1 + n2t2); + + const float fres = 0.5f * (r_p * r_p + r_o * r_o); + + return clamp(fres, 0.0f, 1.0f); +} + +/* @DOC_START +# Function `hvd_sheen_eval` +> Evaluates the anisotropic sheen half-vector distribution on the non-projected hemisphere. +@DOC_END */ +float hvd_sheen_eval(const float invRoughness, + const float nh) // dot(shading_normal, h) +{ + const float sinTheta2 = max(0.0f, 1.0f - nh * nh); + const float sinTheta = sqrt(sinTheta2); + + return (invRoughness + 2.0f) * pow(sinTheta, invRoughness) * 0.5f * M_1_PI * nh; +} + + +// Just the masking term for the v-cavity model. +float vcavities_mask(const float nh, // abs(dot(normal, half)) + const float kh, // abs(dot(dir, half)) + const float nk) // abs(dot(normal, dir)) +{ + return min(2.0f * nh * nk / kh, 1.0f); +} + + +/* @DOC_START +# Function `vcavities_shadow_mask` +> Cook-Torrance style v-cavities shadowing-masking term. +@DOC_END */ +float vcavities_shadow_mask(OUT_TYPE(float) G1, OUT_TYPE(float) G2, const float nh, const vec3 k1, const float k1h, const vec3 k2, const float k2h) +{ + G1 = vcavities_mask(nh, k1h, k1.z); // In my renderer the z-coordinate is the normal! + G2 = vcavities_mask(nh, k2h, k2.z); + + //return (refraction) ? fmaxf(0.0f, G1 + G2 - 1.0f) : fminf(G1, G2); + return min(G1, G2); // PERF Need reflection only. +} + + +/* @DOC_START +# Function `hvd_sheen_sample` +> Samples a half-vector according to an anisotropic sheen distribution. +@DOC_END */ +vec3 hvd_sheen_sample(const vec2 xi, const float invRoughness) +{ + const float phi = 2.0f * M_PI * xi.x; + + float sinPhi = sin(phi); + float cosPhi = cos(phi); + + const float sinTheta = pow(1.0f - xi.y, 1.0f / (invRoughness + 2.0f)); + const float cosTheta = sqrt(1.0f - sinTheta * sinTheta); + + return normalize(vec3(cosPhi * sinTheta, sinPhi * sinTheta, + cosTheta)); // In my renderer the z-coordinate is the normal! +} + +vec3 flip(const vec3 h, const vec3 k, float xi) +{ + const float a = h.z * k.z; + const float b = h.x * k.x + h.y * k.y; + + const float kh = max(0.0f, a + b); + const float kh_f = max(0.0f, a - b); + + const float p_flip = kh_f / (kh + kh_f); + + // PERF xi is not used after this operation by the only caller brdf_sheen_sample(), + // so there is no need to scale the sample. + //if (xi < p_flip) + //{ + // xi /= p_flip; + // return make_float3(-h.x, -h.y, h.z); + //} + //else + //{ + // xi = (xi - p_flip) / (1.0f - p_flip); + // return h; + //} + + return (xi < p_flip) ? vec3(-h.x, -h.y, h.z) : h; +} + + +#undef OUT_TYPE +#endif // NVVKHL_GGX_H diff --git a/nvpro_core_legacy/nvvkhl/shaders/passthrough.vert.glsl b/nvpro_core_legacy/nvvkhl/shaders/passthrough.vert.glsl new file mode 100644 index 0000000..4b76dad --- /dev/null +++ b/nvpro_core_legacy/nvvkhl/shaders/passthrough.vert.glsl @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2022-2024, NVIDIA CORPORATION. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-FileCopyrightText: Copyright (c) 2022-2024, NVIDIA CORPORATION. + * SPDX-License-Identifier: Apache-2.0 + */ + + +#version 450 +layout(location = 0) out vec2 outUv; + + +out gl_PerVertex +{ + vec4 gl_Position; +}; + + +void main() +{ + outUv = vec2((gl_VertexIndex << 1) & 2, gl_VertexIndex & 2); + gl_Position = vec4(outUv * 2.0f - 1.0f, 1.0f, 1.0f); +} diff --git a/nvpro_core_legacy/nvvkhl/shaders/pbr_mat_eval.h b/nvpro_core_legacy/nvvkhl/shaders/pbr_mat_eval.h new file mode 100644 index 0000000..b8e114e --- /dev/null +++ b/nvpro_core_legacy/nvvkhl/shaders/pbr_mat_eval.h @@ -0,0 +1,377 @@ +/* + * Copyright (c) 2022-2025, NVIDIA CORPORATION. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-FileCopyrightText: Copyright (c) 2022-2025, NVIDIA CORPORATION. + * SPDX-License-Identifier: Apache-2.0 + */ + +/* @DOC_START +This file takes the incoming `GltfShadeMaterial` (material uploaded in a buffer) and +evaluates it, basically sampling the textures, and returns the struct `PbrMaterial` +which is used by the BSDF functions to evaluate and sample the material. +@DOC_END */ + +#ifndef MAT_EVAL_H +#define MAT_EVAL_H 1 + +#include "pbr_mat_struct.h" + +struct MeshState +{ + vec3 N; // Normal + vec3 T; // Tangent + vec3 B; // Bitangent + vec3 Ng; // Geometric normal + vec2 tc[2]; // Texture coordinates + bool isInside; +}; + + +/* @DOC_START +# `MAT_EVAL_TEXTURE_ARRAY` Define +> The name of the array that contains all texture samplers. + +Defaults to `texturesMap`; you can define this before including `pbr_mat_eval.h` +to use textures from a different array name. +@DOC_END */ +#ifndef MAT_EVAL_TEXTURE_ARRAY +#define MAT_EVAL_TEXTURE_ARRAY texturesMap +#endif + +/* @DOC_START +# `NO_TEXTURES` Define +> Define this before including `pbr_mat_eval.h` to use a color of `vec4(1.0f)` +> for everything instead of reading textures. +@DOC_END */ +#ifndef NO_TEXTURES +#define USE_TEXTURES +#endif + +vec4 getTexture(in GltfTextureInfo tinfo, in vec2 tc[2]) +{ +#ifdef USE_TEXTURES + // KHR_texture_transform + vec2 texCoord = vec2(vec3(tc[tinfo.texCoord], 1) * tinfo.uvTransform); + return texture(MAT_EVAL_TEXTURE_ARRAY[nonuniformEXT(tinfo.index)], texCoord); +#else + return vec4(1.0F); +#endif +} + +bool isTexturePresent(in GltfTextureInfo tinfo) +{ + return tinfo.index > -1; +} + +/* @DOC_START +* Convert PBR specular glossiness to metallic-roughness +* @DOC_END */ +vec3 convertSGToMR(vec3 diffuseColor, vec3 specularColor, float glossiness, out float metallic, out vec2 roughness) +{ + // Constants + const float dielectricSpecular = 0.04f; // F0 for dielectrics + + // Compute metallic factor + float specularIntensity = max(specularColor.r, max(specularColor.g, specularColor.b)); + float isMetal = smoothstep(dielectricSpecular + 0.01f, dielectricSpecular + 0.05f, specularIntensity); + metallic = isMetal; + + // Compute base color + vec3 baseColor; + if(metallic > 0.0f) + { + // Metallic: Use specular as base color + baseColor = specularColor; + } + else + { + // Non-metallic: Correct diffuse color for energy conservation + baseColor = diffuseColor / (1.0f - dielectricSpecular * (1.0f - metallic)); + baseColor = clamp(baseColor, 0.0f, 1.0f); // Ensure valid color + } + + // Compute roughness + float r = 1.0f - glossiness; + roughness = vec2(r * r); + + return baseColor; +} + +/* @DOC_START +# `MICROFACET_MIN_ROUGHNESS` Define +> Minimum roughness for microfacet models. + +This protects microfacet code from dividing by 0, as well as from numerical +instability around roughness == 0. However, it also means even roughness-0 +surfaces will be rendered with a tiny amount of roughness. + +This value is ad-hoc; it could probably be lowered without issue. +@DOC_END */ +#define MICROFACET_MIN_ROUGHNESS 0.0014142f + +/* @DOC_START +# Function `evaluateMaterial` +> From the incoming `material` and `mesh` info, return a `PbrMaterial` struct +> for the BSDF system. +@DOC_END */ +PbrMaterial evaluateMaterial(in GltfShadeMaterial material, MeshState state) +{ + // Material Evaluated + PbrMaterial pbrMat; + + // pbrMetallicRoughness (standard) + if(material.usePbrSpecularGlossiness == 0) + { + // Base Color/Albedo may be defined from a base texture or a flat color + vec4 baseColor = material.pbrBaseColorFactor; + if(isTexturePresent(material.pbrBaseColorTexture)) + { + baseColor *= getTexture(material.pbrBaseColorTexture, state.tc); + } + pbrMat.baseColor = baseColor.rgb; + pbrMat.opacity = baseColor.a; + + // Metallic-Roughness + float roughness = material.pbrRoughnessFactor; + float metallic = material.pbrMetallicFactor; + if(isTexturePresent(material.pbrMetallicRoughnessTexture)) + { + // Roughness is stored in the 'g' channel, metallic is stored in the 'b' channel. + vec4 metallicRoughnessSample = getTexture(material.pbrMetallicRoughnessTexture, state.tc); + roughness *= metallicRoughnessSample.g; + metallic *= metallicRoughnessSample.b; + } + roughness = max(roughness, MICROFACET_MIN_ROUGHNESS); + pbrMat.roughness = vec2(roughness * roughness); // Square roughness for the microfacet model + pbrMat.metallic = clamp(metallic, 0.0F, 1.0F); + } + else + { + // KHR_materials_pbrSpecularGlossiness: deprecated but still used in many places + vec4 diffuse = material.pbrDiffuseFactor; + float glossiness = material.pbrGlossinessFactor; + vec3 specular = material.pbrSpecularFactor; + + if(isTexturePresent(material.pbrDiffuseTexture)) + { + diffuse *= getTexture(material.pbrDiffuseTexture, state.tc); + } + + if(isTexturePresent(material.pbrSpecularGlossinessTexture)) + { + vec4 specularGlossinessSample = getTexture(material.pbrSpecularGlossinessTexture, state.tc); + specular *= specularGlossinessSample.rgb; + glossiness *= specularGlossinessSample.a; + } + + pbrMat.baseColor = convertSGToMR(diffuse.rgb, specular, glossiness, pbrMat.metallic, pbrMat.roughness); + pbrMat.opacity = diffuse.a; + } + + // Occlusion Map + pbrMat.occlusion = material.occlusionStrength; + if(isTexturePresent(material.occlusionTexture)) + { + float occlusion = getTexture(material.occlusionTexture, state.tc).r; + pbrMat.occlusion = 1.0 + pbrMat.occlusion * (occlusion - 1.0); + } + + // Normal Map + pbrMat.N = state.N; + pbrMat.T = state.T; + pbrMat.B = state.B; + pbrMat.Ng = state.Ng; + bool needsTangentUpdate = false; + + if(isTexturePresent(material.normalTexture)) + { + vec3 normal_vector = getTexture(material.normalTexture, state.tc).xyz; + normal_vector = normal_vector * 2.0F - 1.0F; + normal_vector *= vec3(material.normalTextureScale, material.normalTextureScale, 1.0F); + mat3 tbn = mat3(state.T, state.B, state.N); + pbrMat.N = normalize(tbn * normal_vector); + + // Mark that we need to update T and B due to normal perturbation + needsTangentUpdate = true; + } + + // Emissive term + pbrMat.emissive = material.emissiveFactor; + if(isTexturePresent(material.emissiveTexture)) + { + pbrMat.emissive *= getTexture(material.emissiveTexture, state.tc).rgb; + } + pbrMat.emissive = max(vec3(0.0F), pbrMat.emissive); + + // KHR_materials_specular + // https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_materials_specular + pbrMat.specularColor = material.specularColorFactor; + if(isTexturePresent(material.specularColorTexture)) + { + pbrMat.specularColor *= getTexture(material.specularColorTexture, state.tc).rgb; + } + + // KHR_materials_specular + pbrMat.specular = material.specularFactor; + if(isTexturePresent(material.specularTexture)) + { + pbrMat.specular *= getTexture(material.specularTexture, state.tc).a; + } + + // Dielectric Specular + float ior1 = 1.0F; // IOR of the current medium (e.g., air) + float ior2 = material.ior; // IOR of the material + if(state.isInside && (material.thicknessFactor > 0)) // If the material is thin-walled, we don't need to consider the inside IOR. + { + ior1 = material.ior; + ior2 = 1.0F; + } + pbrMat.ior1 = ior1; + pbrMat.ior2 = ior2; + + + // KHR_materials_transmission + pbrMat.transmission = material.transmissionFactor; + if(isTexturePresent(material.transmissionTexture)) + { + pbrMat.transmission *= getTexture(material.transmissionTexture, state.tc).r; + } + + // KHR_materials_volume + pbrMat.attenuationColor = material.attenuationColor; + pbrMat.attenuationDistance = material.attenuationDistance; + pbrMat.isThinWalled = (material.thicknessFactor == 0.0); + + // KHR_materials_clearcoat + pbrMat.clearcoat = material.clearcoatFactor; + pbrMat.clearcoatRoughness = material.clearcoatRoughness; + pbrMat.Nc = pbrMat.N; + if(isTexturePresent(material.clearcoatTexture)) + { + pbrMat.clearcoat *= getTexture(material.clearcoatTexture, state.tc).r; + } + if(isTexturePresent(material.clearcoatRoughnessTexture)) + { + pbrMat.clearcoatRoughness *= getTexture(material.clearcoatRoughnessTexture, state.tc).g; + } + if(isTexturePresent(material.clearcoatNormalTexture)) + { + mat3 tbn = mat3(pbrMat.T, pbrMat.B, pbrMat.Nc); + vec3 normal_vector = getTexture(material.clearcoatNormalTexture, state.tc).xyz; + normal_vector = normal_vector * 2.0F - 1.0F; + pbrMat.Nc = normalize(tbn * normal_vector); + } + pbrMat.clearcoatRoughness = max(pbrMat.clearcoatRoughness, 0.001F); + + // KHR_materials_iridescence + float iridescence = material.iridescenceFactor; + float iridescenceThickness = material.iridescenceThicknessMaximum; + pbrMat.iridescenceIor = material.iridescenceIor; + if(isTexturePresent(material.iridescenceTexture)) + { + iridescence *= getTexture(material.iridescenceTexture, state.tc).x; + } + if(isTexturePresent(material.iridescenceThicknessTexture)) + { + const float t = getTexture(material.iridescenceThicknessTexture, state.tc).y; + iridescenceThickness = mix(material.iridescenceThicknessMinimum, material.iridescenceThicknessMaximum, t); + } + pbrMat.iridescence = (iridescenceThickness > 0.0f) ? iridescence : 0.0f; // No iridescence when the thickness is zero. + pbrMat.iridescenceThickness = iridescenceThickness; + + // KHR_materials_anisotropy + float anisotropyStrength = material.anisotropyStrength; + // If the anisotropyStrength == 0.0f (default), the roughness is isotropic. + // No need to rotate the anisotropyDirection or tangent space. + if(anisotropyStrength > 0.0F) + { + vec2 anisotropyDirection = vec2(1.0f, 0.0f); // By default the anisotropy strength is along the tangent. + if(isTexturePresent(material.anisotropyTexture)) + { + const vec4 anisotropyTex = getTexture(material.anisotropyTexture, state.tc); + + // .xy encodes the direction in (tangent, bitangent) space. Remap from [0, 1] to [-1, 1]. + anisotropyDirection = normalize(vec2(anisotropyTex) * 2.0f - 1.0f); + // .z encodes the strength in range [0, 1]. + anisotropyStrength *= anisotropyTex.z; + } + + // Adjust the roughness to account for anisotropy. + pbrMat.roughness.x = mix(pbrMat.roughness.y, 1.0f, anisotropyStrength * anisotropyStrength); + + // Rotate the anisotropy direction in the tangent space. + const float s = material.anisotropyRotation.x; // Sin and Cos of the rotation angle. + const float c = material.anisotropyRotation.y; + anisotropyDirection = + vec2(c * anisotropyDirection.x + s * anisotropyDirection.y, c * anisotropyDirection.y - s * anisotropyDirection.x); + + // Update the tangent to be along the anisotropy direction in tangent space. + const vec3 T_aniso = pbrMat.T * anisotropyDirection.x + pbrMat.B * anisotropyDirection.y; + + pbrMat.T = T_aniso; + needsTangentUpdate = true; + } + + // Perform tangent and bitangent updates if necessary + if(needsTangentUpdate) + { + // Ensure T, B, and N are orthonormal + pbrMat.B = cross(pbrMat.N, pbrMat.T); + float bitangentSign = sign(dot(state.B, pbrMat.B)); + pbrMat.B = pbrMat.B * bitangentSign; + pbrMat.T = cross(pbrMat.B, pbrMat.N) * bitangentSign; + } + + // KHR_materials_sheen + pbrMat.sheenColor = material.sheenColorFactor; + if(isTexturePresent(material.sheenColorTexture)) + { + pbrMat.sheenColor *= vec3(getTexture(material.sheenColorTexture, state.tc)); // sRGB + } + + pbrMat.sheenRoughness = material.sheenRoughnessFactor; + if(isTexturePresent(material.sheenRoughnessTexture)) + { + pbrMat.sheenRoughness *= getTexture(material.sheenRoughnessTexture, state.tc).w; + } + pbrMat.sheenRoughness = max(MICROFACET_MIN_ROUGHNESS, pbrMat.sheenRoughness); + + // KHR_materials_dispersion + pbrMat.dispersion = material.dispersion; + + // KHR_materials_diffuse_transmission + pbrMat.diffuseTransmissionFactor = material.diffuseTransmissionFactor; + if(isTexturePresent(material.diffuseTransmissionTexture)) + { + pbrMat.diffuseTransmissionFactor *= getTexture(material.diffuseTransmissionTexture, state.tc).a; + } + pbrMat.diffuseTransmissionColor = material.diffuseTransmissionColor; + if(isTexturePresent(material.diffuseTransmissionColorTexture)) + { + pbrMat.diffuseTransmissionColor = getTexture(material.diffuseTransmissionColorTexture, state.tc).rgb; + } + + return pbrMat; +} + +// Compatibility function +PbrMaterial evaluateMaterial(in GltfShadeMaterial material, in vec3 normal, in vec3 tangent, in vec3 bitangent, in vec2 texCoord) +{ + vec2 tcoords[2] = {texCoord, vec2(0.0F)}; + MeshState mesh = MeshState(normal, tangent, bitangent, normal, tcoords, false); + return evaluateMaterial(material, mesh); +} + +#endif // MAT_EVAL_H diff --git a/nvpro_core_legacy/nvvkhl/shaders/pbr_mat_struct.h b/nvpro_core_legacy/nvvkhl/shaders/pbr_mat_struct.h new file mode 100644 index 0000000..41df2f9 --- /dev/null +++ b/nvpro_core_legacy/nvvkhl/shaders/pbr_mat_struct.h @@ -0,0 +1,125 @@ +/* + * Copyright (c) 2022-2025, NVIDIA CORPORATION. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-FileCopyrightText: Copyright (c) 2022-2025, NVIDIA CORPORATION. + * SPDX-License-Identifier: Apache-2.0 + */ + +/// @DOC_SKIP + +#ifndef NVVKHL_PBR_MAT_STRUCT_H +#define NVVKHL_PBR_MAT_STRUCT_H 1 + +#include "func.h" + +struct PbrMaterial +{ + vec3 baseColor; // base color + float opacity; // 1 = opaque, 0 = fully transparent + vec2 roughness; // 0 = smooth, 1 = rough (anisotropic: x = U, y = V) + float metallic; // 0 = dielectric, 1 = metallic + vec3 emissive; // emissive color + float occlusion; // occlusion factor + + vec3 N; // shading normal + vec3 T; // shading normal + vec3 B; // shading normal + vec3 Ng; // geometric normal + + + float ior1; // index of refraction : current medium (i.e. air) + float ior2; // index of refraction : the other side (i.e. glass) + float dispersion; // KHR_materials_specular + + float specular; // weight of the dielectric specular layer + vec3 specularColor; // color of the dielectric specular layer + float transmission; // KHR_materials_transmission + + vec3 attenuationColor; // KHR_materials_volume + float attenuationDistance; // + bool isThinWalled; // Replace for isThinWalled? + + float clearcoat; // KHR_materials_clearcoat + float clearcoatRoughness; // + vec3 Nc; // clearcoat normal + + float iridescence; + float iridescenceIor; + float iridescenceThickness; + + vec3 sheenColor; + float sheenRoughness; + + float diffuseTransmissionFactor; + vec3 diffuseTransmissionColor; +}; + +PbrMaterial defaultPbrMaterial() +{ + PbrMaterial mat; + mat.baseColor = vec3(1.0F); + mat.opacity = 1.0F; + mat.roughness = vec2(1.0F); + mat.metallic = 1.0F; + mat.emissive = vec3(0.0F); + + mat.N = vec3(0.0F, 0.0F, 1.0F); + mat.Ng = vec3(0.0F, 0.0F, 1.0F); + mat.T = vec3(1.0F, 0.0F, 0.0F); + mat.B = vec3(0.0F, 1.0F, 0.0F); + + mat.ior1 = 1.0F; + mat.ior2 = 1.5F; + mat.dispersion = 0.0F; + + mat.specular = 1.0F; + mat.specularColor = vec3(1.0F); + mat.transmission = 0.0F; + + mat.attenuationColor = vec3(1.0F); + mat.attenuationDistance = 1.0F; + mat.isThinWalled = true; + + mat.clearcoat = 0.0F; + mat.clearcoatRoughness = 0.01F; + mat.Nc = vec3(0.0F, 0.0F, 1.0F); + + mat.iridescence = 0.0F; + mat.iridescenceIor = 1.5F; + mat.iridescenceThickness = 0.1F; + + mat.sheenColor = vec3(0.0F); + mat.sheenRoughness = 0.0F; + mat.occlusion = 1.0F; + + mat.diffuseTransmissionFactor = 0.0F; + mat.diffuseTransmissionColor = vec3(1.0F); + + return mat; +} + +PbrMaterial defaultPbrMaterial(vec3 baseColor, float metallic, float roughness, vec3 N, vec3 Ng) +{ + PbrMaterial mat = defaultPbrMaterial(); + mat.baseColor = baseColor; + mat.metallic = metallic; + mat.roughness = vec2(roughness * roughness); + mat.Ng = Ng; + mat.N = N; + orthonormalBasis(mat.N, mat.T, mat.B); + + return mat; +} +#endif // NVVKHL_PBR_MAT_STRUCT_H diff --git a/nvpro_core_legacy/nvvkhl/shaders/random.h b/nvpro_core_legacy/nvvkhl/shaders/random.h new file mode 100644 index 0000000..032a20f --- /dev/null +++ b/nvpro_core_legacy/nvvkhl/shaders/random.h @@ -0,0 +1,99 @@ +/* + * Copyright (c) 2022-2024, NVIDIA CORPORATION. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-FileCopyrightText: Copyright (c) 2022-2024, NVIDIA CORPORATION. + * SPDX-License-Identifier: Apache-2.0 + */ + +#ifndef RANDOM_GLSL +#define RANDOM_GLSL 1 + +/* @DOC_START +Random number generation functions. + +For even more hash functions, check out +[Jarzynski and Olano, "Hash Functions for GPU Rendering"](https://jcgt.org/published/0009/03/02/) +@DOC_END */ + +precision highp float; + +/* @DOC_START +# Function `xxhash32` +> High-quality hash that takes 96 bits of data and outputs 32, roughly twice +> as slow as `pcg`. + +You can use this to generate a seed for subsequent random number generators; +for instance, provide `uvec3(pixel.x, pixel.y, frame_number). + +From https://github.com/Cyan4973/xxHash and https://www.shadertoy.com/view/XlGcRh. +@DOC_END */ +uint xxhash32(uvec3 p) +{ + const uvec4 primes = uvec4(2246822519U, 3266489917U, 668265263U, 374761393U); + uint h32; + h32 = p.z + primes.w + p.x * primes.y; + h32 = primes.z * ((h32 << 17) | (h32 >> (32 - 17))); + h32 += p.y * primes.y; + h32 = primes.z * ((h32 << 17) | (h32 >> (32 - 17))); + h32 = primes.x * (h32 ^ (h32 >> 15)); + h32 = primes.y * (h32 ^ (h32 >> 13)); + return h32 ^ (h32 >> 16); +} + +/* @DOC_START +# Function `pcg` +> Fast, reasonably good hash that updates 32 bits of state and outputs 32 bits. + +This is a version of `pcg32i_random_t` from the +[PCG random number generator library](https://www.pcg-random.org/index.html), +which updates its internal state using a linear congruential generator and +outputs a hash using `pcg_output_rxs_m_xs_32_32`, a more complex hash. + +There's a section of vk_mini_path_tracer on this random number generator +[here](https://nvpro-samples.github.io/vk_mini_path_tracer/#antialiasingandpseudorandomnumbergeneration/pseudorandomnumbergenerationinglsl). +@DOC_END */ +uint pcg(inout uint state) +{ + uint prev = state * 747796405u + 2891336453u; + uint word = ((prev >> ((prev >> 28u) + 4u)) ^ prev) * 277803737u; + state = prev; + return (word >> 22u) ^ word; +} + +/* @DOC_START +# Function `rand` +> Generates a random float in [0, 1], updating an RNG state. + +This can be used to generate many random numbers! Here's an example: + +```glsl +uint seed = xxhash32(vec3(pixel.xy, frame_number)); +for(int bounce = 0; bounce < 50; bounce++) +{ + ... + BsdfSampleData sampleData; + sampleData.xi = vec3(rand(seed), rand(seed), rand(seed)); + ... +} +``` +@DOC_END */ +float rand(inout uint seed) +{ + uint r = pcg(seed); + return float(r) * (1.F / float(0xffffffffu)); +} + + +#endif // RANDOM_GLSL diff --git a/nvpro_core_legacy/nvvkhl/shaders/tonemapper.comp.glsl b/nvpro_core_legacy/nvvkhl/shaders/tonemapper.comp.glsl new file mode 100644 index 0000000..bcebb1f --- /dev/null +++ b/nvpro_core_legacy/nvvkhl/shaders/tonemapper.comp.glsl @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2022-2024, NVIDIA CORPORATION. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-FileCopyrightText: Copyright (c) 2022-2024, NVIDIA CORPORATION. + * SPDX-License-Identifier: Apache-2.0 + */ + + +#version 450 + +#extension GL_GOOGLE_include_directive : enable + +#include "dh_tonemap.h" +#include "dh_comp.h" + + +layout(set = 0, binding = eTonemapperInput) uniform sampler2D g_image; +layout(set = 0, binding = eTonemapperOutput) writeonly uniform image2D g_out_image; + +layout(push_constant) uniform shaderInformation +{ + Tonemapper tm; +}; + +layout(local_size_x = WORKGROUP_SIZE, local_size_y = WORKGROUP_SIZE, local_size_z = 1) in; + + +void main() +{ + if(gl_GlobalInvocationID.xy != clamp(gl_GlobalInvocationID.xy, vec2(0.0F), imageSize(g_out_image))) + return; + + const vec2 pixel_center = vec2(gl_GlobalInvocationID.xy) + vec2(0.5F); + const vec2 i_uv = pixel_center / vec2(imageSize(g_out_image)); + + vec4 R = texture(g_image, i_uv); + + if(tm.isActive == 1) + { + R.xyz = applyTonemap(tm, R.xyz, i_uv); + } + + imageStore(g_out_image, ivec2(gl_GlobalInvocationID.xy), R); +} diff --git a/nvpro_core_legacy/nvvkhl/shaders/tonemapper.frag.glsl b/nvpro_core_legacy/nvvkhl/shaders/tonemapper.frag.glsl new file mode 100644 index 0000000..f05ed57 --- /dev/null +++ b/nvpro_core_legacy/nvvkhl/shaders/tonemapper.frag.glsl @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2022-2024, NVIDIA CORPORATION. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-FileCopyrightText: Copyright (c) 2022-2024, NVIDIA CORPORATION. + * SPDX-License-Identifier: Apache-2.0 + */ + + +#version 450 + +#extension GL_GOOGLE_include_directive : enable + +#include "dh_tonemap.h" + +layout(location = 0) in vec2 i_uv; +layout(location = 0) out vec4 o_color; + +layout(set = 0, binding = eTonemapperInput) uniform sampler2D g_image; + + +layout(push_constant) uniform shaderInformation +{ + Tonemapper tm; +}; + + +void main() +{ + vec4 R = texture(g_image, i_uv); + + if(tm.isActive == 1) + R.xyz = applyTonemap(tm, R.xyz, i_uv); + + o_color = R; +} diff --git a/nvpro_core_legacy/nvvkhl/tonemap_postprocess.cpp b/nvpro_core_legacy/nvvkhl/tonemap_postprocess.cpp new file mode 100644 index 0000000..069481e --- /dev/null +++ b/nvpro_core_legacy/nvvkhl/tonemap_postprocess.cpp @@ -0,0 +1,337 @@ +/* + * Copyright (c) 2022-2024, NVIDIA CORPORATION. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-FileCopyrightText: Copyright (c) 2022-2024, NVIDIA CORPORATION. + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include +#include +#include + +namespace nvvkhl { + +TonemapperPostProcess::~TonemapperPostProcess() +{ + if(m_device) + { + if(m_graphicsPipeline != VK_NULL_HANDLE) + { + m_device->vkDestroyPipeline(*m_device, m_graphicsPipeline, nullptr); + } + if(m_computePipeline != VK_NULL_HANDLE) + { + m_device->vkDestroyPipeline(*m_device, m_computePipeline, nullptr); + } + } +} + +static VkExtent2D getGroupCounts(const VkExtent2D& size) +{ + constexpr uint32_t groupSize = 8; + return {(size.width + groupSize - 1) / groupSize, (size.height + groupSize - 1) / groupSize}; +} + +void TonemapperPostProcess::createGraphicPipeline(const vko::Device& device, + VkFormat colorFormat, + VkFormat depthFormat, + std::span vertexShader, + std::span fragmentShader) +{ + m_mode = TmMode::eGraphic; + m_device = &device; + + // Create descriptor set layout for push descriptors + m_graphicsBindings = vko::makeBindings({ + {{nvvkhl_shaders::eTonemapperInput, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_FRAGMENT_BIT, nullptr}, 0}, + }); + m_graphicsLayout = vko::makeDescriptorSetLayout(device, m_graphicsBindings, VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR); + + // Create pipeline layout with push constants + VkPushConstantRange pushConstantRange{VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(nvvkhl_shaders::Tonemapper)}; + VkDescriptorSetLayout layoutHandle = static_cast(*m_graphicsLayout); + VkPipelineLayoutCreateInfo pipelineLayoutInfo{ + .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .setLayoutCount = 1, + .pSetLayouts = &layoutHandle, + .pushConstantRangeCount = 1, + .pPushConstantRanges = &pushConstantRange, + }; + m_graphicsPipelineLayout.emplace(device, pipelineLayoutInfo); + + // Create shader modules + vko::ShaderModule vertexModule(device, VkShaderModuleCreateInfo{ + .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .codeSize = vertexShader.size_bytes(), + .pCode = vertexShader.data(), + }); + vko::ShaderModule fragmentModule(device, VkShaderModuleCreateInfo{ + .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .codeSize = fragmentShader.size_bytes(), + .pCode = fragmentShader.data(), + }); + + // Create graphics pipeline + VkPipelineShaderStageCreateInfo stages[] = { + {.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, .pNext = nullptr, .flags = 0, .stage = VK_SHADER_STAGE_VERTEX_BIT, .module = vertexModule, .pName = "main", .pSpecializationInfo = nullptr}, + {.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, .pNext = nullptr, .flags = 0, .stage = VK_SHADER_STAGE_FRAGMENT_BIT, .module = fragmentModule, .pName = "main", .pSpecializationInfo = nullptr}, + }; + + VkPipelineRenderingCreateInfo renderingInfo{ + .sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO, + .pNext = nullptr, + .viewMask = 0, + .colorAttachmentCount = 1, + .pColorAttachmentFormats = &colorFormat, + .depthAttachmentFormat = depthFormat, + .stencilAttachmentFormat = VK_FORMAT_UNDEFINED, + }; + + VkPipelineVertexInputStateCreateInfo vertexInput{ + .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .vertexBindingDescriptionCount = 0, + .pVertexBindingDescriptions = nullptr, + .vertexAttributeDescriptionCount = 0, + .pVertexAttributeDescriptions = nullptr, + }; + + VkPipelineInputAssemblyStateCreateInfo inputAssembly{ + .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, + .primitiveRestartEnable = VK_FALSE, + }; + + VkPipelineRasterizationStateCreateInfo rasterization{ + .sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .depthClampEnable = VK_FALSE, + .rasterizerDiscardEnable = VK_FALSE, + .polygonMode = VK_POLYGON_MODE_FILL, + .cullMode = VK_CULL_MODE_NONE, + .frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE, + .depthBiasEnable = VK_FALSE, + .depthBiasConstantFactor = 0.0f, + .depthBiasClamp = 0.0f, + .depthBiasSlopeFactor = 0.0f, + .lineWidth = 1.0f, + }; + + VkPipelineColorBlendAttachmentState colorBlendAttachment{ + .blendEnable = VK_FALSE, + .srcColorBlendFactor = VK_BLEND_FACTOR_ONE, + .dstColorBlendFactor = VK_BLEND_FACTOR_ZERO, + .colorBlendOp = VK_BLEND_OP_ADD, + .srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE, + .dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO, + .alphaBlendOp = VK_BLEND_OP_ADD, + .colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT, + }; + + VkPipelineColorBlendStateCreateInfo colorBlend{ + .sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .logicOpEnable = VK_FALSE, + .logicOp = VK_LOGIC_OP_COPY, + .attachmentCount = 1, + .pAttachments = &colorBlendAttachment, + .blendConstants = {0.0f, 0.0f, 0.0f, 0.0f}, + }; + + VkGraphicsPipelineCreateInfo pipelineInfo{ + .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, + .pNext = &renderingInfo, + .flags = 0, + .stageCount = 2, + .pStages = stages, + .pVertexInputState = &vertexInput, + .pInputAssemblyState = &inputAssembly, + .pTessellationState = nullptr, + .pViewportState = nullptr, + .pRasterizationState = &rasterization, + .pMultisampleState = nullptr, + .pDepthStencilState = nullptr, + .pColorBlendState = &colorBlend, + .pDynamicState = nullptr, + .layout = *m_graphicsPipelineLayout, + .renderPass = VK_NULL_HANDLE, + .subpass = 0, + .basePipelineHandle = VK_NULL_HANDLE, + .basePipelineIndex = -1, + }; + + if(device.vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &m_graphicsPipeline) != VK_SUCCESS) + { + m_graphicsPipeline = VK_NULL_HANDLE; + } +} + +void TonemapperPostProcess::createComputePipeline(const vko::Device& device, + std::span computeShader) +{ + m_mode = TmMode::eCompute; + m_device = &device; + + // Create descriptor set layout for push descriptors + m_computeBindings = vko::makeBindings({ + {{nvvkhl_shaders::eTonemapperInput, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr}, 0}, + {{nvvkhl_shaders::eTonemapperOutput, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr}, 0}, + }); + m_computeLayout = vko::makeDescriptorSetLayout(device, m_computeBindings, VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR); + + // Create pipeline layout with push constants + VkPushConstantRange pushConstantRange{VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(nvvkhl_shaders::Tonemapper)}; + VkDescriptorSetLayout layoutHandle = static_cast(*m_computeLayout); + VkPipelineLayoutCreateInfo pipelineLayoutInfo{ + .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .setLayoutCount = 1, + .pSetLayouts = &layoutHandle, + .pushConstantRangeCount = 1, + .pPushConstantRanges = &pushConstantRange, + }; + m_computePipelineLayout.emplace(device, pipelineLayoutInfo); + + // Create shader module + vko::ShaderModule computeModule(device, VkShaderModuleCreateInfo{ + .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .codeSize = computeShader.size_bytes(), + .pCode = computeShader.data(), + }); + + // Create compute pipeline + VkPipelineShaderStageCreateInfo stage{ + .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .stage = VK_SHADER_STAGE_COMPUTE_BIT, + .module = computeModule, + .pName = "main", + .pSpecializationInfo = nullptr, + }; + VkComputePipelineCreateInfo pipelineInfo{ + .sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .stage = stage, + .layout = *m_computePipelineLayout, + .basePipelineHandle = VK_NULL_HANDLE, + .basePipelineIndex = -1, + }; + + if(device.vkCreateComputePipelines(device, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &m_computePipeline) != VK_SUCCESS) + { + m_computePipeline = VK_NULL_HANDLE; + } +} + +void TonemapperPostProcess::updateGraphicDescriptorSets(VkDescriptorImageInfo inImage) +{ + assert(m_mode == TmMode::eGraphic && m_graphicsLayout); + m_iimage = inImage; + vko::WriteDescriptorSetBuilder builder; + builder.push_back( + VK_NULL_HANDLE, // Push descriptor - not used + m_graphicsBindings.bindings[0], + 0, + m_iimage); + m_writes.assign(builder.writes().begin(), builder.writes().end()); +} + +void TonemapperPostProcess::updateComputeDescriptorSets(VkDescriptorImageInfo inImage, VkDescriptorImageInfo outImage) +{ + assert(m_mode == TmMode::eCompute && m_computeLayout); + m_iimage = inImage; + m_oimage = outImage; + vko::WriteDescriptorSetBuilder builder; + builder.push_back( + VK_NULL_HANDLE, // Push descriptor - not used + m_computeBindings.bindings[0], + 0, + m_iimage); + builder.push_back( + VK_NULL_HANDLE, // Push descriptor - not used + m_computeBindings.bindings[1], + 0, + m_oimage); + m_writes.assign(builder.writes().begin(), builder.writes().end()); + + // Fix up pointers to point to our member variables instead of builder's temporary storage + m_writes[0].pImageInfo = &m_iimage; + m_writes[1].pImageInfo = &m_oimage; +} + +void TonemapperPostProcess::runGraphic(VkCommandBuffer cmd) +{ + assert(m_mode == TmMode::eGraphic && m_graphicsPipeline != VK_NULL_HANDLE && m_graphicsPipelineLayout); + // Note: These are global Vulkan functions, not device methods + m_device->vkCmdPushConstants(cmd, static_cast(*m_graphicsPipelineLayout), VK_SHADER_STAGE_FRAGMENT_BIT, 0, + sizeof(nvvkhl_shaders::Tonemapper), &m_settings); + m_device->vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, m_graphicsPipeline); + m_device->vkCmdPushDescriptorSetKHR(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, static_cast(*m_graphicsPipelineLayout), 0, + static_cast(m_writes.size()), m_writes.data()); + m_device->vkCmdDraw(cmd, 3, 1, 0, 0); +} + +void TonemapperPostProcess::runCompute(VkCommandBuffer cmd, const VkExtent2D& size) +{ + assert(m_mode == TmMode::eCompute && m_computePipeline != VK_NULL_HANDLE && m_computePipelineLayout); + m_device->vkCmdPushConstants(cmd, static_cast(*m_computePipelineLayout), VK_SHADER_STAGE_COMPUTE_BIT, 0, + sizeof(nvvkhl_shaders::Tonemapper), &m_settings); + m_device->vkCmdPushDescriptorSetKHR(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, static_cast(*m_computePipelineLayout), 0, + static_cast(m_writes.size()), m_writes.data()); + m_device->vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, m_computePipeline); + VkExtent2D group_counts = getGroupCounts(size); + m_device->vkCmdDispatch(cmd, group_counts.width, group_counts.height, 1); +} + +bool TonemapperPostProcess::onUI() +{ + bool changed{false}; + + const char* items[] = {"Filmic", "Uncharted 2", "Clip", "ACES", "AgX", "Khronos PBR"}; + + changed |= ImGui::Combo("Method", &m_settings.method, items, IM_ARRAYSIZE(items)); + changed |= ImGui::Checkbox("Active", reinterpret_cast(&m_settings.isActive)); + changed |= ImGui::SliderFloat("Exposure", &m_settings.exposure, 0.1F, 15.0F, "%.3f", ImGuiSliderFlags_Logarithmic); + changed |= ImGui::SliderFloat("Brightness", &m_settings.brightness, 0.0F, 2.0F); + changed |= ImGui::SliderFloat("Contrast", &m_settings.contrast, 0.0F, 2.0F); + changed |= ImGui::SliderFloat("Saturation", &m_settings.saturation, 0.0F, 2.0F); + changed |= ImGui::SliderFloat("Vignette", &m_settings.vignette, 0.0F, 1.0F); + + if(ImGui::SmallButton("reset")) + { + m_settings = nvvkhl_shaders::defaultTonemapper(); + changed = true; + } + return changed; +} + +} // namespace nvvkhl diff --git a/nvpro_core_legacy/nvvkhl/tonemap_postprocess.hpp b/nvpro_core_legacy/nvvkhl/tonemap_postprocess.hpp new file mode 100644 index 0000000..0b1f38b --- /dev/null +++ b/nvpro_core_legacy/nvvkhl/tonemap_postprocess.hpp @@ -0,0 +1,99 @@ +/* + * Copyright (c) 2022-2025, NVIDIA CORPORATION. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-FileCopyrightText: Copyright (c) 2022-2025, NVIDIA CORPORATION. + * SPDX-License-Identifier: Apache-2.0 + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include + +namespace nvvkhl { + +// Tonemapper using vulkan_objects with RAII design +struct TonemapperPostProcess +{ + TonemapperPostProcess() = default; + ~TonemapperPostProcess(); + + TonemapperPostProcess(const TonemapperPostProcess&) = delete; + TonemapperPostProcess& operator=(const TonemapperPostProcess&) = delete; + TonemapperPostProcess(TonemapperPostProcess&&) = default; + TonemapperPostProcess& operator=(TonemapperPostProcess&&) = default; + + // Create graphics pipeline for tonemapping + void createGraphicPipeline(const vko::Device& device, + VkFormat colorFormat, + VkFormat depthFormat, + std::span vertexShader, + std::span fragmentShader); + + // Create compute pipeline for tonemapping + void createComputePipeline(const vko::Device& device, std::span computeShader); + + // Update descriptor sets for graphics (push descriptors) + void updateGraphicDescriptorSets(VkDescriptorImageInfo inImage); + + // Update descriptor sets for compute (push descriptors) + void updateComputeDescriptorSets(VkDescriptorImageInfo inImage, VkDescriptorImageInfo outImage); + + // Execute graphics tonemapping + void runGraphic(VkCommandBuffer cmd); + + // Execute compute tonemapping + void runCompute(VkCommandBuffer cmd, const VkExtent2D& size); + + // Display UI for tonemapper settings + bool onUI(); + + void setSettings(const nvvkhl_shaders::Tonemapper& settings) { m_settings = settings; } + nvvkhl_shaders::Tonemapper& settings() { return m_settings; } + +private: + // Graphics pipeline resources + vko::BindingsAndFlags m_graphicsBindings; + std::optional m_graphicsLayout; + std::optional m_graphicsPipelineLayout; + VkPipeline m_graphicsPipeline{VK_NULL_HANDLE}; + const vko::Device* m_device{nullptr}; + + // Compute pipeline resources + vko::BindingsAndFlags m_computeBindings; + std::optional m_computeLayout; + std::optional m_computePipelineLayout; + VkPipeline m_computePipeline{VK_NULL_HANDLE}; + + nvvkhl_shaders::Tonemapper m_settings{nvvkhl_shaders::defaultTonemapper()}; + + // Push descriptor writes (built on update, used in run) + VkDescriptorImageInfo m_iimage{}; + VkDescriptorImageInfo m_oimage{}; + std::vector m_writes; + + enum class TmMode + { + eNone, + eGraphic, + eCompute + } m_mode{TmMode::eNone}; +}; + +} // namespace nvvkhl diff --git a/nvpro_core_legacy/third_party/dxh/include/directx/dxgiformat.h b/nvpro_core_legacy/third_party/dxh/include/directx/dxgiformat.h new file mode 100644 index 0000000..83e6c07 --- /dev/null +++ b/nvpro_core_legacy/third_party/dxh/include/directx/dxgiformat.h @@ -0,0 +1,144 @@ +// +// Copyright (C) Microsoft Corporation. +// Licensed under the MIT license +// + +#ifndef __dxgiformat_h__ +#define __dxgiformat_h__ + +#define DXGI_FORMAT_DEFINED 1 + +typedef enum DXGI_FORMAT +{ + DXGI_FORMAT_UNKNOWN = 0, + DXGI_FORMAT_R32G32B32A32_TYPELESS = 1, + DXGI_FORMAT_R32G32B32A32_FLOAT = 2, + DXGI_FORMAT_R32G32B32A32_UINT = 3, + DXGI_FORMAT_R32G32B32A32_SINT = 4, + DXGI_FORMAT_R32G32B32_TYPELESS = 5, + DXGI_FORMAT_R32G32B32_FLOAT = 6, + DXGI_FORMAT_R32G32B32_UINT = 7, + DXGI_FORMAT_R32G32B32_SINT = 8, + DXGI_FORMAT_R16G16B16A16_TYPELESS = 9, + DXGI_FORMAT_R16G16B16A16_FLOAT = 10, + DXGI_FORMAT_R16G16B16A16_UNORM = 11, + DXGI_FORMAT_R16G16B16A16_UINT = 12, + DXGI_FORMAT_R16G16B16A16_SNORM = 13, + DXGI_FORMAT_R16G16B16A16_SINT = 14, + DXGI_FORMAT_R32G32_TYPELESS = 15, + DXGI_FORMAT_R32G32_FLOAT = 16, + DXGI_FORMAT_R32G32_UINT = 17, + DXGI_FORMAT_R32G32_SINT = 18, + DXGI_FORMAT_R32G8X24_TYPELESS = 19, + DXGI_FORMAT_D32_FLOAT_S8X24_UINT = 20, + DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS = 21, + DXGI_FORMAT_X32_TYPELESS_G8X24_UINT = 22, + DXGI_FORMAT_R10G10B10A2_TYPELESS = 23, + DXGI_FORMAT_R10G10B10A2_UNORM = 24, + DXGI_FORMAT_R10G10B10A2_UINT = 25, + DXGI_FORMAT_R11G11B10_FLOAT = 26, + DXGI_FORMAT_R8G8B8A8_TYPELESS = 27, + DXGI_FORMAT_R8G8B8A8_UNORM = 28, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB = 29, + DXGI_FORMAT_R8G8B8A8_UINT = 30, + DXGI_FORMAT_R8G8B8A8_SNORM = 31, + DXGI_FORMAT_R8G8B8A8_SINT = 32, + DXGI_FORMAT_R16G16_TYPELESS = 33, + DXGI_FORMAT_R16G16_FLOAT = 34, + DXGI_FORMAT_R16G16_UNORM = 35, + DXGI_FORMAT_R16G16_UINT = 36, + DXGI_FORMAT_R16G16_SNORM = 37, + DXGI_FORMAT_R16G16_SINT = 38, + DXGI_FORMAT_R32_TYPELESS = 39, + DXGI_FORMAT_D32_FLOAT = 40, + DXGI_FORMAT_R32_FLOAT = 41, + DXGI_FORMAT_R32_UINT = 42, + DXGI_FORMAT_R32_SINT = 43, + DXGI_FORMAT_R24G8_TYPELESS = 44, + DXGI_FORMAT_D24_UNORM_S8_UINT = 45, + DXGI_FORMAT_R24_UNORM_X8_TYPELESS = 46, + DXGI_FORMAT_X24_TYPELESS_G8_UINT = 47, + DXGI_FORMAT_R8G8_TYPELESS = 48, + DXGI_FORMAT_R8G8_UNORM = 49, + DXGI_FORMAT_R8G8_UINT = 50, + DXGI_FORMAT_R8G8_SNORM = 51, + DXGI_FORMAT_R8G8_SINT = 52, + DXGI_FORMAT_R16_TYPELESS = 53, + DXGI_FORMAT_R16_FLOAT = 54, + DXGI_FORMAT_D16_UNORM = 55, + DXGI_FORMAT_R16_UNORM = 56, + DXGI_FORMAT_R16_UINT = 57, + DXGI_FORMAT_R16_SNORM = 58, + DXGI_FORMAT_R16_SINT = 59, + DXGI_FORMAT_R8_TYPELESS = 60, + DXGI_FORMAT_R8_UNORM = 61, + DXGI_FORMAT_R8_UINT = 62, + DXGI_FORMAT_R8_SNORM = 63, + DXGI_FORMAT_R8_SINT = 64, + DXGI_FORMAT_A8_UNORM = 65, + DXGI_FORMAT_R1_UNORM = 66, + DXGI_FORMAT_R9G9B9E5_SHAREDEXP = 67, + DXGI_FORMAT_R8G8_B8G8_UNORM = 68, + DXGI_FORMAT_G8R8_G8B8_UNORM = 69, + DXGI_FORMAT_BC1_TYPELESS = 70, + DXGI_FORMAT_BC1_UNORM = 71, + DXGI_FORMAT_BC1_UNORM_SRGB = 72, + DXGI_FORMAT_BC2_TYPELESS = 73, + DXGI_FORMAT_BC2_UNORM = 74, + DXGI_FORMAT_BC2_UNORM_SRGB = 75, + DXGI_FORMAT_BC3_TYPELESS = 76, + DXGI_FORMAT_BC3_UNORM = 77, + DXGI_FORMAT_BC3_UNORM_SRGB = 78, + DXGI_FORMAT_BC4_TYPELESS = 79, + DXGI_FORMAT_BC4_UNORM = 80, + DXGI_FORMAT_BC4_SNORM = 81, + DXGI_FORMAT_BC5_TYPELESS = 82, + DXGI_FORMAT_BC5_UNORM = 83, + DXGI_FORMAT_BC5_SNORM = 84, + DXGI_FORMAT_B5G6R5_UNORM = 85, + DXGI_FORMAT_B5G5R5A1_UNORM = 86, + DXGI_FORMAT_B8G8R8A8_UNORM = 87, + DXGI_FORMAT_B8G8R8X8_UNORM = 88, + DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM = 89, + DXGI_FORMAT_B8G8R8A8_TYPELESS = 90, + DXGI_FORMAT_B8G8R8A8_UNORM_SRGB = 91, + DXGI_FORMAT_B8G8R8X8_TYPELESS = 92, + DXGI_FORMAT_B8G8R8X8_UNORM_SRGB = 93, + DXGI_FORMAT_BC6H_TYPELESS = 94, + DXGI_FORMAT_BC6H_UF16 = 95, + DXGI_FORMAT_BC6H_SF16 = 96, + DXGI_FORMAT_BC7_TYPELESS = 97, + DXGI_FORMAT_BC7_UNORM = 98, + DXGI_FORMAT_BC7_UNORM_SRGB = 99, + DXGI_FORMAT_AYUV = 100, + DXGI_FORMAT_Y410 = 101, + DXGI_FORMAT_Y416 = 102, + DXGI_FORMAT_NV12 = 103, + DXGI_FORMAT_P010 = 104, + DXGI_FORMAT_P016 = 105, + DXGI_FORMAT_420_OPAQUE = 106, + DXGI_FORMAT_YUY2 = 107, + DXGI_FORMAT_Y210 = 108, + DXGI_FORMAT_Y216 = 109, + DXGI_FORMAT_NV11 = 110, + DXGI_FORMAT_AI44 = 111, + DXGI_FORMAT_IA44 = 112, + DXGI_FORMAT_P8 = 113, + DXGI_FORMAT_A8P8 = 114, + DXGI_FORMAT_B4G4R4A4_UNORM = 115, + + DXGI_FORMAT_P208 = 130, + DXGI_FORMAT_V208 = 131, + DXGI_FORMAT_V408 = 132, + + + DXGI_FORMAT_SAMPLER_FEEDBACK_MIN_MIP_OPAQUE = 189, + DXGI_FORMAT_SAMPLER_FEEDBACK_MIP_REGION_USED_OPAQUE = 190, + + DXGI_FORMAT_A4B4G4R4_UNORM = 191, + + + DXGI_FORMAT_FORCE_UINT = 0xffffffff +} DXGI_FORMAT; + +#endif // __dxgiformat_h__ diff --git a/nvpro_core_legacy/third_party/tinygltf/json.hpp b/nvpro_core_legacy/third_party/tinygltf/json.hpp new file mode 100644 index 0000000..82d69f7 --- /dev/null +++ b/nvpro_core_legacy/third_party/tinygltf/json.hpp @@ -0,0 +1,25526 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + +/****************************************************************************\ + * Note on documentation: The source files contain links to the online * + * documentation of the public API at https://json.nlohmann.me. This URL * + * contains the most recent documentation and should also be applicable to * + * previous versions; documentation for deprecated functions is not * + * removed, but marked deprecated. See "Generate documentation" section in * + * file docs/README.md. * +\****************************************************************************/ + +#ifndef INCLUDE_NLOHMANN_JSON_HPP_ +#define INCLUDE_NLOHMANN_JSON_HPP_ + +#include // all_of, find, for_each +#include // nullptr_t, ptrdiff_t, size_t +#include // hash, less +#include // initializer_list +#ifndef JSON_NO_IO + #include // istream, ostream +#endif // JSON_NO_IO +#include // random_access_iterator_tag +#include // unique_ptr +#include // string, stoi, to_string +#include // declval, forward, move, pair, swap +#include // vector + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// This file contains all macro definitions affecting or depending on the ABI + +#ifndef JSON_SKIP_LIBRARY_VERSION_CHECK + #if defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR) && defined(NLOHMANN_JSON_VERSION_PATCH) + #if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 12 || NLOHMANN_JSON_VERSION_PATCH != 0 + #warning "Already included a different version of the library!" + #endif + #endif +#endif + +#define NLOHMANN_JSON_VERSION_MAJOR 3 // NOLINT(modernize-macro-to-enum) +#define NLOHMANN_JSON_VERSION_MINOR 12 // NOLINT(modernize-macro-to-enum) +#define NLOHMANN_JSON_VERSION_PATCH 0 // NOLINT(modernize-macro-to-enum) + +#ifndef JSON_DIAGNOSTICS + #define JSON_DIAGNOSTICS 0 +#endif + +#ifndef JSON_DIAGNOSTIC_POSITIONS + #define JSON_DIAGNOSTIC_POSITIONS 0 +#endif + +#ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON + #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0 +#endif + +#if JSON_DIAGNOSTICS + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag +#else + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS +#endif + +#if JSON_DIAGNOSTIC_POSITIONS + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS _dp +#else + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS +#endif + +#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON + #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp +#else + #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON +#endif + +#ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION + #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0 +#endif + +// Construct the namespace ABI tags component +#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c) json_abi ## a ## b ## c +#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c) \ + NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c) + +#define NLOHMANN_JSON_ABI_TAGS \ + NLOHMANN_JSON_ABI_TAGS_CONCAT( \ + NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS, \ + NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON, \ + NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS) + +// Construct the namespace version component +#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \ + _v ## major ## _ ## minor ## _ ## patch +#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \ + NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) + +#if NLOHMANN_JSON_NAMESPACE_NO_VERSION +#define NLOHMANN_JSON_NAMESPACE_VERSION +#else +#define NLOHMANN_JSON_NAMESPACE_VERSION \ + NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \ + NLOHMANN_JSON_VERSION_MINOR, \ + NLOHMANN_JSON_VERSION_PATCH) +#endif + +// Combine namespace components +#define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b +#define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \ + NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) + +#ifndef NLOHMANN_JSON_NAMESPACE +#define NLOHMANN_JSON_NAMESPACE \ + nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \ + NLOHMANN_JSON_ABI_TAGS, \ + NLOHMANN_JSON_NAMESPACE_VERSION) +#endif + +#ifndef NLOHMANN_JSON_NAMESPACE_BEGIN +#define NLOHMANN_JSON_NAMESPACE_BEGIN \ + namespace nlohmann \ + { \ + inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \ + NLOHMANN_JSON_ABI_TAGS, \ + NLOHMANN_JSON_NAMESPACE_VERSION) \ + { +#endif + +#ifndef NLOHMANN_JSON_NAMESPACE_END +#define NLOHMANN_JSON_NAMESPACE_END \ + } /* namespace (inline namespace) NOLINT(readability/namespace) */ \ + } // namespace nlohmann +#endif + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // transform +#include // array +#include // forward_list +#include // inserter, front_inserter, end +#include // map +#ifdef JSON_HAS_CPP_17 + #include // optional +#endif +#include // string +#include // tuple, make_tuple +#include // is_arithmetic, is_same, is_enum, underlying_type, is_convertible +#include // unordered_map +#include // pair, declval +#include // valarray + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // nullptr_t +#include // exception +#if JSON_DIAGNOSTICS + #include // accumulate +#endif +#include // runtime_error +#include // to_string +#include // vector + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // array +#include // size_t +#include // uint8_t +#include // string + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // declval, pair +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template struct make_void +{ + using type = void; +}; +template using void_t = typename make_void::type; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +// https://en.cppreference.com/w/cpp/experimental/is_detected +struct nonesuch +{ + nonesuch() = delete; + ~nonesuch() = delete; + nonesuch(nonesuch const&) = delete; + nonesuch(nonesuch const&&) = delete; + void operator=(nonesuch const&) = delete; + void operator=(nonesuch&&) = delete; +}; + +template class Op, + class... Args> +struct detector +{ + using value_t = std::false_type; + using type = Default; +}; + +template class Op, class... Args> +struct detector>, Op, Args...> +{ + using value_t = std::true_type; + using type = Op; +}; + +template class Op, class... Args> +using is_detected = typename detector::value_t; + +template class Op, class... Args> +struct is_detected_lazy : is_detected { }; + +template class Op, class... Args> +using detected_t = typename detector::type; + +template class Op, class... Args> +using detected_or = detector; + +template class Op, class... Args> +using detected_or_t = typename detected_or::type; + +template class Op, class... Args> +using is_detected_exact = std::is_same>; + +template class Op, class... Args> +using is_detected_convertible = + std::is_convertible, To>; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include + + +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-FileCopyrightText: 2016 - 2021 Evan Nemerson +// SPDX-License-Identifier: MIT + +/* Hedley - https://nemequ.github.io/hedley + * Created by Evan Nemerson + */ + +#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15) +#if defined(JSON_HEDLEY_VERSION) + #undef JSON_HEDLEY_VERSION +#endif +#define JSON_HEDLEY_VERSION 15 + +#if defined(JSON_HEDLEY_STRINGIFY_EX) + #undef JSON_HEDLEY_STRINGIFY_EX +#endif +#define JSON_HEDLEY_STRINGIFY_EX(x) #x + +#if defined(JSON_HEDLEY_STRINGIFY) + #undef JSON_HEDLEY_STRINGIFY +#endif +#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x) + +#if defined(JSON_HEDLEY_CONCAT_EX) + #undef JSON_HEDLEY_CONCAT_EX +#endif +#define JSON_HEDLEY_CONCAT_EX(a,b) a##b + +#if defined(JSON_HEDLEY_CONCAT) + #undef JSON_HEDLEY_CONCAT +#endif +#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b) + +#if defined(JSON_HEDLEY_CONCAT3_EX) + #undef JSON_HEDLEY_CONCAT3_EX +#endif +#define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c + +#if defined(JSON_HEDLEY_CONCAT3) + #undef JSON_HEDLEY_CONCAT3 +#endif +#define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c) + +#if defined(JSON_HEDLEY_VERSION_ENCODE) + #undef JSON_HEDLEY_VERSION_ENCODE +#endif +#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision)) + +#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR) + #undef JSON_HEDLEY_VERSION_DECODE_MAJOR +#endif +#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000) + +#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR) + #undef JSON_HEDLEY_VERSION_DECODE_MINOR +#endif +#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000) + +#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION) + #undef JSON_HEDLEY_VERSION_DECODE_REVISION +#endif +#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000) + +#if defined(JSON_HEDLEY_GNUC_VERSION) + #undef JSON_HEDLEY_GNUC_VERSION +#endif +#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__) + #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__) +#elif defined(__GNUC__) + #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0) +#endif + +#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK) + #undef JSON_HEDLEY_GNUC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_GNUC_VERSION) + #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_MSVC_VERSION) + #undef JSON_HEDLEY_MSVC_VERSION +#endif +#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL) + #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100) +#elif defined(_MSC_FULL_VER) && !defined(__ICL) + #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10) +#elif defined(_MSC_VER) && !defined(__ICL) + #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0) +#endif + +#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK) + #undef JSON_HEDLEY_MSVC_VERSION_CHECK +#endif +#if !defined(JSON_HEDLEY_MSVC_VERSION) + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0) +#elif defined(_MSC_VER) && (_MSC_VER >= 1400) + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch))) +#elif defined(_MSC_VER) && (_MSC_VER >= 1200) + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch))) +#else + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor))) +#endif + +#if defined(JSON_HEDLEY_INTEL_VERSION) + #undef JSON_HEDLEY_INTEL_VERSION +#endif +#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL) + #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE) +#elif defined(__INTEL_COMPILER) && !defined(__ICL) + #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0) +#endif + +#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK) + #undef JSON_HEDLEY_INTEL_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_INTEL_VERSION) + #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_INTEL_CL_VERSION) + #undef JSON_HEDLEY_INTEL_CL_VERSION +#endif +#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL) + #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0) +#endif + +#if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK) + #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_INTEL_CL_VERSION) + #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_PGI_VERSION) + #undef JSON_HEDLEY_PGI_VERSION +#endif +#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__) + #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__) +#endif + +#if defined(JSON_HEDLEY_PGI_VERSION_CHECK) + #undef JSON_HEDLEY_PGI_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_PGI_VERSION) + #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_SUNPRO_VERSION) + #undef JSON_HEDLEY_SUNPRO_VERSION +#endif +#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10) +#elif defined(__SUNPRO_C) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf) +#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10) +#elif defined(__SUNPRO_CC) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf) +#endif + +#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK) + #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_SUNPRO_VERSION) + #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION) + #undef JSON_HEDLEY_EMSCRIPTEN_VERSION +#endif +#if defined(__EMSCRIPTEN__) + #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__) +#endif + +#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK) + #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION) + #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_ARM_VERSION) + #undef JSON_HEDLEY_ARM_VERSION +#endif +#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION) + #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100) +#elif defined(__CC_ARM) && defined(__ARMCC_VERSION) + #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100) +#endif + +#if defined(JSON_HEDLEY_ARM_VERSION_CHECK) + #undef JSON_HEDLEY_ARM_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_ARM_VERSION) + #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_IBM_VERSION) + #undef JSON_HEDLEY_IBM_VERSION +#endif +#if defined(__ibmxl__) + #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__) +#elif defined(__xlC__) && defined(__xlC_ver__) + #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff) +#elif defined(__xlC__) + #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0) +#endif + +#if defined(JSON_HEDLEY_IBM_VERSION_CHECK) + #undef JSON_HEDLEY_IBM_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_IBM_VERSION) + #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_VERSION) + #undef JSON_HEDLEY_TI_VERSION +#endif +#if \ + defined(__TI_COMPILER_VERSION__) && \ + ( \ + defined(__TMS470__) || defined(__TI_ARM__) || \ + defined(__MSP430__) || \ + defined(__TMS320C2000__) \ + ) +#if (__TI_COMPILER_VERSION__ >= 16000000) + #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif +#endif + +#if defined(JSON_HEDLEY_TI_VERSION_CHECK) + #undef JSON_HEDLEY_TI_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_VERSION) + #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL2000_VERSION) + #undef JSON_HEDLEY_TI_CL2000_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__) + #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL2000_VERSION) + #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL430_VERSION) + #undef JSON_HEDLEY_TI_CL430_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__) + #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL430_VERSION) + #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_ARMCL_VERSION) + #undef JSON_HEDLEY_TI_ARMCL_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__)) + #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK) + #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_ARMCL_VERSION) + #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL6X_VERSION) + #undef JSON_HEDLEY_TI_CL6X_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__) + #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL6X_VERSION) + #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL7X_VERSION) + #undef JSON_HEDLEY_TI_CL7X_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__C7000__) + #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL7X_VERSION) + #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CLPRU_VERSION) + #undef JSON_HEDLEY_TI_CLPRU_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__PRU__) + #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CLPRU_VERSION) + #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_CRAY_VERSION) + #undef JSON_HEDLEY_CRAY_VERSION +#endif +#if defined(_CRAYC) + #if defined(_RELEASE_PATCHLEVEL) + #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL) + #else + #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0) + #endif +#endif + +#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK) + #undef JSON_HEDLEY_CRAY_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_CRAY_VERSION) + #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_IAR_VERSION) + #undef JSON_HEDLEY_IAR_VERSION +#endif +#if defined(__IAR_SYSTEMS_ICC__) + #if __VER__ > 1000 + #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000)) + #else + #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0) + #endif +#endif + +#if defined(JSON_HEDLEY_IAR_VERSION_CHECK) + #undef JSON_HEDLEY_IAR_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_IAR_VERSION) + #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TINYC_VERSION) + #undef JSON_HEDLEY_TINYC_VERSION +#endif +#if defined(__TINYC__) + #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100) +#endif + +#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK) + #undef JSON_HEDLEY_TINYC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TINYC_VERSION) + #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_DMC_VERSION) + #undef JSON_HEDLEY_DMC_VERSION +#endif +#if defined(__DMC__) + #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf) +#endif + +#if defined(JSON_HEDLEY_DMC_VERSION_CHECK) + #undef JSON_HEDLEY_DMC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_DMC_VERSION) + #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_COMPCERT_VERSION) + #undef JSON_HEDLEY_COMPCERT_VERSION +#endif +#if defined(__COMPCERT_VERSION__) + #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100) +#endif + +#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK) + #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_COMPCERT_VERSION) + #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_PELLES_VERSION) + #undef JSON_HEDLEY_PELLES_VERSION +#endif +#if defined(__POCC__) + #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0) +#endif + +#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK) + #undef JSON_HEDLEY_PELLES_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_PELLES_VERSION) + #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_MCST_LCC_VERSION) + #undef JSON_HEDLEY_MCST_LCC_VERSION +#endif +#if defined(__LCC__) && defined(__LCC_MINOR__) + #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__) +#endif + +#if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK) + #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_MCST_LCC_VERSION) + #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_GCC_VERSION) + #undef JSON_HEDLEY_GCC_VERSION +#endif +#if \ + defined(JSON_HEDLEY_GNUC_VERSION) && \ + !defined(__clang__) && \ + !defined(JSON_HEDLEY_INTEL_VERSION) && \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_ARM_VERSION) && \ + !defined(JSON_HEDLEY_CRAY_VERSION) && \ + !defined(JSON_HEDLEY_TI_VERSION) && \ + !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL430_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \ + !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \ + !defined(__COMPCERT__) && \ + !defined(JSON_HEDLEY_MCST_LCC_VERSION) + #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION +#endif + +#if defined(JSON_HEDLEY_GCC_VERSION_CHECK) + #undef JSON_HEDLEY_GCC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_GCC_VERSION) + #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_HAS_ATTRIBUTE +#endif +#if \ + defined(__has_attribute) && \ + ( \ + (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \ + ) +# define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute) +#else +# define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE +#endif +#if defined(__has_attribute) + #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) +#else + #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE +#endif +#if defined(__has_attribute) + #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) +#else + #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE +#endif +#if \ + defined(__has_cpp_attribute) && \ + defined(__cplusplus) && \ + (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute) +#else + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0) +#endif + +#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS) + #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS +#endif +#if !defined(__cplusplus) || !defined(__has_cpp_attribute) + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0) +#elif \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_IAR_VERSION) && \ + (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \ + (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0)) + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute) +#else + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE +#endif +#if defined(__has_cpp_attribute) && defined(__cplusplus) + #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute) +#else + #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE +#endif +#if defined(__has_cpp_attribute) && defined(__cplusplus) + #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute) +#else + #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_BUILTIN) + #undef JSON_HEDLEY_HAS_BUILTIN +#endif +#if defined(__has_builtin) + #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin) +#else + #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN) + #undef JSON_HEDLEY_GNUC_HAS_BUILTIN +#endif +#if defined(__has_builtin) + #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin) +#else + #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN) + #undef JSON_HEDLEY_GCC_HAS_BUILTIN +#endif +#if defined(__has_builtin) + #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin) +#else + #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_FEATURE) + #undef JSON_HEDLEY_HAS_FEATURE +#endif +#if defined(__has_feature) + #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature) +#else + #define JSON_HEDLEY_HAS_FEATURE(feature) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE) + #undef JSON_HEDLEY_GNUC_HAS_FEATURE +#endif +#if defined(__has_feature) + #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature) +#else + #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_FEATURE) + #undef JSON_HEDLEY_GCC_HAS_FEATURE +#endif +#if defined(__has_feature) + #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature) +#else + #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_EXTENSION) + #undef JSON_HEDLEY_HAS_EXTENSION +#endif +#if defined(__has_extension) + #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension) +#else + #define JSON_HEDLEY_HAS_EXTENSION(extension) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION) + #undef JSON_HEDLEY_GNUC_HAS_EXTENSION +#endif +#if defined(__has_extension) + #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension) +#else + #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION) + #undef JSON_HEDLEY_GCC_HAS_EXTENSION +#endif +#if defined(__has_extension) + #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension) +#else + #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE +#endif +#if defined(__has_declspec_attribute) + #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute) +#else + #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE +#endif +#if defined(__has_declspec_attribute) + #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute) +#else + #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE +#endif +#if defined(__has_declspec_attribute) + #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute) +#else + #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_WARNING) + #undef JSON_HEDLEY_HAS_WARNING +#endif +#if defined(__has_warning) + #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning) +#else + #define JSON_HEDLEY_HAS_WARNING(warning) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_WARNING) + #undef JSON_HEDLEY_GNUC_HAS_WARNING +#endif +#if defined(__has_warning) + #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning) +#else + #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_WARNING) + #undef JSON_HEDLEY_GCC_HAS_WARNING +#endif +#if defined(__has_warning) + #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning) +#else + #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if \ + (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \ + defined(__clang__) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \ + (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR)) + #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value) +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) + #define JSON_HEDLEY_PRAGMA(value) __pragma(value) +#else + #define JSON_HEDLEY_PRAGMA(value) +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH) + #undef JSON_HEDLEY_DIAGNOSTIC_PUSH +#endif +#if defined(JSON_HEDLEY_DIAGNOSTIC_POP) + #undef JSON_HEDLEY_DIAGNOSTIC_POP +#endif +#if defined(__clang__) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop") +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push)) + #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop)) +#elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop") +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop") +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)") +#else + #define JSON_HEDLEY_DIAGNOSTIC_PUSH + #define JSON_HEDLEY_DIAGNOSTIC_POP +#endif + +/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for + HEDLEY INTERNAL USE ONLY. API subject to change without notice. */ +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ +#endif +#if defined(__cplusplus) +# if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat") +# if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions") +# if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions") +# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ + _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \ + _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \ + xpr \ + JSON_HEDLEY_DIAGNOSTIC_POP +# else +# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ + _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \ + xpr \ + JSON_HEDLEY_DIAGNOSTIC_POP +# endif +# else +# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ + xpr \ + JSON_HEDLEY_DIAGNOSTIC_POP +# endif +# endif +#endif +#if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x +#endif + +#if defined(JSON_HEDLEY_CONST_CAST) + #undef JSON_HEDLEY_CONST_CAST +#endif +#if defined(__cplusplus) +# define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast(expr)) +#elif \ + JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) +# define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \ + ((T) (expr)); \ + JSON_HEDLEY_DIAGNOSTIC_POP \ + })) +#else +# define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr)) +#endif + +#if defined(JSON_HEDLEY_REINTERPRET_CAST) + #undef JSON_HEDLEY_REINTERPRET_CAST +#endif +#if defined(__cplusplus) + #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast(expr)) +#else + #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr)) +#endif + +#if defined(JSON_HEDLEY_STATIC_CAST) + #undef JSON_HEDLEY_STATIC_CAST +#endif +#if defined(__cplusplus) + #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast(expr)) +#else + #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr)) +#endif + +#if defined(JSON_HEDLEY_CPP_CAST) + #undef JSON_HEDLEY_CPP_CAST +#endif +#if defined(__cplusplus) +# if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast") +# define JSON_HEDLEY_CPP_CAST(T, expr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \ + ((T) (expr)) \ + JSON_HEDLEY_DIAGNOSTIC_POP +# elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0) +# define JSON_HEDLEY_CPP_CAST(T, expr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("diag_suppress=Pe137") \ + JSON_HEDLEY_DIAGNOSTIC_POP +# else +# define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr)) +# endif +#else +# define JSON_HEDLEY_CPP_CAST(T, expr) (expr) +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)") +#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786)) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445") +#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996)) +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444") +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718") +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)") +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215") +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)") +#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161)) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"") +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068)) +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163") +#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161") +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)") +#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292)) +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030)) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098") +#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097") +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)") +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097") +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wcast-qual") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunused-function") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"") +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505)) +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION +#endif + +#if defined(JSON_HEDLEY_DEPRECATED) + #undef JSON_HEDLEY_DEPRECATED +#endif +#if defined(JSON_HEDLEY_DEPRECATED_FOR) + #undef JSON_HEDLEY_DEPRECATED_FOR +#endif +#if \ + JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since)) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement)) +#elif \ + (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since))) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement))) +#elif defined(__cplusplus) && (__cplusplus >= 201402L) + #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]]) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]]) +#elif \ + JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) + #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__)) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__)) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated) +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated") + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated") +#else + #define JSON_HEDLEY_DEPRECATED(since) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) +#endif + +#if defined(JSON_HEDLEY_UNAVAILABLE) + #undef JSON_HEDLEY_UNAVAILABLE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since))) +#else + #define JSON_HEDLEY_UNAVAILABLE(available_since) +#endif + +#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT) + #undef JSON_HEDLEY_WARN_UNUSED_RESULT +#endif +#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG) + #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__)) + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__)) +#elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L) + #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]]) +#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) + #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) +#elif defined(_Check_return_) /* SAL */ + #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_ + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_ +#else + #define JSON_HEDLEY_WARN_UNUSED_RESULT + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) +#endif + +#if defined(JSON_HEDLEY_SENTINEL) + #undef JSON_HEDLEY_SENTINEL +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position))) +#else + #define JSON_HEDLEY_SENTINEL(position) +#endif + +#if defined(JSON_HEDLEY_NO_RETURN) + #undef JSON_HEDLEY_NO_RETURN +#endif +#if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_NO_RETURN __noreturn +#elif \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__)) +#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L + #define JSON_HEDLEY_NO_RETURN _Noreturn +#elif defined(__cplusplus) && (__cplusplus >= 201103L) + #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]]) +#elif \ + JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) + #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__)) +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) + #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return") +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_NO_RETURN __declspec(noreturn) +#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus) + #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;") +#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0) + #define JSON_HEDLEY_NO_RETURN __attribute((noreturn)) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0) + #define JSON_HEDLEY_NO_RETURN __declspec(noreturn) +#else + #define JSON_HEDLEY_NO_RETURN +#endif + +#if defined(JSON_HEDLEY_NO_ESCAPE) + #undef JSON_HEDLEY_NO_ESCAPE +#endif +#if JSON_HEDLEY_HAS_ATTRIBUTE(noescape) + #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__)) +#else + #define JSON_HEDLEY_NO_ESCAPE +#endif + +#if defined(JSON_HEDLEY_UNREACHABLE) + #undef JSON_HEDLEY_UNREACHABLE +#endif +#if defined(JSON_HEDLEY_UNREACHABLE_RETURN) + #undef JSON_HEDLEY_UNREACHABLE_RETURN +#endif +#if defined(JSON_HEDLEY_ASSUME) + #undef JSON_HEDLEY_ASSUME +#endif +#if \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_ASSUME(expr) __assume(expr) +#elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume) + #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr) +#elif \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) + #if defined(__cplusplus) + #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr) + #else + #define JSON_HEDLEY_ASSUME(expr) _nassert(expr) + #endif +#endif +#if \ + (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable() +#elif defined(JSON_HEDLEY_ASSUME) + #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0) +#endif +#if !defined(JSON_HEDLEY_ASSUME) + #if defined(JSON_HEDLEY_UNREACHABLE) + #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1))) + #else + #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr) + #endif +#endif +#if defined(JSON_HEDLEY_UNREACHABLE) + #if \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) + #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value)) + #else + #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE() + #endif +#else + #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value) +#endif +#if !defined(JSON_HEDLEY_UNREACHABLE) + #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0) +#endif + +JSON_HEDLEY_DIAGNOSTIC_PUSH +#if JSON_HEDLEY_HAS_WARNING("-Wpedantic") + #pragma clang diagnostic ignored "-Wpedantic" +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus) + #pragma clang diagnostic ignored "-Wc++98-compat-pedantic" +#endif +#if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0) + #if defined(__clang__) + #pragma clang diagnostic ignored "-Wvariadic-macros" + #elif defined(JSON_HEDLEY_GCC_VERSION) + #pragma GCC diagnostic ignored "-Wvariadic-macros" + #endif +#endif +#if defined(JSON_HEDLEY_NON_NULL) + #undef JSON_HEDLEY_NON_NULL +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) + #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__))) +#else + #define JSON_HEDLEY_NON_NULL(...) +#endif +JSON_HEDLEY_DIAGNOSTIC_POP + +#if defined(JSON_HEDLEY_PRINTF_FORMAT) + #undef JSON_HEDLEY_PRINTF_FORMAT +#endif +#if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check))) +#elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check))) +#elif \ + JSON_HEDLEY_HAS_ATTRIBUTE(format) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check))) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check)) +#else + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) +#endif + +#if defined(JSON_HEDLEY_CONSTEXPR) + #undef JSON_HEDLEY_CONSTEXPR +#endif +#if defined(__cplusplus) + #if __cplusplus >= 201103L + #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr) + #endif +#endif +#if !defined(JSON_HEDLEY_CONSTEXPR) + #define JSON_HEDLEY_CONSTEXPR +#endif + +#if defined(JSON_HEDLEY_PREDICT) + #undef JSON_HEDLEY_PREDICT +#endif +#if defined(JSON_HEDLEY_LIKELY) + #undef JSON_HEDLEY_LIKELY +#endif +#if defined(JSON_HEDLEY_UNLIKELY) + #undef JSON_HEDLEY_UNLIKELY +#endif +#if defined(JSON_HEDLEY_UNPREDICTABLE) + #undef JSON_HEDLEY_UNPREDICTABLE +#endif +#if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable) + #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr)) +#endif +#if \ + (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability( (expr), (value), (probability)) +# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) __builtin_expect_with_probability(!!(expr), 1 , (probability)) +# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) __builtin_expect_with_probability(!!(expr), 0 , (probability)) +# define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 ) +# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) +#elif \ + (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PREDICT(expr, expected, probability) \ + (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))) +# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \ + (__extension__ ({ \ + double hedley_probability_ = (probability); \ + ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \ + })) +# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \ + (__extension__ ({ \ + double hedley_probability_ = (probability); \ + ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \ + })) +# define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1) +# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0) +#else +# define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)) +# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr)) +# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr)) +# define JSON_HEDLEY_LIKELY(expr) (!!(expr)) +# define JSON_HEDLEY_UNLIKELY(expr) (!!(expr)) +#endif +#if !defined(JSON_HEDLEY_UNPREDICTABLE) + #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5) +#endif + +#if defined(JSON_HEDLEY_MALLOC) + #undef JSON_HEDLEY_MALLOC +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_MALLOC __attribute__((__malloc__)) +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) + #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory") +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_MALLOC __declspec(restrict) +#else + #define JSON_HEDLEY_MALLOC +#endif + +#if defined(JSON_HEDLEY_PURE) + #undef JSON_HEDLEY_PURE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PURE __attribute__((__pure__)) +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) +# define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data") +#elif defined(__cplusplus) && \ + ( \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \ + ) +# define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;") +#else +# define JSON_HEDLEY_PURE +#endif + +#if defined(JSON_HEDLEY_CONST) + #undef JSON_HEDLEY_CONST +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(const) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_CONST __attribute__((__const__)) +#elif \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) + #define JSON_HEDLEY_CONST _Pragma("no_side_effect") +#else + #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE +#endif + +#if defined(JSON_HEDLEY_RESTRICT) + #undef JSON_HEDLEY_RESTRICT +#endif +#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus) + #define JSON_HEDLEY_RESTRICT restrict +#elif \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \ + defined(__clang__) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_RESTRICT __restrict +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus) + #define JSON_HEDLEY_RESTRICT _Restrict +#else + #define JSON_HEDLEY_RESTRICT +#endif + +#if defined(JSON_HEDLEY_INLINE) + #undef JSON_HEDLEY_INLINE +#endif +#if \ + (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \ + (defined(__cplusplus) && (__cplusplus >= 199711L)) + #define JSON_HEDLEY_INLINE inline +#elif \ + defined(JSON_HEDLEY_GCC_VERSION) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0) + #define JSON_HEDLEY_INLINE __inline__ +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_INLINE __inline +#else + #define JSON_HEDLEY_INLINE +#endif + +#if defined(JSON_HEDLEY_ALWAYS_INLINE) + #undef JSON_HEDLEY_ALWAYS_INLINE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) +# define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) +# define JSON_HEDLEY_ALWAYS_INLINE __forceinline +#elif defined(__cplusplus) && \ + ( \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \ + ) +# define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) +# define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced") +#else +# define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE +#endif + +#if defined(JSON_HEDLEY_NEVER_INLINE) + #undef JSON_HEDLEY_NEVER_INLINE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) + #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__)) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0) + #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline") +#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus) + #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never") +#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0) + #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline)) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0) + #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline) +#else + #define JSON_HEDLEY_NEVER_INLINE +#endif + +#if defined(JSON_HEDLEY_PRIVATE) + #undef JSON_HEDLEY_PRIVATE +#endif +#if defined(JSON_HEDLEY_PUBLIC) + #undef JSON_HEDLEY_PUBLIC +#endif +#if defined(JSON_HEDLEY_IMPORT) + #undef JSON_HEDLEY_IMPORT +#endif +#if defined(_WIN32) || defined(__CYGWIN__) +# define JSON_HEDLEY_PRIVATE +# define JSON_HEDLEY_PUBLIC __declspec(dllexport) +# define JSON_HEDLEY_IMPORT __declspec(dllimport) +#else +# if \ + JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ + ( \ + defined(__TI_EABI__) && \ + ( \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \ + ) \ + ) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden"))) +# define JSON_HEDLEY_PUBLIC __attribute__((__visibility__("default"))) +# else +# define JSON_HEDLEY_PRIVATE +# define JSON_HEDLEY_PUBLIC +# endif +# define JSON_HEDLEY_IMPORT extern +#endif + +#if defined(JSON_HEDLEY_NO_THROW) + #undef JSON_HEDLEY_NO_THROW +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__)) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) + #define JSON_HEDLEY_NO_THROW __declspec(nothrow) +#else + #define JSON_HEDLEY_NO_THROW +#endif + +#if defined(JSON_HEDLEY_FALL_THROUGH) + #undef JSON_HEDLEY_FALL_THROUGH +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__)) +#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough) + #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]]) +#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough) + #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]]) +#elif defined(__fallthrough) /* SAL */ + #define JSON_HEDLEY_FALL_THROUGH __fallthrough +#else + #define JSON_HEDLEY_FALL_THROUGH +#endif + +#if defined(JSON_HEDLEY_RETURNS_NON_NULL) + #undef JSON_HEDLEY_RETURNS_NON_NULL +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__)) +#elif defined(_Ret_notnull_) /* SAL */ + #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_ +#else + #define JSON_HEDLEY_RETURNS_NON_NULL +#endif + +#if defined(JSON_HEDLEY_ARRAY_PARAM) + #undef JSON_HEDLEY_ARRAY_PARAM +#endif +#if \ + defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \ + !defined(__STDC_NO_VLA__) && \ + !defined(__cplusplus) && \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_TINYC_VERSION) + #define JSON_HEDLEY_ARRAY_PARAM(name) (name) +#else + #define JSON_HEDLEY_ARRAY_PARAM(name) +#endif + +#if defined(JSON_HEDLEY_IS_CONSTANT) + #undef JSON_HEDLEY_IS_CONSTANT +#endif +#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR) + #undef JSON_HEDLEY_REQUIRE_CONSTEXPR +#endif +/* JSON_HEDLEY_IS_CONSTEXPR_ is for + HEDLEY INTERNAL USE ONLY. API subject to change without notice. */ +#if defined(JSON_HEDLEY_IS_CONSTEXPR_) + #undef JSON_HEDLEY_IS_CONSTEXPR_ +#endif +#if \ + JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr) +#endif +#if !defined(__cplusplus) +# if \ + JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24) +#if defined(__INTPTR_TYPE__) + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*) +#else + #include + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*) +#endif +# elif \ + ( \ + defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \ + !defined(JSON_HEDLEY_SUNPRO_VERSION) && \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_IAR_VERSION)) || \ + (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0) +#if defined(__INTPTR_TYPE__) + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0) +#else + #include + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0) +#endif +# elif \ + defined(JSON_HEDLEY_GCC_VERSION) || \ + defined(JSON_HEDLEY_INTEL_VERSION) || \ + defined(JSON_HEDLEY_TINYC_VERSION) || \ + defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \ + defined(JSON_HEDLEY_TI_CL2000_VERSION) || \ + defined(JSON_HEDLEY_TI_CL6X_VERSION) || \ + defined(JSON_HEDLEY_TI_CL7X_VERSION) || \ + defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \ + defined(__clang__) +# define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \ + sizeof(void) != \ + sizeof(*( \ + 1 ? \ + ((void*) ((expr) * 0L) ) : \ +((struct { char v[sizeof(void) * 2]; } *) 1) \ + ) \ + ) \ + ) +# endif +#endif +#if defined(JSON_HEDLEY_IS_CONSTEXPR_) + #if !defined(JSON_HEDLEY_IS_CONSTANT) + #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr) + #endif + #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1)) +#else + #if !defined(JSON_HEDLEY_IS_CONSTANT) + #define JSON_HEDLEY_IS_CONSTANT(expr) (0) + #endif + #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr) +#endif + +#if defined(JSON_HEDLEY_BEGIN_C_DECLS) + #undef JSON_HEDLEY_BEGIN_C_DECLS +#endif +#if defined(JSON_HEDLEY_END_C_DECLS) + #undef JSON_HEDLEY_END_C_DECLS +#endif +#if defined(JSON_HEDLEY_C_DECL) + #undef JSON_HEDLEY_C_DECL +#endif +#if defined(__cplusplus) + #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" { + #define JSON_HEDLEY_END_C_DECLS } + #define JSON_HEDLEY_C_DECL extern "C" +#else + #define JSON_HEDLEY_BEGIN_C_DECLS + #define JSON_HEDLEY_END_C_DECLS + #define JSON_HEDLEY_C_DECL +#endif + +#if defined(JSON_HEDLEY_STATIC_ASSERT) + #undef JSON_HEDLEY_STATIC_ASSERT +#endif +#if \ + !defined(__cplusplus) && ( \ + (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \ + (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + defined(_Static_assert) \ + ) +# define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message) +#elif \ + (defined(__cplusplus) && (__cplusplus >= 201103L)) || \ + JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) +# define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message)) +#else +# define JSON_HEDLEY_STATIC_ASSERT(expr, message) +#endif + +#if defined(JSON_HEDLEY_NULL) + #undef JSON_HEDLEY_NULL +#endif +#if defined(__cplusplus) + #if __cplusplus >= 201103L + #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr) + #elif defined(NULL) + #define JSON_HEDLEY_NULL NULL + #else + #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0) + #endif +#elif defined(NULL) + #define JSON_HEDLEY_NULL NULL +#else + #define JSON_HEDLEY_NULL ((void*) 0) +#endif + +#if defined(JSON_HEDLEY_MESSAGE) + #undef JSON_HEDLEY_MESSAGE +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") +# define JSON_HEDLEY_MESSAGE(msg) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ + JSON_HEDLEY_PRAGMA(message msg) \ + JSON_HEDLEY_DIAGNOSTIC_POP +#elif \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg) +#elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg) +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg)) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg)) +#else +# define JSON_HEDLEY_MESSAGE(msg) +#endif + +#if defined(JSON_HEDLEY_WARNING) + #undef JSON_HEDLEY_WARNING +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") +# define JSON_HEDLEY_WARNING(msg) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ + JSON_HEDLEY_PRAGMA(clang warning msg) \ + JSON_HEDLEY_DIAGNOSTIC_POP +#elif \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) +# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) +# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg)) +#else +# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg) +#endif + +#if defined(JSON_HEDLEY_REQUIRE) + #undef JSON_HEDLEY_REQUIRE +#endif +#if defined(JSON_HEDLEY_REQUIRE_MSG) + #undef JSON_HEDLEY_REQUIRE_MSG +#endif +#if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if) +# if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat") +# define JSON_HEDLEY_REQUIRE(expr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \ + __attribute__((diagnose_if(!(expr), #expr, "error"))) \ + JSON_HEDLEY_DIAGNOSTIC_POP +# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \ + __attribute__((diagnose_if(!(expr), msg, "error"))) \ + JSON_HEDLEY_DIAGNOSTIC_POP +# else +# define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error"))) +# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error"))) +# endif +#else +# define JSON_HEDLEY_REQUIRE(expr) +# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) +#endif + +#if defined(JSON_HEDLEY_FLAGS) + #undef JSON_HEDLEY_FLAGS +#endif +#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion")) + #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__)) +#else + #define JSON_HEDLEY_FLAGS +#endif + +#if defined(JSON_HEDLEY_FLAGS_CAST) + #undef JSON_HEDLEY_FLAGS_CAST +#endif +#if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0) +# define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("warning(disable:188)") \ + ((T) (expr)); \ + JSON_HEDLEY_DIAGNOSTIC_POP \ + })) +#else +# define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr) +#endif + +#if defined(JSON_HEDLEY_EMPTY_BASES) + #undef JSON_HEDLEY_EMPTY_BASES +#endif +#if \ + (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases) +#else + #define JSON_HEDLEY_EMPTY_BASES +#endif + +/* Remaining macros are deprecated. */ + +#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK) + #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK +#endif +#if defined(__clang__) + #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0) +#else + #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE +#endif +#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) + +#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE +#endif +#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) + +#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN) + #undef JSON_HEDLEY_CLANG_HAS_BUILTIN +#endif +#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin) + +#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE) + #undef JSON_HEDLEY_CLANG_HAS_FEATURE +#endif +#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature) + +#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION) + #undef JSON_HEDLEY_CLANG_HAS_EXTENSION +#endif +#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension) + +#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE +#endif +#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) + +#if defined(JSON_HEDLEY_CLANG_HAS_WARNING) + #undef JSON_HEDLEY_CLANG_HAS_WARNING +#endif +#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning) + +#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */ + + +// This file contains all internal macro definitions (except those affecting ABI) +// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them + +// #include + + +// exclude unsupported compilers +#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK) + #if defined(__clang__) + #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400 + #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers" + #endif + #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER)) + #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800 + #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers" + #endif + #endif +#endif + +// C++ language standard detection +// if the user manually specified the used c++ version this is skipped +#if !defined(JSON_HAS_CPP_23) && !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11) + #if (defined(__cplusplus) && __cplusplus > 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG > 202002L) + #define JSON_HAS_CPP_23 + #define JSON_HAS_CPP_20 + #define JSON_HAS_CPP_17 + #define JSON_HAS_CPP_14 + #elif (defined(__cplusplus) && __cplusplus > 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG > 201703L) + #define JSON_HAS_CPP_20 + #define JSON_HAS_CPP_17 + #define JSON_HAS_CPP_14 + #elif (defined(__cplusplus) && __cplusplus > 201402L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464 + #define JSON_HAS_CPP_17 + #define JSON_HAS_CPP_14 + #elif (defined(__cplusplus) && __cplusplus > 201103L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1) + #define JSON_HAS_CPP_14 + #endif + // the cpp 11 flag is always specified because it is the minimal required version + #define JSON_HAS_CPP_11 +#endif + +#ifdef __has_include + #if __has_include() + #include + #endif +#endif + +#if !defined(JSON_HAS_FILESYSTEM) && !defined(JSON_HAS_EXPERIMENTAL_FILESYSTEM) + #ifdef JSON_HAS_CPP_17 + #if defined(__cpp_lib_filesystem) + #define JSON_HAS_FILESYSTEM 1 + #elif defined(__cpp_lib_experimental_filesystem) + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 + #elif !defined(__has_include) + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 + #elif __has_include() + #define JSON_HAS_FILESYSTEM 1 + #elif __has_include() + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 + #endif + + // std::filesystem does not work on MinGW GCC 8: https://sourceforge.net/p/mingw-w64/bugs/737/ + #if defined(__MINGW32__) && defined(__GNUC__) && __GNUC__ == 8 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before GCC 8: https://en.cppreference.com/w/cpp/compiler_support + #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 8 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before Clang 7: https://en.cppreference.com/w/cpp/compiler_support + #if defined(__clang_major__) && __clang_major__ < 7 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before MSVC 19.14: https://en.cppreference.com/w/cpp/compiler_support + #if defined(_MSC_VER) && _MSC_VER < 1914 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before iOS 13 + #if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before macOS Catalina + #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + #endif +#endif + +#ifndef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 0 +#endif + +#ifndef JSON_HAS_FILESYSTEM + #define JSON_HAS_FILESYSTEM 0 +#endif + +#ifndef JSON_HAS_THREE_WAY_COMPARISON + #if defined(__cpp_impl_three_way_comparison) && __cpp_impl_three_way_comparison >= 201907L \ + && defined(__cpp_lib_three_way_comparison) && __cpp_lib_three_way_comparison >= 201907L + #define JSON_HAS_THREE_WAY_COMPARISON 1 + #else + #define JSON_HAS_THREE_WAY_COMPARISON 0 + #endif +#endif + +#ifndef JSON_HAS_RANGES + // ranges header shipping in GCC 11.1.0 (released 2021-04-27) has syntax error + #if defined(__GLIBCXX__) && __GLIBCXX__ == 20210427 + #define JSON_HAS_RANGES 0 + #elif defined(__cpp_lib_ranges) + #define JSON_HAS_RANGES 1 + #else + #define JSON_HAS_RANGES 0 + #endif +#endif + +#ifndef JSON_HAS_STATIC_RTTI + #if !defined(_HAS_STATIC_RTTI) || _HAS_STATIC_RTTI != 0 + #define JSON_HAS_STATIC_RTTI 1 + #else + #define JSON_HAS_STATIC_RTTI 0 + #endif +#endif + +#ifdef JSON_HAS_CPP_17 + #define JSON_INLINE_VARIABLE inline +#else + #define JSON_INLINE_VARIABLE +#endif + +#if JSON_HEDLEY_HAS_ATTRIBUTE(no_unique_address) + #define JSON_NO_UNIQUE_ADDRESS [[no_unique_address]] +#else + #define JSON_NO_UNIQUE_ADDRESS +#endif + +// disable documentation warnings on clang +#if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wdocumentation" + #pragma clang diagnostic ignored "-Wdocumentation-unknown-command" +#endif + +// allow disabling exceptions +#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION) + #define JSON_THROW(exception) throw exception + #define JSON_TRY try + #define JSON_CATCH(exception) catch(exception) + #define JSON_INTERNAL_CATCH(exception) catch(exception) +#else + #include + #define JSON_THROW(exception) std::abort() + #define JSON_TRY if(true) + #define JSON_CATCH(exception) if(false) + #define JSON_INTERNAL_CATCH(exception) if(false) +#endif + +// override exception macros +#if defined(JSON_THROW_USER) + #undef JSON_THROW + #define JSON_THROW JSON_THROW_USER +#endif +#if defined(JSON_TRY_USER) + #undef JSON_TRY + #define JSON_TRY JSON_TRY_USER +#endif +#if defined(JSON_CATCH_USER) + #undef JSON_CATCH + #define JSON_CATCH JSON_CATCH_USER + #undef JSON_INTERNAL_CATCH + #define JSON_INTERNAL_CATCH JSON_CATCH_USER +#endif +#if defined(JSON_INTERNAL_CATCH_USER) + #undef JSON_INTERNAL_CATCH + #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER +#endif + +// allow overriding assert +#if !defined(JSON_ASSERT) + #include // assert + #define JSON_ASSERT(x) assert(x) +#endif + +// allow to access some private functions (needed by the test suite) +#if defined(JSON_TESTS_PRIVATE) + #define JSON_PRIVATE_UNLESS_TESTED public +#else + #define JSON_PRIVATE_UNLESS_TESTED private +#endif + +/*! +@brief macro to briefly define a mapping between an enum and JSON +@def NLOHMANN_JSON_SERIALIZE_ENUM +@since version 3.4.0 +*/ +#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...) \ + template \ + inline void to_json(BasicJsonType& j, const ENUM_TYPE& e) \ + { \ + /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */ \ + static_assert(std::is_enum::value, #ENUM_TYPE " must be an enum!"); \ + /* NOLINTNEXTLINE(modernize-avoid-c-arrays) we don't want to depend on */ \ + static const std::pair m[] = __VA_ARGS__; \ + auto it = std::find_if(std::begin(m), std::end(m), \ + [e](const std::pair& ej_pair) -> bool \ + { \ + return ej_pair.first == e; \ + }); \ + j = ((it != std::end(m)) ? it : std::begin(m))->second; \ + } \ + template \ + inline void from_json(const BasicJsonType& j, ENUM_TYPE& e) \ + { \ + /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */ \ + static_assert(std::is_enum::value, #ENUM_TYPE " must be an enum!"); \ + /* NOLINTNEXTLINE(modernize-avoid-c-arrays) we don't want to depend on */ \ + static const std::pair m[] = __VA_ARGS__; \ + auto it = std::find_if(std::begin(m), std::end(m), \ + [&j](const std::pair& ej_pair) -> bool \ + { \ + return ej_pair.second == j; \ + }); \ + e = ((it != std::end(m)) ? it : std::begin(m))->first; \ + } + +// Ugly macros to avoid uglier copy-paste when specializing basic_json. They +// may be removed in the future once the class is split. + +#define NLOHMANN_BASIC_JSON_TPL_DECLARATION \ + template class ObjectType, \ + template class ArrayType, \ + class StringType, class BooleanType, class NumberIntegerType, \ + class NumberUnsignedType, class NumberFloatType, \ + template class AllocatorType, \ + template class JSONSerializer, \ + class BinaryType, \ + class CustomBaseClass> + +#define NLOHMANN_BASIC_JSON_TPL \ + basic_json + +// Macros to simplify conversion from/to types + +#define NLOHMANN_JSON_EXPAND( x ) x +#define NLOHMANN_JSON_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, NAME,...) NAME +#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \ + NLOHMANN_JSON_PASTE64, \ + NLOHMANN_JSON_PASTE63, \ + NLOHMANN_JSON_PASTE62, \ + NLOHMANN_JSON_PASTE61, \ + NLOHMANN_JSON_PASTE60, \ + NLOHMANN_JSON_PASTE59, \ + NLOHMANN_JSON_PASTE58, \ + NLOHMANN_JSON_PASTE57, \ + NLOHMANN_JSON_PASTE56, \ + NLOHMANN_JSON_PASTE55, \ + NLOHMANN_JSON_PASTE54, \ + NLOHMANN_JSON_PASTE53, \ + NLOHMANN_JSON_PASTE52, \ + NLOHMANN_JSON_PASTE51, \ + NLOHMANN_JSON_PASTE50, \ + NLOHMANN_JSON_PASTE49, \ + NLOHMANN_JSON_PASTE48, \ + NLOHMANN_JSON_PASTE47, \ + NLOHMANN_JSON_PASTE46, \ + NLOHMANN_JSON_PASTE45, \ + NLOHMANN_JSON_PASTE44, \ + NLOHMANN_JSON_PASTE43, \ + NLOHMANN_JSON_PASTE42, \ + NLOHMANN_JSON_PASTE41, \ + NLOHMANN_JSON_PASTE40, \ + NLOHMANN_JSON_PASTE39, \ + NLOHMANN_JSON_PASTE38, \ + NLOHMANN_JSON_PASTE37, \ + NLOHMANN_JSON_PASTE36, \ + NLOHMANN_JSON_PASTE35, \ + NLOHMANN_JSON_PASTE34, \ + NLOHMANN_JSON_PASTE33, \ + NLOHMANN_JSON_PASTE32, \ + NLOHMANN_JSON_PASTE31, \ + NLOHMANN_JSON_PASTE30, \ + NLOHMANN_JSON_PASTE29, \ + NLOHMANN_JSON_PASTE28, \ + NLOHMANN_JSON_PASTE27, \ + NLOHMANN_JSON_PASTE26, \ + NLOHMANN_JSON_PASTE25, \ + NLOHMANN_JSON_PASTE24, \ + NLOHMANN_JSON_PASTE23, \ + NLOHMANN_JSON_PASTE22, \ + NLOHMANN_JSON_PASTE21, \ + NLOHMANN_JSON_PASTE20, \ + NLOHMANN_JSON_PASTE19, \ + NLOHMANN_JSON_PASTE18, \ + NLOHMANN_JSON_PASTE17, \ + NLOHMANN_JSON_PASTE16, \ + NLOHMANN_JSON_PASTE15, \ + NLOHMANN_JSON_PASTE14, \ + NLOHMANN_JSON_PASTE13, \ + NLOHMANN_JSON_PASTE12, \ + NLOHMANN_JSON_PASTE11, \ + NLOHMANN_JSON_PASTE10, \ + NLOHMANN_JSON_PASTE9, \ + NLOHMANN_JSON_PASTE8, \ + NLOHMANN_JSON_PASTE7, \ + NLOHMANN_JSON_PASTE6, \ + NLOHMANN_JSON_PASTE5, \ + NLOHMANN_JSON_PASTE4, \ + NLOHMANN_JSON_PASTE3, \ + NLOHMANN_JSON_PASTE2, \ + NLOHMANN_JSON_PASTE1)(__VA_ARGS__)) +#define NLOHMANN_JSON_PASTE2(func, v1) func(v1) +#define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2) +#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3) +#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4) +#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5) +#define NLOHMANN_JSON_PASTE7(func, v1, v2, v3, v4, v5, v6) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE6(func, v2, v3, v4, v5, v6) +#define NLOHMANN_JSON_PASTE8(func, v1, v2, v3, v4, v5, v6, v7) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE7(func, v2, v3, v4, v5, v6, v7) +#define NLOHMANN_JSON_PASTE9(func, v1, v2, v3, v4, v5, v6, v7, v8) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE8(func, v2, v3, v4, v5, v6, v7, v8) +#define NLOHMANN_JSON_PASTE10(func, v1, v2, v3, v4, v5, v6, v7, v8, v9) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE9(func, v2, v3, v4, v5, v6, v7, v8, v9) +#define NLOHMANN_JSON_PASTE11(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE10(func, v2, v3, v4, v5, v6, v7, v8, v9, v10) +#define NLOHMANN_JSON_PASTE12(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) +#define NLOHMANN_JSON_PASTE13(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) +#define NLOHMANN_JSON_PASTE14(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) +#define NLOHMANN_JSON_PASTE15(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) +#define NLOHMANN_JSON_PASTE16(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) +#define NLOHMANN_JSON_PASTE17(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) +#define NLOHMANN_JSON_PASTE18(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) +#define NLOHMANN_JSON_PASTE19(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) +#define NLOHMANN_JSON_PASTE20(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) +#define NLOHMANN_JSON_PASTE21(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) +#define NLOHMANN_JSON_PASTE22(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) +#define NLOHMANN_JSON_PASTE23(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) +#define NLOHMANN_JSON_PASTE24(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) +#define NLOHMANN_JSON_PASTE25(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) +#define NLOHMANN_JSON_PASTE26(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) +#define NLOHMANN_JSON_PASTE27(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE26(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) +#define NLOHMANN_JSON_PASTE28(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE27(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) +#define NLOHMANN_JSON_PASTE29(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE28(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) +#define NLOHMANN_JSON_PASTE30(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE29(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) +#define NLOHMANN_JSON_PASTE31(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE30(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) +#define NLOHMANN_JSON_PASTE32(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE31(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) +#define NLOHMANN_JSON_PASTE33(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE32(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) +#define NLOHMANN_JSON_PASTE34(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE33(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) +#define NLOHMANN_JSON_PASTE35(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE34(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) +#define NLOHMANN_JSON_PASTE36(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE35(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) +#define NLOHMANN_JSON_PASTE37(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE36(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) +#define NLOHMANN_JSON_PASTE38(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE37(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) +#define NLOHMANN_JSON_PASTE39(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE38(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) +#define NLOHMANN_JSON_PASTE40(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE39(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) +#define NLOHMANN_JSON_PASTE41(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE40(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) +#define NLOHMANN_JSON_PASTE42(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE41(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) +#define NLOHMANN_JSON_PASTE43(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE42(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) +#define NLOHMANN_JSON_PASTE44(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE43(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) +#define NLOHMANN_JSON_PASTE45(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE44(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) +#define NLOHMANN_JSON_PASTE46(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE45(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) +#define NLOHMANN_JSON_PASTE47(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE46(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) +#define NLOHMANN_JSON_PASTE48(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE47(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) +#define NLOHMANN_JSON_PASTE49(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE48(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) +#define NLOHMANN_JSON_PASTE50(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) +#define NLOHMANN_JSON_PASTE51(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) +#define NLOHMANN_JSON_PASTE52(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) +#define NLOHMANN_JSON_PASTE53(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE52(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) +#define NLOHMANN_JSON_PASTE54(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE53(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) +#define NLOHMANN_JSON_PASTE55(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE54(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) +#define NLOHMANN_JSON_PASTE56(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE55(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) +#define NLOHMANN_JSON_PASTE57(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE56(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) +#define NLOHMANN_JSON_PASTE58(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE57(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) +#define NLOHMANN_JSON_PASTE59(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE58(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) +#define NLOHMANN_JSON_PASTE60(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE59(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) +#define NLOHMANN_JSON_PASTE61(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE60(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) +#define NLOHMANN_JSON_PASTE62(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE61(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) +#define NLOHMANN_JSON_PASTE63(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE62(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) +#define NLOHMANN_JSON_PASTE64(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE63(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) + +#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1; +#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1); +#define NLOHMANN_JSON_FROM_WITH_DEFAULT(v1) nlohmann_json_t.v1 = !nlohmann_json_j.is_null() ? nlohmann_json_j.value(#v1, nlohmann_json_default_obj.v1) : nlohmann_json_default_obj.v1; + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_INTRUSIVE +@since version 3.9.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT +@since version 3.11.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Type, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE +@since version 3.11.3 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE +@since version 3.9.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT +@since version 3.11.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE +@since version 3.11.3 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(Type, BaseType, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT(Type, BaseType, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, BaseType, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE(Type, BaseType, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, BaseType, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, BaseType, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } + +// inspired from https://stackoverflow.com/a/26745591 +// allows calling any std function as if (e.g., with begin): +// using std::begin; begin(x); +// +// it allows using the detected idiom to retrieve the return type +// of such an expression +#define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name) \ + namespace detail { \ + using std::std_name; \ + \ + template \ + using result_of_##std_name = decltype(std_name(std::declval()...)); \ + } \ + \ + namespace detail2 { \ + struct std_name##_tag \ + { \ + }; \ + \ + template \ + std_name##_tag std_name(T&&...); \ + \ + template \ + using result_of_##std_name = decltype(std_name(std::declval()...)); \ + \ + template \ + struct would_call_std_##std_name \ + { \ + static constexpr auto const value = ::nlohmann::detail:: \ + is_detected_exact::value; \ + }; \ + } /* namespace detail2 */ \ + \ + template \ + struct would_call_std_##std_name : detail2::would_call_std_##std_name \ + { \ + } + +#ifndef JSON_USE_IMPLICIT_CONVERSIONS + #define JSON_USE_IMPLICIT_CONVERSIONS 1 +#endif + +#if JSON_USE_IMPLICIT_CONVERSIONS + #define JSON_EXPLICIT +#else + #define JSON_EXPLICIT explicit +#endif + +#ifndef JSON_DISABLE_ENUM_SERIALIZATION + #define JSON_DISABLE_ENUM_SERIALIZATION 0 +#endif + +#ifndef JSON_USE_GLOBAL_UDLS + #define JSON_USE_GLOBAL_UDLS 1 +#endif + +#if JSON_HAS_THREE_WAY_COMPARISON + #include // partial_ordering +#endif + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/////////////////////////// +// JSON type enumeration // +/////////////////////////// + +/*! +@brief the JSON type enumeration + +This enumeration collects the different JSON types. It is internally used to +distinguish the stored values, and the functions @ref basic_json::is_null(), +@ref basic_json::is_object(), @ref basic_json::is_array(), +@ref basic_json::is_string(), @ref basic_json::is_boolean(), +@ref basic_json::is_number() (with @ref basic_json::is_number_integer(), +@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()), +@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and +@ref basic_json::is_structured() rely on it. + +@note There are three enumeration entries (number_integer, number_unsigned, and +number_float), because the library distinguishes these three types for numbers: +@ref basic_json::number_unsigned_t is used for unsigned integers, +@ref basic_json::number_integer_t is used for signed integers, and +@ref basic_json::number_float_t is used for floating-point numbers or to +approximate integers which do not fit in the limits of their respective type. + +@sa see @ref basic_json::basic_json(const value_t value_type) -- create a JSON +value with the default value for a given type + +@since version 1.0.0 +*/ +enum class value_t : std::uint8_t +{ + null, ///< null value + object, ///< object (unordered set of name/value pairs) + array, ///< array (ordered collection of values) + string, ///< string value + boolean, ///< boolean value + number_integer, ///< number value (signed integer) + number_unsigned, ///< number value (unsigned integer) + number_float, ///< number value (floating-point) + binary, ///< binary array (ordered collection of bytes) + discarded ///< discarded by the parser callback function +}; + +/*! +@brief comparison operator for JSON types + +Returns an ordering that is similar to Python: +- order: null < boolean < number < object < array < string < binary +- furthermore, each type is not smaller than itself +- discarded values are not comparable +- binary is represented as a b"" string in python and directly comparable to a + string; however, making a binary array directly comparable with a string would + be surprising behavior in a JSON file. + +@since version 1.0.0 +*/ +#if JSON_HAS_THREE_WAY_COMPARISON + inline std::partial_ordering operator<=>(const value_t lhs, const value_t rhs) noexcept // *NOPAD* +#else + inline bool operator<(const value_t lhs, const value_t rhs) noexcept +#endif +{ + static constexpr std::array order = {{ + 0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */, + 1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */, + 6 /* binary */ + } + }; + + const auto l_index = static_cast(lhs); + const auto r_index = static_cast(rhs); +#if JSON_HAS_THREE_WAY_COMPARISON + if (l_index < order.size() && r_index < order.size()) + { + return order[l_index] <=> order[r_index]; // *NOPAD* + } + return std::partial_ordering::unordered; +#else + return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index]; +#endif +} + +// GCC selects the built-in operator< over an operator rewritten from +// a user-defined spaceship operator +// Clang, MSVC, and ICC select the rewritten candidate +// (see GCC bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105200) +#if JSON_HAS_THREE_WAY_COMPARISON && defined(__GNUC__) +inline bool operator<(const value_t lhs, const value_t rhs) noexcept +{ + return std::is_lt(lhs <=> rhs); // *NOPAD* +} +#endif + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/*! +@brief replace all occurrences of a substring by another string + +@param[in,out] s the string to manipulate; changed so that all + occurrences of @a f are replaced with @a t +@param[in] f the substring to replace with @a t +@param[in] t the string to replace @a f + +@pre The search string @a f must not be empty. **This precondition is +enforced with an assertion.** + +@since version 2.0.0 +*/ +template +inline void replace_substring(StringType& s, const StringType& f, + const StringType& t) +{ + JSON_ASSERT(!f.empty()); + for (auto pos = s.find(f); // find first occurrence of f + pos != StringType::npos; // make sure f was found + s.replace(pos, f.size(), t), // replace with t, and + pos = s.find(f, pos + t.size())) // find next occurrence of f + {} +} + +/*! + * @brief string escaping as described in RFC 6901 (Sect. 4) + * @param[in] s string to escape + * @return escaped string + * + * Note the order of escaping "~" to "~0" and "/" to "~1" is important. + */ +template +inline StringType escape(StringType s) +{ + replace_substring(s, StringType{"~"}, StringType{"~0"}); + replace_substring(s, StringType{"/"}, StringType{"~1"}); + return s; +} + +/*! + * @brief string unescaping as described in RFC 6901 (Sect. 4) + * @param[in] s string to unescape + * @return unescaped string + * + * Note the order of escaping "~1" to "/" and "~0" to "~" is important. + */ +template +static void unescape(StringType& s) +{ + replace_substring(s, StringType{"~1"}, StringType{"/"}); + replace_substring(s, StringType{"~0"}, StringType{"~"}); +} + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // size_t + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/// struct to capture the start position of the current token +struct position_t +{ + /// the total number of characters read + std::size_t chars_read_total = 0; + /// the number of characters read in the current line + std::size_t chars_read_current_line = 0; + /// the number of lines read + std::size_t lines_read = 0; + + /// conversion to size_t to preserve SAX interface + constexpr operator size_t() const + { + return chars_read_total; + } +}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-FileCopyrightText: 2018 The Abseil Authors +// SPDX-License-Identifier: MIT + + + +#include // array +#include // size_t +#include // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type +#include // index_sequence, make_index_sequence, index_sequence_for + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template +using uncvref_t = typename std::remove_cv::type>::type; + +#ifdef JSON_HAS_CPP_14 + +// the following utilities are natively available in C++14 +using std::enable_if_t; +using std::index_sequence; +using std::make_index_sequence; +using std::index_sequence_for; + +#else + +// alias templates to reduce boilerplate +template +using enable_if_t = typename std::enable_if::type; + +// The following code is taken from https://github.com/abseil/abseil-cpp/blob/10cb35e459f5ecca5b2ff107635da0bfa41011b4/absl/utility/utility.h +// which is part of Google Abseil (https://github.com/abseil/abseil-cpp), licensed under the Apache License 2.0. + +//// START OF CODE FROM GOOGLE ABSEIL + +// integer_sequence +// +// Class template representing a compile-time integer sequence. An instantiation +// of `integer_sequence` has a sequence of integers encoded in its +// type through its template arguments (which is a common need when +// working with C++11 variadic templates). `absl::integer_sequence` is designed +// to be a drop-in replacement for C++14's `std::integer_sequence`. +// +// Example: +// +// template< class T, T... Ints > +// void user_function(integer_sequence); +// +// int main() +// { +// // user_function's `T` will be deduced to `int` and `Ints...` +// // will be deduced to `0, 1, 2, 3, 4`. +// user_function(make_integer_sequence()); +// } +template +struct integer_sequence +{ + using value_type = T; + static constexpr std::size_t size() noexcept + { + return sizeof...(Ints); + } +}; + +// index_sequence +// +// A helper template for an `integer_sequence` of `size_t`, +// `absl::index_sequence` is designed to be a drop-in replacement for C++14's +// `std::index_sequence`. +template +using index_sequence = integer_sequence; + +namespace utility_internal +{ + +template +struct Extend; + +// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency. +template +struct Extend, SeqSize, 0> +{ + using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >; +}; + +template +struct Extend, SeqSize, 1> +{ + using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >; +}; + +// Recursion helper for 'make_integer_sequence'. +// 'Gen::type' is an alias for 'integer_sequence'. +template +struct Gen +{ + using type = + typename Extend < typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type; +}; + +template +struct Gen +{ + using type = integer_sequence; +}; + +} // namespace utility_internal + +// Compile-time sequences of integers + +// make_integer_sequence +// +// This template alias is equivalent to +// `integer_sequence`, and is designed to be a drop-in +// replacement for C++14's `std::make_integer_sequence`. +template +using make_integer_sequence = typename utility_internal::Gen::type; + +// make_index_sequence +// +// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`, +// and is designed to be a drop-in replacement for C++14's +// `std::make_index_sequence`. +template +using make_index_sequence = make_integer_sequence; + +// index_sequence_for +// +// Converts a typename pack into an index sequence of the same length, and +// is designed to be a drop-in replacement for C++14's +// `std::index_sequence_for()` +template +using index_sequence_for = make_index_sequence; + +//// END OF CODE FROM GOOGLE ABSEIL + +#endif + +// dispatch utility (taken from ranges-v3) +template struct priority_tag : priority_tag < N - 1 > {}; +template<> struct priority_tag<0> {}; + +// taken from ranges-v3 +template +struct static_const +{ + static JSON_INLINE_VARIABLE constexpr T value{}; +}; + +#ifndef JSON_HAS_CPP_17 + template + constexpr T static_const::value; +#endif + +template +constexpr std::array make_array(Args&& ... args) +{ + return std::array {{static_cast(std::forward(args))...}}; +} + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // numeric_limits +#include // char_traits +#include // tuple +#include // false_type, is_constructible, is_integral, is_same, true_type +#include // declval + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // random_access_iterator_tag + +// #include + +// #include + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template +struct iterator_types {}; + +template +struct iterator_types < + It, + void_t> +{ + using difference_type = typename It::difference_type; + using value_type = typename It::value_type; + using pointer = typename It::pointer; + using reference = typename It::reference; + using iterator_category = typename It::iterator_category; +}; + +// This is required as some compilers implement std::iterator_traits in a way that +// doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341. +template +struct iterator_traits +{ +}; + +template +struct iterator_traits < T, enable_if_t < !std::is_pointer::value >> + : iterator_types +{ +}; + +template +struct iterator_traits::value>> +{ + using iterator_category = std::random_access_iterator_tag; + using value_type = T; + using difference_type = ptrdiff_t; + using pointer = T*; + using reference = T&; +}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN + +NLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin); + +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN + +NLOHMANN_CAN_CALL_STD_FUNC_IMPL(end); + +NLOHMANN_JSON_NAMESPACE_END + +// #include + +// #include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + +#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_ + #define INCLUDE_NLOHMANN_JSON_FWD_HPP_ + + #include // int64_t, uint64_t + #include // map + #include // allocator + #include // string + #include // vector + + // #include + + + /*! + @brief namespace for Niels Lohmann + @see https://github.com/nlohmann + @since version 1.0.0 + */ + NLOHMANN_JSON_NAMESPACE_BEGIN + + /*! + @brief default JSONSerializer template argument + + This serializer ignores the template arguments and uses ADL + ([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl)) + for serialization. + */ + template + struct adl_serializer; + + /// a class to store JSON values + /// @sa https://json.nlohmann.me/api/basic_json/ + template class ObjectType = + std::map, + template class ArrayType = std::vector, + class StringType = std::string, class BooleanType = bool, + class NumberIntegerType = std::int64_t, + class NumberUnsignedType = std::uint64_t, + class NumberFloatType = double, + template class AllocatorType = std::allocator, + template class JSONSerializer = + adl_serializer, + class BinaryType = std::vector, // cppcheck-suppress syntaxError + class CustomBaseClass = void> + class basic_json; + + /// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document + /// @sa https://json.nlohmann.me/api/json_pointer/ + template + class json_pointer; + + /*! + @brief default specialization + @sa https://json.nlohmann.me/api/json/ + */ + using json = basic_json<>; + + /// @brief a minimal map-like container that preserves insertion order + /// @sa https://json.nlohmann.me/api/ordered_map/ + template + struct ordered_map; + + /// @brief specialization that maintains the insertion order of object keys + /// @sa https://json.nlohmann.me/api/ordered_json/ + using ordered_json = basic_json; + + NLOHMANN_JSON_NAMESPACE_END + +#endif // INCLUDE_NLOHMANN_JSON_FWD_HPP_ + + +NLOHMANN_JSON_NAMESPACE_BEGIN +/*! +@brief detail namespace with internal helper functions + +This namespace collects functions that should not be exposed, +implementations of some @ref basic_json methods, and meta-programming helpers. + +@since version 2.1.0 +*/ +namespace detail +{ + +///////////// +// helpers // +///////////// + +// Note to maintainers: +// +// Every trait in this file expects a non CV-qualified type. +// The only exceptions are in the 'aliases for detected' section +// (i.e. those of the form: decltype(T::member_function(std::declval()))) +// +// In this case, T has to be properly CV-qualified to constraint the function arguments +// (e.g. to_json(BasicJsonType&, const T&)) + +template struct is_basic_json : std::false_type {}; + +NLOHMANN_BASIC_JSON_TPL_DECLARATION +struct is_basic_json : std::true_type {}; + +// used by exceptions create() member functions +// true_type for pointer to possibly cv-qualified basic_json or std::nullptr_t +// false_type otherwise +template +struct is_basic_json_context : + std::integral_constant < bool, + is_basic_json::type>::type>::value + || std::is_same::value > +{}; + +////////////////////// +// json_ref helpers // +////////////////////// + +template +class json_ref; + +template +struct is_json_ref : std::false_type {}; + +template +struct is_json_ref> : std::true_type {}; + +////////////////////////// +// aliases for detected // +////////////////////////// + +template +using mapped_type_t = typename T::mapped_type; + +template +using key_type_t = typename T::key_type; + +template +using value_type_t = typename T::value_type; + +template +using difference_type_t = typename T::difference_type; + +template +using pointer_t = typename T::pointer; + +template +using reference_t = typename T::reference; + +template +using iterator_category_t = typename T::iterator_category; + +template +using to_json_function = decltype(T::to_json(std::declval()...)); + +template +using from_json_function = decltype(T::from_json(std::declval()...)); + +template +using get_template_function = decltype(std::declval().template get()); + +// trait checking if JSONSerializer::from_json(json const&, udt&) exists +template +struct has_from_json : std::false_type {}; + +// trait checking if j.get is valid +// use this trait instead of std::is_constructible or std::is_convertible, +// both rely on, or make use of implicit conversions, and thus fail when T +// has several constructors/operator= (see https://github.com/nlohmann/json/issues/958) +template +struct is_getable +{ + static constexpr bool value = is_detected::value; +}; + +template +struct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +// This trait checks if JSONSerializer::from_json(json const&) exists +// this overload is used for non-default-constructible user-defined-types +template +struct has_non_default_from_json : std::false_type {}; + +template +struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +// This trait checks if BasicJsonType::json_serializer::to_json exists +// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion. +template +struct has_to_json : std::false_type {}; + +template +struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +template +using detect_key_compare = typename T::key_compare; + +template +struct has_key_compare : std::integral_constant::value> {}; + +// obtains the actual object key comparator +template +struct actual_object_comparator +{ + using object_t = typename BasicJsonType::object_t; + using object_comparator_t = typename BasicJsonType::default_object_comparator_t; + using type = typename std::conditional < has_key_compare::value, + typename object_t::key_compare, object_comparator_t>::type; +}; + +template +using actual_object_comparator_t = typename actual_object_comparator::type; + +///////////////// +// char_traits // +///////////////// + +// Primary template of char_traits calls std char_traits +template +struct char_traits : std::char_traits +{}; + +// Explicitly define char traits for unsigned char since it is not standard +template<> +struct char_traits : std::char_traits +{ + using char_type = unsigned char; + using int_type = uint64_t; + + // Redefine to_int_type function + static int_type to_int_type(char_type c) noexcept + { + return static_cast(c); + } + + static char_type to_char_type(int_type i) noexcept + { + return static_cast(i); + } + + static constexpr int_type eof() noexcept + { + return static_cast(std::char_traits::eof()); + } +}; + +// Explicitly define char traits for signed char since it is not standard +template<> +struct char_traits : std::char_traits +{ + using char_type = signed char; + using int_type = uint64_t; + + // Redefine to_int_type function + static int_type to_int_type(char_type c) noexcept + { + return static_cast(c); + } + + static char_type to_char_type(int_type i) noexcept + { + return static_cast(i); + } + + static constexpr int_type eof() noexcept + { + return static_cast(std::char_traits::eof()); + } +}; + +/////////////////// +// is_ functions // +/////////////////// + +// https://en.cppreference.com/w/cpp/types/conjunction +template struct conjunction : std::true_type { }; +template struct conjunction : B { }; +template +struct conjunction +: std::conditional(B::value), conjunction, B>::type {}; + +// https://en.cppreference.com/w/cpp/types/negation +template struct negation : std::integral_constant < bool, !B::value > { }; + +// Reimplementation of is_constructible and is_default_constructible, due to them being broken for +// std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367). +// This causes compile errors in e.g. clang 3.5 or gcc 4.9. +template +struct is_default_constructible : std::is_default_constructible {}; + +template +struct is_default_constructible> + : conjunction, is_default_constructible> {}; + +template +struct is_default_constructible> + : conjunction, is_default_constructible> {}; + +template +struct is_default_constructible> + : conjunction...> {}; + +template +struct is_default_constructible> + : conjunction...> {}; + +template +struct is_constructible : std::is_constructible {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_iterator_traits : std::false_type {}; + +template +struct is_iterator_traits> +{ + private: + using traits = iterator_traits; + + public: + static constexpr auto value = + is_detected::value && + is_detected::value && + is_detected::value && + is_detected::value && + is_detected::value; +}; + +template +struct is_range +{ + private: + using t_ref = typename std::add_lvalue_reference::type; + + using iterator = detected_t; + using sentinel = detected_t; + + // to be 100% correct, it should use https://en.cppreference.com/w/cpp/iterator/input_or_output_iterator + // and https://en.cppreference.com/w/cpp/iterator/sentinel_for + // but reimplementing these would be too much work, as a lot of other concepts are used underneath + static constexpr auto is_iterator_begin = + is_iterator_traits>::value; + + public: + static constexpr bool value = !std::is_same::value && !std::is_same::value && is_iterator_begin; +}; + +template +using iterator_t = enable_if_t::value, result_of_begin())>>; + +template +using range_value_t = value_type_t>>; + +// The following implementation of is_complete_type is taken from +// https://blogs.msdn.microsoft.com/vcblog/2015/12/02/partial-support-for-expression-sfinae-in-vs-2015-update-1/ +// and is written by Xiang Fan who agreed to using it in this library. + +template +struct is_complete_type : std::false_type {}; + +template +struct is_complete_type : std::true_type {}; + +template +struct is_compatible_object_type_impl : std::false_type {}; + +template +struct is_compatible_object_type_impl < + BasicJsonType, CompatibleObjectType, + enable_if_t < is_detected::value&& + is_detected::value >> +{ + using object_t = typename BasicJsonType::object_t; + + // macOS's is_constructible does not play well with nonesuch... + static constexpr bool value = + is_constructible::value && + is_constructible::value; +}; + +template +struct is_compatible_object_type + : is_compatible_object_type_impl {}; + +template +struct is_constructible_object_type_impl : std::false_type {}; + +template +struct is_constructible_object_type_impl < + BasicJsonType, ConstructibleObjectType, + enable_if_t < is_detected::value&& + is_detected::value >> +{ + using object_t = typename BasicJsonType::object_t; + + static constexpr bool value = + (is_default_constructible::value && + (std::is_move_assignable::value || + std::is_copy_assignable::value) && + (is_constructible::value && + std::is_same < + typename object_t::mapped_type, + typename ConstructibleObjectType::mapped_type >::value)) || + (has_from_json::value || + has_non_default_from_json < + BasicJsonType, + typename ConstructibleObjectType::mapped_type >::value); +}; + +template +struct is_constructible_object_type + : is_constructible_object_type_impl {}; + +template +struct is_compatible_string_type +{ + static constexpr auto value = + is_constructible::value; +}; + +template +struct is_constructible_string_type +{ + // launder type through decltype() to fix compilation failure on ICPC +#ifdef __INTEL_COMPILER + using laundered_type = decltype(std::declval()); +#else + using laundered_type = ConstructibleStringType; +#endif + + static constexpr auto value = + conjunction < + is_constructible, + is_detected_exact>::value; +}; + +template +struct is_compatible_array_type_impl : std::false_type {}; + +template +struct is_compatible_array_type_impl < + BasicJsonType, CompatibleArrayType, + enable_if_t < + is_detected::value&& + is_iterator_traits>>::value&& +// special case for types like std::filesystem::path whose iterator's value_type are themselves +// c.f. https://github.com/nlohmann/json/pull/3073 + !std::is_same>::value >> +{ + static constexpr bool value = + is_constructible>::value; +}; + +template +struct is_compatible_array_type + : is_compatible_array_type_impl {}; + +template +struct is_constructible_array_type_impl : std::false_type {}; + +template +struct is_constructible_array_type_impl < + BasicJsonType, ConstructibleArrayType, + enable_if_t::value >> + : std::true_type {}; + +template +struct is_constructible_array_type_impl < + BasicJsonType, ConstructibleArrayType, + enable_if_t < !std::is_same::value&& + !is_compatible_string_type::value&& + is_default_constructible::value&& +(std::is_move_assignable::value || + std::is_copy_assignable::value)&& +is_detected::value&& +is_iterator_traits>>::value&& +is_detected::value&& +// special case for types like std::filesystem::path whose iterator's value_type are themselves +// c.f. https://github.com/nlohmann/json/pull/3073 +!std::is_same>::value&& +is_complete_type < +detected_t>::value >> +{ + using value_type = range_value_t; + + static constexpr bool value = + std::is_same::value || + has_from_json::value || + has_non_default_from_json < + BasicJsonType, + value_type >::value; +}; + +template +struct is_constructible_array_type + : is_constructible_array_type_impl {}; + +template +struct is_compatible_integer_type_impl : std::false_type {}; + +template +struct is_compatible_integer_type_impl < + RealIntegerType, CompatibleNumberIntegerType, + enable_if_t < std::is_integral::value&& + std::is_integral::value&& + !std::is_same::value >> +{ + // is there an assert somewhere on overflows? + using RealLimits = std::numeric_limits; + using CompatibleLimits = std::numeric_limits; + + static constexpr auto value = + is_constructible::value && + CompatibleLimits::is_integer && + RealLimits::is_signed == CompatibleLimits::is_signed; +}; + +template +struct is_compatible_integer_type + : is_compatible_integer_type_impl {}; + +template +struct is_compatible_type_impl: std::false_type {}; + +template +struct is_compatible_type_impl < + BasicJsonType, CompatibleType, + enable_if_t::value >> +{ + static constexpr bool value = + has_to_json::value; +}; + +template +struct is_compatible_type + : is_compatible_type_impl {}; + +template +struct is_constructible_tuple : std::false_type {}; + +template +struct is_constructible_tuple> : conjunction...> {}; + +template +struct is_json_iterator_of : std::false_type {}; + +template +struct is_json_iterator_of : std::true_type {}; + +template +struct is_json_iterator_of : std::true_type +{}; + +// checks if a given type T is a template specialization of Primary +template