diff --git a/.github/workflows/presubmit.yml b/.github/workflows/presubmit.yml index ef82b6ec..1e9a4d31 100644 --- a/.github/workflows/presubmit.yml +++ b/.github/workflows/presubmit.yml @@ -28,8 +28,16 @@ jobs: submodules: recursive - name: Build run: | - mkdir build - cd build + if [[ "${{ matrix.os }}" == "ubuntu-20.04" ]]; then + sudo apt update + sudo apt install -y libtclap-dev libglm-dev libglew-dev libsfml-dev libstb-dev libidn11 libx11-dev libxrandr-dev libxi-dev mesa-common-dev libgl1-mesa-dev libglu1-mesa-dev libudev-dev + elif [[ "${{ matrix.os }}" == "macos-latest" ]]; then + brew install tclap glm glew sfml mesa-glu + git clone https://github.com/Microsoft/vcpkg.git + ./vcpkg/bootstrap-vcpkg.sh + ./vcpkg/vcpkg install stb + TOOLCHAIN_ARG="-D CMAKE_TOOLCHAIN_FILE=./vcpkg/scripts/buildsystems/vcpkg.cmake" + fi if [[ "${{ matrix.compiler }}" == "gcc" ]]; then CC=gcc CXX=g++ @@ -37,8 +45,8 @@ jobs: CC=clang CXX=clang++ fi - cmake -DCMAKE_C_COMPILER=$CC -DCMAKE_CXX_COMPILER=$CXX ../ - make -j2 VERBOSE=1 + cmake -D CMAKE_C_COMPILER=$CC -D CMAKE_CXX_COMPILER=$CXX $TOOLCHAIN_ARG -S . -B build + cmake --build ./build --verbose --parallel 2 buildwin: needs: format name: Build Windows @@ -50,10 +58,11 @@ jobs: submodules: recursive - name: Build run: | - mkdir build - cd build - cmake ../ - cmake --build . + git clone https://github.com/Microsoft/vcpkg.git + .\vcpkg\bootstrap-vcpkg.bat + .\vcpkg\vcpkg.exe --triplet=x64-windows install sfml tclap glm glew stb + cmake -D CMAKE_TOOLCHAIN_FILE=.\vcpkg\scripts\buildsystems\vcpkg.cmake -S . -B build + cmake --build ./build -- /verbosity:minimal /maxCpuCount /noLogo python: name: Exercise Python examples on ${{matrix.os}} diff --git a/.gitignore b/.gitignore index 8598c422..adacb9e4 100644 --- a/.gitignore +++ b/.gitignore @@ -4,3 +4,4 @@ install/ # vim *~ .*.sw[op] +.vscode diff --git a/.gitlab/ubuntu-18.04-rocm.Dockerfile b/.gitlab/ubuntu-18.04-rocm.Dockerfile new file mode 100644 index 00000000..d17ef498 --- /dev/null +++ b/.gitlab/ubuntu-18.04-rocm.Dockerfile @@ -0,0 +1,10 @@ +FROM streamhpc/opencl-sdk-base:ubuntu-18.04-20211119 +RUN set -ex; \ + export DEBIAN_FRONTEND=noninteractive ; \ +# Register ROCm APT repo + wget --quiet --recursive --no-directories --no-parent "https://repo.radeon.com/amdgpu-install/latest/ubuntu/bionic/" --accept "amdgpu-install-*_all.deb" ; \ + apt install -y -qq ./amdgpu-install-*_all.deb libnuma-dev initramfs-tools ; \ + apt update -qq; \ + rm ./amdgpu-install-*_all.deb ; \ +# Install OpenCL package only (and dependency) + amdgpu-install -y --usecase=opencl \ No newline at end of file diff --git a/.gitlab/ubuntu-18.04.Dockerfile b/.gitlab/ubuntu-18.04.Dockerfile new file mode 100644 index 00000000..04869a8a --- /dev/null +++ b/.gitlab/ubuntu-18.04.Dockerfile @@ -0,0 +1,45 @@ +FROM ubuntu:18.04 AS apt-installs +RUN set -ex; \ + export DEBIAN_FRONTEND=noninteractive ; \ + apt update -qq; \ +# install wget to download repository keys and CMake tarballs +# install software-properties-common for the apt-add-repository command + apt install -y -qq wget software-properties-common ; \ +# Canonical hosts recent GCC compilers in ubuntu-toolchain-r/test + apt-add-repository -y ppa:ubuntu-toolchain-r/test ; \ +# LLVM hosts most toolchain in separate repos. We only register those absent from ubuntu-toolchain-r/test + wget -q -O - https://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add - ; \ + apt-add-repository -y 'deb [arch=amd64] https://apt.llvm.org/bionic/ llvm-toolchain-bionic-11 main' ; \ + apt-add-repository -y 'deb [arch=amd64] https://apt.llvm.org/bionic/ llvm-toolchain-bionic-12 main' ; \ + apt-add-repository -y 'deb [arch=amd64] https://apt.llvm.org/bionic/ llvm-toolchain-bionic-13 main' ; \ +# install ninja, GCC 7-10, LLVM 8-13 and build-essential to get linkers, etc. +# install git to download dependencies +# install ruby to run CMock +# install libidn11 which CMake 3.1.3 only depends on +# install ca-certificates to `git clone` via HTTPS +# install SFML dependencies +# libx11-dev libxrandr-dev libxi-dev +# mesa-common-dev for gl.h +# libgl1-mesa-dev for libGL.so +# libglu1-mesa-dev for glu.h +# libudev-dev +# install Vcpkg dependencies +# curl zip unzip tar + apt install -y -qq build-essential g++-7 g++-8 g++-9 g++-10 clang-8 clang-9 clang-10 clang-11 clang-12 clang-13 ninja-build git ruby libidn11 ca-certificates libx11-dev libxrandr-dev libxi-dev mesa-common-dev libgl1-mesa-dev libglu1-mesa-dev libudev-dev curl zip unzip tar + +# install CMake minimum (3.0.2 (Headers, ICD Loader), 3.1.3 (CLHPP), 3.10.3 (SDK)) and latest (3.21.2) +RUN mkdir -p /opt/Kitware/CMake ; \ + wget -c https://github.com/Kitware/CMake/releases/download/v3.0.2/cmake-3.0.2-Linux-i386.tar.gz -O - | tar -xz --directory /opt/Kitware/CMake ; \ + mv /opt/Kitware/CMake/cmake-3.0.2-Linux-i386 /opt/Kitware/CMake/3.0.2 ; \ + wget -c https://github.com/Kitware/CMake/releases/download/v3.1.3/cmake-3.1.3-Linux-x86_64.tar.gz -O - | tar -xz --directory /opt/Kitware/CMake ; \ + mv /opt/Kitware/CMake/cmake-3.1.3-Linux-x86_64 /opt/Kitware/CMake/3.1.3 ; \ + wget -c https://github.com/Kitware/CMake/releases/download/v3.10.3/cmake-3.10.3-Linux-x86_64.tar.gz -O - | tar -xz --directory /opt/Kitware/CMake ; \ + mv /opt/Kitware/CMake/cmake-3.10.3-Linux-x86_64 /opt/Kitware/CMake/3.10.3 ; \ + wget -c https://github.com/Kitware/CMake/releases/download/v3.21.2/cmake-3.21.2-linux-x86_64.tar.gz -O - | tar -xz --directory /opt/Kitware/CMake ; \ + mv /opt/Kitware/CMake/cmake-3.21.2-linux-x86_64 /opt/Kitware/CMake/3.21.2 + +# install Vcpkg +RUN git clone --depth 1 https://github.com/Microsoft/vcpkg.git /opt/Microsoft/vcpkg ; \ + /opt/Microsoft/vcpkg/bootstrap-vcpkg.sh ; \ +# install SFML, TCLAP, GLM + /opt/Microsoft/vcpkg/vcpkg install sfml tclap glm glew \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt index 8e765948..2aca2aad 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -14,29 +14,91 @@ cmake_minimum_required(VERSION 3.0) -set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_STANDARD 14) -project(OpenCL-SDK) +project(OpenCL-SDK + VERSION 1.0 + LANGUAGES + C CXX +) + +include(CMakeDependentOption) +option(OPENCL_SDK_BUILD_SAMPLES "Build sample code" ON) +cmake_dependent_option(OPENCL_SDK_BUILD_OPENGL_SAMPLES "Build OpenCL-OpenGL interop sample code" ON OPENCL_SDK_BUILD_SAMPLES OFF) +cmake_dependent_option(OPENCL_SDK_TEST_SAMPLES "Add CTest to samples (where applicable)" ON OPENCL_SDK_BUILD_SAMPLES OFF) + +include(CTest) if (NOT CMAKE_BUILD_TYPE) message(STATUS "No build type selected, default to Release") set(CMAKE_BUILD_TYPE "Release" CACHE PATH "Build Type" FORCE) endif() -set(OPENCL_ICD_LOADER_HEADERS_DIR - "${PROJECT_SOURCE_DIR}/external/OpenCL-Headers" CACHE PATH "Path to OpenCL - Headers") - if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) set(CMAKE_INSTALL_PREFIX "${PROJECT_SOURCE_DIR}/install" CACHE PATH "Install Path" FORCE) endif() -set(OPENCL_SDK_INCLUDE_DIRS - "${PROJECT_SOURCE_DIR}/external/OpenCL-Headers" - "${PROJECT_SOURCE_DIR}/external/OpenCL-CLHPP/include") +add_subdirectory(external/OpenCL-Headers) +add_subdirectory(external/OpenCL-ICD-Loader) +add_subdirectory(external/OpenCL-CLHPP) + +if(OPENCL_SDK_BUILD_SAMPLES) + list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake/Modules) + add_subdirectory(third_party/cargs) + find_package(TCLAP REQUIRED) + find_package(Stb REQUIRED) + if(OPENCL_SDK_BUILD_OPENGL_SAMPLES) + cmake_minimum_required(VERSION 3.10) # SFML 2 won't find Freetype::Freetype under 3.10 + find_package(OpenGL REQUIRED) + if(CMAKE_SYSTEM_NAME MATCHES Linux) # TODO: Add EGL support + # OpenGL doesn't explicitly depend on X11 (as of CMake v3.2) but we'll need it + find_package(X11 REQUIRED) + endif() + find_package(GLEW REQUIRED) + if(NOT TARGET OpenGL::GLU) + # GLU is a dependency of GLEW but it's not advertized as an OpenGL COMPONENT + message(FATAL_ERROR "GLEW depends on GLU but was not found.") + endif() + find_package(SFML 2 + REQUIRED + COMPONENTS window graphics + ) + find_package(GLEW REQUIRED) + find_package(glm CONFIG REQUIRED) + endif(OPENCL_SDK_BUILD_OPENGL_SAMPLES) +endif(OPENCL_SDK_BUILD_SAMPLES) + +add_subdirectory(lib) +if(OPENCL_SDK_BUILD_SAMPLES) + add_subdirectory(samples) +endif() -add_subdirectory(${PROJECT_SOURCE_DIR}/external/OpenCL-ICD-Loader) -add_subdirectory(${PROJECT_SOURCE_DIR}/samples) +include(GNUInstallDirs) +file( + WRITE ${PROJECT_BINARY_DIR}/OpenCL/OpenCLConfig.cmake + [[ +get_filename_component(PARENT_DIR ${CMAKE_CURRENT_LIST_DIR} PATH) +include("${PARENT_DIR}/OpenCLHeaders/OpenCLHeadersConfig.cmake") +include("${PARENT_DIR}/OpenCLICDLoader/OpenCLICDLoaderConfig.cmake") +include("${PARENT_DIR}/OpenCLHeadersCpp/OpenCLHeadersCppConfig.cmake") +include("${PARENT_DIR}/OpenCLUtils/OpenCLUtilsConfig.cmake") +include("${PARENT_DIR}/OpenCLUtilsCpp/OpenCLUtilsCppConfig.cmake") + ]] +) +set(config_package_location ${CMAKE_INSTALL_DATADIR}/cmake/OpenCL) +install( + FILES ${PROJECT_BINARY_DIR}/OpenCL/OpenCLConfig.cmake + DESTINATION ${config_package_location} +) -set_target_properties(OpenCL PROPERTIES LIBRARY_OUTPUT_DIRECTORY - ${CMAKE_CURRENT_BINARY_DIR}) +unset(CMAKE_SIZEOF_VOID_P) +include(CMakePackageConfigHelpers) +write_basic_package_version_file( + ${CMAKE_CURRENT_BINARY_DIR}/OpenCL/OpenCLConfigVersion.cmake + VERSION ${PROJECT_VERSION} + COMPATIBILITY AnyNewerVersion +) +install( + FILES ${CMAKE_CURRENT_BINARY_DIR}/OpenCL/OpenCLConfigVersion.cmake + DESTINATION ${config_package_location} +) diff --git a/README.md b/README.md index 4aead069..663bcd8c 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -# OpenCL-SDK (in development) +# OpenCLTM SDK (in development) This is the Khronos OpenCL SDK. It brings together all the components needed to develop OpenCL applications: @@ -13,40 +13,57 @@ It also contains resources useful to OpenCL developers: - Code samples (`samples/`) - Documentation (`docs/`) -## Setting Up the SDK +## Build Instructions -This repository uses sub-modules for the OpenCL Headers, OpenCL C++ bindings, and OpenCL ICD Loader. +### Dependencies -To clone a new repository with all sub-modules included, use the `--recursive` option. -Note that this option clones all sub-modules and their dependencies, which are not required for the OpenCL SDK: +- This repository uses sub-modules for the OpenCL Headers, OpenCL C++ bindings, and OpenCL ICD Loader and some of their transitive dependencies. -```sh -$ git clone --recursive https://github.com/KhronosGroup/OpenCL-SDK.git -``` + - To clone a new repository with all sub-modules included, use the `--recursive` option. Note that this option clones all sub-modules and their dependencies, which are not strictly required for the OpenCL SDK: -Alternatively, to clone only the sub-modules for the OpenCL SDK, first clone this repository without sub-modules included: + git clone --recursive https://github.com/KhronosGroup/OpenCL-SDK.git -```sh -$ git clone https://github.com/KhronosGroup/OpenCL-SDK.git -``` + - Alternatively, to clone only the sub-modules for the OpenCL SDK, first clone this repository without sub-modules included then setup submodules non-recursively: -Then setup sub-modules: + git clone https://github.com/KhronosGroup/OpenCL-SDK.git + git submodule init + git submodule update -```sh -$ git submodule init -$ git submodule update -``` +- The SDK uses CMake for its build system. +If CMake is not provided by your build system or OS package manager, please consult the [CMake website](https://cmake.org). -## Building the Samples +- The SDK samples depend on -This repository uses CMake as its build system. -The suggested build directory is `build`. + - [Templatized C++ Command Line Parser Library](http://tclap.sourceforge.net/) (aka. TCLAP) + - [Simple and Fast Multimedia Library](https://www.sfml-dev.org/) (aka. SFML) + - [OpenGL Mathematics](https://glm.g-truc.net/0.9.9/index.html) (aka. GLM) -To generate build files, use for example: +### Example Build -```sh -$ mkdir build && cd build -$ cmake .. -``` +> The example build guide uses [Vcpkg](https://vcpkg.io/en/index.html) to fetch all dependencies. Note that Vcpkg is _not_ a requirement and is only used for convenience. One may provide dependencies through any other CMake mechanism. For details on how to install Vcpkg, refer to it's [Getting Started Guide](https://vcpkg.io/en/getting-started.html). The example build assumes targeting 64-bit Windows. -Then build with the generated build files. +1. Clone this repo with the rest of the OpenCL SDK components: + + git clone https://github.com/KhronosGroup/OpenCL-SDK.git + git submodule init + git submodule update + +1. Install dependencies + + vcpkg --triplet x64-windows install sfml tclap glm + +1. Build and install SDK with samples and no downstream unit tests + + cmake -A x64 ` + -D BUILD_TESTING=OFF ` + -D BUILD_DOCS=OFF ` + -D BUILD_EXAMPLES=OFF ` + -D BUILD_TESTS=OFF ` + -D OPENCL_SDK_BUILD_SAMPLES=ON ` + -D OPENCL_SDK_TEST_SAMPLES=OFF ` + -D CMAKE_TOOLCHAIN_FILE=/vcpkg/install/root/scripts/buildsystems/vcpkg.cmake ` + -D VCPKG_TARGET_TRIPLET=x64-windows + -B ./OpenCL-SDK/build -S ./OpenCL-SDK + cmake --build ./OpenCL-SDK/build --target install + +_(Note: on Linux paths to dependent libraries are automatically handled by RPATH in both the build and install tree. On Windows all DLLs have to be on the `PATH`. Vcpkg copies dependent DLLs to the build tree, but in order to do the same in the install tree, sufficiently new CMake version is required. CMake 3.21 instroduces `install(IMPORTED_RUNTIME_ARTIFACTS)`.)_ \ No newline at end of file diff --git a/cmake/Modules/FindStb.cmake b/cmake/Modules/FindStb.cmake new file mode 100644 index 00000000..0a4886e5 --- /dev/null +++ b/cmake/Modules/FindStb.cmake @@ -0,0 +1,30 @@ +# - Find Stb +# Find the Stb headers +# +# Stb_INCLUDE_DIR - where to find the TCLAP headers +# Stb_FOUND - True if TCLAP is found + +if (Stb_INCLUDE_DIR) + # already in cache, be silent + set (Stb_FIND_QUIETLY TRUE) +endif (Stb_INCLUDE_DIR) + +# find the headers +find_path (Stb_INCLUDE_PATH stb_image.h + PATHS + ${Stb_DIR} + PATH_SUFFIXES + include + include/stb + ) + +# handle the QUIETLY and REQUIRED arguments and set Stb_FOUND to +# TRUE if all listed variables are TRUE +include (FindPackageHandleStandardArgs) +find_package_handle_standard_args (Stb "Stb (https://github.com/nothings/stb) could not be found. Set Stb_INCLUDE_PATH to point to the headers adding '-D Stb_INCLUDE_PATH=/path/to/stb' to the cmake command." Stb_INCLUDE_PATH) + +if (Stb_FOUND) + set (Stb_INCLUDE_DIR ${Stb_INCLUDE_PATH}) +endif (Stb_FOUND) + +mark_as_advanced(Stb_INCLUDE_PATH) diff --git a/cmake/Modules/FindTCLAP.cmake b/cmake/Modules/FindTCLAP.cmake new file mode 100644 index 00000000..781450a2 --- /dev/null +++ b/cmake/Modules/FindTCLAP.cmake @@ -0,0 +1,28 @@ +# - Find TCLAP +# Find the TCLAP headers +# +# TCLAP_INCLUDE_DIR - where to find the TCLAP headers +# TCLAP_FOUND - True if TCLAP is found + +if (TCLAP_INCLUDE_DIR) + # already in cache, be silent + set (TCLAP_FIND_QUIETLY TRUE) +endif (TCLAP_INCLUDE_DIR) + +# find the headers +find_path (TCLAP_INCLUDE_PATH tclap/CmdLine.h + PATHS + ${CMAKE_SOURCE_DIR}/include + ${CMAKE_INSTALL_PREFIX}/include + ) + +# handle the QUIETLY and REQUIRED arguments and set TCLAP_FOUND to +# TRUE if all listed variables are TRUE +include (FindPackageHandleStandardArgs) +find_package_handle_standard_args (TCLAP "TCLAP (http://tclap.sourceforge.net/) could not be found. Set TCLAP_INCLUDE_PATH to point to the headers adding '-DTCLAP_INCLUDE_PATH=/path/to/tclap' to the cmake command." TCLAP_INCLUDE_PATH) + +if (TCLAP_FOUND) + set (TCLAP_INCLUDE_DIR ${TCLAP_INCLUDE_PATH}) +endif (TCLAP_FOUND) + +mark_as_advanced(TCLAP_INCLUDE_PATH) diff --git a/external/OpenCL-CLHPP b/external/OpenCL-CLHPP index 1df82b97..62d36e41 160000 --- a/external/OpenCL-CLHPP +++ b/external/OpenCL-CLHPP @@ -1 +1 @@ -Subproject commit 1df82b9749739f2681081092ae163bb0f0d40f66 +Subproject commit 62d36e41275d12ec1220f68abb8fe66d12306c45 diff --git a/external/OpenCL-Headers b/external/OpenCL-Headers index 59ac4dc2..80c10b1f 160000 --- a/external/OpenCL-Headers +++ b/external/OpenCL-Headers @@ -1 +1 @@ -Subproject commit 59ac4dc2f282286d8db83143686cfe37ec658b84 +Subproject commit 80c10b1f65b932894b830da7cd37bc56c541bae4 diff --git a/external/OpenCL-ICD-Loader b/external/OpenCL-ICD-Loader index 169f05d0..b7a648b2 160000 --- a/external/OpenCL-ICD-Loader +++ b/external/OpenCL-ICD-Loader @@ -1 +1 @@ -Subproject commit 169f05d026e65948b30cfe2200595fda92198cf7 +Subproject commit b7a648b2702e5484725163dcb99a3960370807b5 diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt new file mode 100644 index 00000000..8a52459f --- /dev/null +++ b/lib/CMakeLists.txt @@ -0,0 +1,214 @@ +include(GenerateExportHeader) +include(GNUInstallDirs) + +foreach(UTIL_LIB_NAME IN ITEMS Utils UtilsCpp) + if(UTIL_LIB_NAME STREQUAL Utils) + set(UTIL_LIB_SOURCES src/Utils/Utils.c) + set(UTIL_LIB_DEPS + OpenCL::Headers + $<$:m> + ) + set(UTIL_CL_VERSION_MACRO_NAME CL_TARGET_OPENCL_VERSION) + elseif(UTIL_LIB_NAME STREQUAL UtilsCpp) + set(UTIL_LIB_SOURCES src/Utils/Utils.cpp) + set(UTIL_LIB_DEPS + OpenCL::HeadersCpp + OpenCL::Utils + ) + set(UTIL_CL_VERSION_MACRO_NAME CL_HPP_TARGET_OPENCL_VERSION) + else() + message(FATAL_ERROR "Unkown Util flavor") + endif() + set(UTIL_LIB_TARGET OpenCL${UTIL_LIB_NAME}) + add_library(${UTIL_LIB_TARGET} ${UTIL_LIB_SOURCES}) + add_library(OpenCL::${UTIL_LIB_NAME} ALIAS ${UTIL_LIB_TARGET}) + + string(TOUPPER ${UTIL_LIB_NAME} UPPER_UTIL_LIB_NAME) + generate_export_header(${UTIL_LIB_TARGET} + EXPORT_MACRO_NAME ${UPPER_UTIL_LIB_NAME}_EXPORT + EXPORT_FILE_NAME OpenCL${UTIL_LIB_NAME}_Export.h + ) + + target_include_directories(${UTIL_LIB_TARGET} + PUBLIC + $ + $ + $ + ) + target_link_libraries(${UTIL_LIB_TARGET} + PUBLIC + ${UTIL_LIB_DEPS} + OpenCL::OpenCL + ) + target_compile_definitions(${UTIL_LIB_TARGET} + PRIVATE + ${UTIL_CL_VERSION_MACRO_NAME}=300 + PUBLIC + CL_HPP_ENABLE_EXCEPTIONS + ) + + set_target_properties(${UTIL_LIB_TARGET} + PROPERTIES + ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR} + LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR} + RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_BINDIR} + INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}" + FOLDER "Libraries/${UTIL_LIB_NAME}" + ) + + install( + TARGETS ${UTIL_LIB_TARGET} + EXPORT OpenCL${UTIL_LIB_NAME}Targets + ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} + RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} + ) + install( + DIRECTORY include/CL/Utils + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/CL + ) + export( + EXPORT OpenCL${UTIL_LIB_NAME}Targets + FILE ${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_DATADIR}/cmake/OpenCL${UTIL_LIB_NAME}/OpenCL${UTIL_LIB_NAME}Targets.cmake + NAMESPACE OpenCL:: + ) + file( + WRITE ${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_DATADIR}/cmake/OpenCL${UTIL_LIB_NAME}/OpenCL${UTIL_LIB_NAME}Config.cmake + "include(\"\${CMAKE_CURRENT_LIST_DIR}/OpenCL${UTIL_LIB_NAME}Targets.cmake\")" + ) + + set(config_package_location ${CMAKE_INSTALL_DATADIR}/cmake/OpenCL${UTIL_LIB_NAME}) + install( + EXPORT OpenCL${UTIL_LIB_NAME}Targets + FILE OpenCL${UTIL_LIB_NAME}Targets.cmake + NAMESPACE OpenCL:: + DESTINATION ${config_package_location} + ) + install( + FILES ${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_DATADIR}/cmake/OpenCL${UTIL_LIB_NAME}/OpenCL${UTIL_LIB_NAME}Config.cmake + DESTINATION ${config_package_location} + ) + + unset(CMAKE_SIZEOF_VOID_P) + include(CMakePackageConfigHelpers) + write_basic_package_version_file( + ${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_DATADIR}/cmake/OpenCL${UTIL_LIB_NAME}/OpenCL${UTIL_LIB_NAME}ConfigVersion.cmake + VERSION ${PROJECT_VERSION} + COMPATIBILITY AnyNewerVersion + ) + install( + FILES ${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_DATADIR}/cmake/OpenCL${UTIL_LIB_NAME}/OpenCL${UTIL_LIB_NAME}ConfigVersion.cmake + DESTINATION ${config_package_location} + ) +endforeach() + +if(OPENCL_SDK_BUILD_SAMPLES) + foreach(SDK_LIB_NAME IN ITEMS SDK SDKCpp) + if(SDK_LIB_NAME STREQUAL SDK) + set(SDK_LIB_SOURCES src/SDK/SDK.c) + set(SDK_LIB_DEPS + OpenCL::Headers + OpenCL::Utils + cargs + ) + set(SDK_LIB_INCLUDES + ${Stb_INCLUDE_DIR} + ) + set(SDK_CL_VERSION_MACRO_NAME CL_TARGET_OPENCL_VERSION) + elseif(SDK_LIB_NAME STREQUAL SDKCpp) + set(SDK_LIB_SOURCES + src/SDK/CLI.cpp + src/SDK/Image.cpp + $<$:src/SDK/InteropContext.cpp> + $<$:src/SDK/InteropWindow.cpp> + ) + set(SDK_LIB_DEPS + OpenCL::HeadersCpp + OpenCL::UtilsCpp + $<$:OpenGL::GL> + $<$:GLEW::GLEW> + $<$,$>:OpenGL::GLU> + $<$:sfml-system> + $<$:sfml-window> + $<$:sfml-graphics> + ) + set(SDK_LIB_INCLUDES + ${TCLAP_INCLUDE_DIR} + ${Stb_INCLUDE_DIR} + ) + set(SDK_CL_VERSION_MACRO_NAME CL_HPP_TARGET_OPENCL_VERSION) + else() + message(FATAL_ERROR "Unkown SDK flavor") + endif() + + set(SDK_LIB_TARGET OpenCL${SDK_LIB_NAME}) + add_library(${SDK_LIB_TARGET} ${SDK_LIB_SOURCES}) + add_library(OpenCL::${SDK_LIB_NAME} ALIAS ${SDK_LIB_TARGET}) + + string(TOUPPER ${SDK_LIB_NAME} UPPER_SDK_LIB_NAME) + generate_export_header(${SDK_LIB_TARGET} + EXPORT_MACRO_NAME ${UPPER_SDK_LIB_NAME}_EXPORT + EXPORT_FILE_NAME OpenCL${SDK_LIB_NAME}_Export.h + ) + configure_file( + include/CL/SDK/OpenCLSDK_Config.in.h + ${CMAKE_CURRENT_BINARY_DIR}/OpenCLSDK_Config.h + ) + + target_include_directories(${SDK_LIB_TARGET} + PUBLIC + ${SDK_LIB_INCLUDES} + $ + $ + $ + ) + target_link_libraries(${SDK_LIB_TARGET} + PUBLIC + ${SDK_LIB_DEPS} + OpenCL::OpenCL + ) + target_compile_definitions(${SDK_LIB_TARGET} + PRIVATE + ${SDK_CL_VERSION_MACRO_NAME}=300 + PUBLIC + CL_HPP_ENABLE_EXCEPTIONS + ) + + set_target_properties(${SDK_LIB_TARGET} + PROPERTIES + ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR} + LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR} + RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_BINDIR} + INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}" + FOLDER "Libraries/${SDK_LIB_TARGET}" + ) + install( + TARGETS ${SDK_LIB_TARGET} + RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} + ) + # Copying DLLs the samples depend on only makes sense on Wnidows. On *nix + # OSes we rely on RPATH. We can only do this with sufficiently new CMake. + if( + OPENCL_SDK_BUILD_OPENGL_SAMPLES AND + CMAKE_VERSION VERSION_GREATER_EQUAL 3.21 AND + CMAKE_SYSTEM_NAME MATCHES Windows + ) + foreach(DEP IN ITEMS + GLEW::GLEW + sfml-window + sfml-graphics + sfml-system + ) + get_target_property(DEP_TYPE ${DEP} TYPE) + if(${DEP_TYPE} STREQUAL SHARED_LIBRARY) + install( + IMPORTED_RUNTIME_ARTIFACTS + ${DEP} + RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} + ) + endif() + endforeach() + endif() + endforeach() +endif(OPENCL_SDK_BUILD_SAMPLES) diff --git a/lib/README.md b/lib/README.md new file mode 100644 index 00000000..8fb015da --- /dev/null +++ b/lib/README.md @@ -0,0 +1,15 @@ +# OpenCL Utility and OpenCL SDK Library Documentation + +There are two libraries in the OpenCL SDK which all samples utilize to different extents. One such library is the OpenCL Utility Library which is an exported library and is meant to ease the use of OpenCL, while the OpenCL SDK Library builds on top of it but is not exported when installing the SDK. The OpenCL SDK lib extends the Utility library in ways which likely don't make sense outside the context of the SDK samples. + +## OpenCL Utility Library + +One may think of this library as analogous to GLU and GLUT in the domain of OpenGL. A set of utilities which condense common tasks into singular functions or add missing functionality of the API which otherwise couldn't be added as a non-API-breaking change. + +For a complete list utilities provided by this library, refer to the [OpenCL Utility Library docs](./Utils.md). + +## OpenCL SDK Library + +The SDK library extends the Utility library by deduplicating common tasks like command-line argument parsing, selecting devices, logging, and other contentious tasks which your application likely does differently, hence the value in shipping it for external use, moreover promise forward and/or backward compatibility is low. + +For a complete list functionality provided by this library, refer to the [OpenCL SDK Library docs](./SDK.md). \ No newline at end of file diff --git a/lib/SDK.md b/lib/SDK.md new file mode 100644 index 00000000..e9a55596 --- /dev/null +++ b/lib/SDK.md @@ -0,0 +1,278 @@ +# OpenCL SDK Library + +The OpenCL SDK Library hosts both C and C++ utilities which are generally useful for writing OpenCL applications but are either dependency-heavy or contentious. Because these utilities aren't the subject of universal interest, these utilities are _not_ exported, meaning SDK installations won't install their headers nor their libraries. Doing so the [OpenCL Utility Library](./Utils.md) can be kept dependency-free. + +The utilities are broken into to libraries, `OpenCLSDK` and `OpenCLSDKCpp`. Samples include ``/`` and link to their libraries respectively. + +## List of utilities + +- [Command-line Interface](#command-line-interface-utilities) +- [Pseudo Random Number Generation utilities](#pseudo-random-number-generation-utilities) +- [Image utilities](#image-utilities) +- [OpenCL-OpenGL interop utilities](#openCL-openGL-interop-utilities) + +### Command-line interface utilities + +#### C +```c +struct cl_sdk_options_DeviceTriplet +{ + int plat_index; + int dev_index; + cl_device_type dev_type; +}; + +struct cl_sdk_options_Diagnostic +{ + bool verbose; + bool quiet; +}; + +struct cl_sdk_options_SingleDevice +{ + struct cl_sdk_options_DeviceTriplet triplet; +}; + +struct cl_sdk_options_MultiDevice +{ + struct cl_sdk_options_DeviceTriplet * triplets; + size_t number; +}; +``` +#### C++ +```c++ +struct cl::sdk::DeviceTriplet +{ + int plat_index; + int dev_index; + cl_device_type dev_type; +}; +struct cl::sdk::Diagnostic +{ + bool verbose, + quiet; +}; +struct cl::sdk::SingleDevice +{ + DeviceTriplet triplet; +}; +struct cl::sdk::MultiDevice +{ + cl::vector triplets; +}; +struct cl::sdk::Window +{ + int width; + int height; + bool fullscreen; +}; +``` + +The SDK Library deduplicates the storage the result of common CLI argument parsing. These types are used throughout the SDK samples. + +#### C++ +```c++ +template +auto cl::sdk::parse(); + +template +Option cl::sdk::comprehend(Parsers... parsers); + +template +std::tuple cl::sdk::parse_cli(int argc, char* argv[], std::string banner = "OpenCL SDK sample template") +``` + +These functions reduce the boilerplate needed for each sample to introduce their own set of command-line arguments and helps deduplicate the set of common options which most samples inherit. + +The first two are the customizable parts where each sample (and the the pre-defined options) specify how CLI arguments should be processed. `cl::sdk::parse()` specifies what the option names are and should return an instance of tuple-like type (`std::get(const type&)` be valid) containing smart-pointer-like types (`ptr.get()` be valid) holding TCLAP arguments and switches. `cl::sdk::comprehend()` takes this tuple already expanded as arguments with names and "makes sense" of the strings of args already validated during parsing and returns a singular struct of the options at hand. + +> The types returned by `cl::sdk::parse()` must exactly match the `Parsers...` of `cl::sdk::comprehend()`. + +`cl::sdk::parse_cli()` is a simple metaprogram that invokes the `parse` and `comprehend` functions of all the `Options` types it is given in the correct order. First it registers all the command-line arguments and switches, then invokes the parse method of the underlying CLI parser and then invokes the comprehend method of the + +Simplest example is the C++ SAXPY sample adding a single option to control the length of the vector operands. The sample uses a single OpenCL device and respects diagnostic level options as well. + +#### C++ +```c++ +// Sample-specific option +struct SaxpyOptions { size_t length; }; + +// Add option to CLI parsing SDK utility +template <> auto cl::sdk::parse(){ + return std::make_tuple( + std::make_shared>("l", "length", "Length of input", false, 1'048'576, "positive integral") + ); +} +template <> SaxpyOptions cl::sdk::comprehend( + std::shared_ptr> length_arg){ + return SaxpyOptions{ + length_arg->getValue() + }; +} + +int main(int argc, char* argv[]) +{ + try + { + // Parse command-line options + auto opts = cl::sdk::parse_cli< + cl::sdk::options::Diagnostic, + cl::sdk::options::SingleDevice, + SaxpyOptions>(argc, argv); + const auto& diag_opts = std::get<0>(opts); + const auto& dev_opts = std::get<1>(opts); + const auto& saxpy_opts = std::get<2>(opts); + ... + } + // catch clauses +} +``` + +_(Note: C++17 structured-bindings allows cleaner binding of names to the members of the tuple returned by `cl::sdk::parse_cli`.)_ + +### Pseudo Random Number Generation utilities + +#### C +```c +void cl_sdk_fill_with_random_floats(pcg32_random_t * rng, cl_float * arr, const size_t len); +``` +Fills an array with random floats in the range [0, 1). +- `rng` must point to a valid PRNG instance. +- `arr` must be allocated storage long enough to store the results. +- `len` is the count of elements that will be written to `arr`. + +```c +void cl_sdk_fill_with_random_floats_range(pcg32_random_t * rng, + cl_float * arr, const size_t len, const cl_float low, const cl_float hi); +``` +Fills an array with random floats in the range [`low`, `hi`). +- `rng` must point to a valid PRNG instance. +- `arr` must be allocated storage long enough to store the results. +- `len` is the count of elements that will be written to `arr`. +- `low` is the low-end of the range. +- `hi` is the high-end of the range. + +```c +void cl_sdk_fill_with_random_ints_range(pcg32_random_t * rng, + cl_int * arr, const size_t len, const cl_int low, const cl_int hi); +``` +Fills an array with uniformly distributed numbers in the range [`low`, `hi`]. Uses rejection sampling from uniform bit distribution. +- `rng` must point to a valid PRNG instance. +- `arr` must be allocated storage long enough to store the results. +- `len` is the count of elements that will be written to `arr`. +- `low` is the low-end of the range. +- `hi` is the high-end of the range. + +#### C++ +```c++ +template +void fill_with_random(PRNG&& prng, Containers&&... containers); +``` +Fills containers with random numbers using a user-provided PRNG. +- `prng` must be a PRNG, a callable type with `T(void)` signature where `T` is implicitly convertible to the `value_type` of `containers`. +- `containers` must be a container providing a [LegacyOutputIterator](https://en.cppreference.com/w/cpp/named_req/OutputIterator). + +### Image utilities +#### C +```c +typedef struct cl_sdk_image +{ + int width, height, pixel_size; + unsigned char* pixels; +} +cl_sdk_image; +``` +#### C++ +```c++ +struct cl::sdk::Image +{ + int width, height, pixel_size; + cl::vector pixels; +}; +``` +Used to store pixel information of images read/written to/from storage. +- `width` and `height` store the number of pixels the image has in x-y directions respectively. +- `pixel_size` stores the number of bytes used to store a single pixel. +- `pixels` stores the actual pixel data. + +#### C +```c +cl_sdk_image cl_sdk_read_image(const char* file_name, cl_int* err); +``` +#### C++ +```c++ +Image cl::sdk::read_image(const char* file_name, cl_int* err); +``` +Reads a BMP/JPEG/PNG image from disk. +- `file_name` specifies the absolute or relative path (to the current working-directory) to the image. +- `err` is an optional pointer used to capture error conditions. + +Returns an `cl_sdk_image`/`cl::sdk::Image` instance. If an error occurs, the returned image is in an invalid state. + +#### C +```c +void cl_sdk_write_image(const char * file_name, const cl_sdk_image * im, cl_int * err); +``` +#### C++ +```c++ +void cl::sdk::write_image(const char* file_name, const Image& image, cl_int* err); +``` +Writes a BMP/JPEG/PNG image from disk. +- `file_name` specifies the absolute or relative path (to the current working-directory) to the image. +- `image` is the source of pixel information. +- `err` is an optional pointer used to capture error conditions. +### OpenCL-OpenGL interop utilities + +#### C++ +```c++ +cl::vector cl::sdk::get_interop_context_properties(const cl::Device& plat, cl_int* error = nullptr); +``` + +This function returns a null-terminated list of context properties required to setup an OpenCL-OpenGL interop context with the currently active OpenGL context. + +If `error` is non-null or if `CL_HPP_ENABLE_EXCEPTIONS` is used, ordinary OpenCL error codes may be returned and the following library-specific error codes: + +- `CL_UTIL_OS_GL_QUERY_ERROR` if platform-specific errors occur when trying to query for the currently active OpenGL context. + +#### C++ +```c++ +cl::Context cl::sdk::get_interop_context(int plat_id, int dev_id, cl_device_type type, cl_int* error = nullptr); +``` + +This function creates an interop context on the platform with id `plat_id` with a single device of type `type` and id `dev_id` which is able to share resources with the currently active OpenGL context. + +If `error` is non-null or if `CL_HPP_ENABLE_EXCEPTIONS` is used, ordinary OpenCL error codes may be returned and the following library-specific error codes: + +- `CL_UTIL_INDEX_OUT_OF_RANGE` if the requested platform or device id is outside the range of available platforms or devices of the selected `type` on the platform. +- `CL_UTIL_OS_GL_QUERY_ERROR` if platform-specific errors occur when trying to query for the currently active OpenGL context. + +#### C++ +```c++ +class cl::sdk::InteropWindow : public sf::Window +{ +public: + explicit InteropWindow( + sf::VideoMode mode, + const sf::String& title, + sf::Uint32 style = sf::Style::Default, + const sf::ContextSettings& settings = sf::ContextSettings{}, + int platform_id = 0, + int device_id = 0, + cl_bitfield device_type = CL_DEVICE_TYPE_DEFAULT + ); + + void run(); + +protected: + // Core functionality to be overriden + virtual void initializeGL() = 0; // Function that initializes all OpenGL assets needed to draw a scene + virtual void initializeCL() = 0; // Function that initializes all OpenCL assets needed to draw a scene + virtual void updateScene() = 0; // Function that holds scene update guaranteed not to conflict with drawing + virtual void render() = 0; // Function that does the native rendering + virtual void event(const sf::Event& e) = 0; // Function that handles render area resize + + cl::Context opencl_context; + bool cl_khr_gl_event_supported; +}; +``` +This class encapsulates an interactive window with the content being one OpenGL canvas. It provides a set of functions for the user to override in derived classes. \ No newline at end of file diff --git a/lib/Utils.md b/lib/Utils.md new file mode 100644 index 00000000..61ec0138 --- /dev/null +++ b/lib/Utils.md @@ -0,0 +1,121 @@ +# OpenCL Utility Library + +The OpenCL Utility Library provides both C and C++ bindings with near feature parity. The utilities are broken into to libraries, `OpenCLUtils` and `OpenCLUtilsCpp`. To include them in your project, include ``/`` and link to their libraries respectively. + +## List of utilities + +- [Platform](#platform-utilities) +- [Device](#device-utilities) +- [Context](#context-utilities) +- [Event](#event-utilities) +- [Error](#error-handling-utilities) + +### Platform utilities + +```c++ +bool cl::util::supports_extension(const cl::Platform& platform, const cl::string& extension); +``` +Tells whether a platform supports a given extension. +- `platform` is the platform to query. +- `extension` is the extension string being searched for. + +```c++ +bool cl::util::platform_version_contains(const cl::Platform& platform, const cl::string& version_fragment); +``` +Tells whether the platform version string contains a specific fragment. +- `platform` is the platform to query. +- `version_fragment` is the version string fragment to search for. + +### Device utilities + +```c++ +bool cl::util::opencl_c_version_contains(const cl::Device& device, const cl::string& version_fragment); +``` +Tells whether the device OpenCL C version string contains a specific fragment. +- `device` is the device to query. +- `version_fragment` is the version string fragment to search for. + +```c++ +bool cl::util::supports_extension(const cl::Device& device, const cl::string& extension); +``` +Tells whether a device supports a given extension. +- `device` is the device to query. +- `extension` is the extension string being searched for. + +```c++ +bool cl::util::supports_feature(const cl::Device& device, const cl::string& feature_name); +``` +Tells whether a device supports any version of a feature. +- `device` is the device to query. +- `feature_name` is the feature name string being searched for. + +_(Note: this function is only available when both the Utility library and the using code defines minimally `CL_VERSION_3_0`.)_ +### Context utilities + +```c +cl_context cl_util_get_context(int plat_id, int dev_id, cl_device_type type, cl_int* error); +``` +```c++ +cl::Context cl::util::get_context(int plat_id, int dev_id, cl_device_type type, cl_int* error = nullptr); +``` + +These functions create a context on the platform with id `plat_id` with a single device of type `type` and id `dev_id`. + +If `error` is non-null or if `CL_HPP_ENABLE_EXCEPTIONS` is used, ordinary OpenCL error codes may be returned and the following library-specific error codes: + +- `CL_UTIL_INDEX_OUT_OF_RANGE` if the requested platform or device id is outside the range of available platforms or devices of the selected `type` on the platform. + +### Event utilities + +```c++ +template +auto cl::util::get_duration(cl::Event& ev); +``` + +This function template can be used to query an event for the duration of time measured in user-provided units between two state transitions. By default the return type is `std::chrono::nanoseconds` as that is the unit of measure of the OpenCL API. + +### Error handling utilities + +```c++ +class Error : public std::exception +{ +private: + int err_; + const char * errStr_; +public: + /*! \brief Create a new SDK error exception for a given error code + * and corresponding message. + * + * \param err error code value. + * + * \param errStr a descriptive string that must remain in scope until + * handling of the exception has concluded. If set, it + * will be returned by what(). + */ + Error(cl_int err, const char * errStr = NULL) : err_(err), errStr_(errStr) + {} + + ~Error() throw() {} + + /*! \brief Get error string associated with exception + * + * \return A memory pointer to the error message string. + */ + virtual const char * what() const throw () + { + if (errStr_ == NULL) { + return "empty"; + } + else { + return errStr_; + } + } + + /*! \brief Get error code associated with exception + * + * \return The error code. + */ + cl_int err(void) const { return err_; } +}; +``` +This type is used as the exception type thrown by utilities when an error occurs and the compiling code defines `CL_HPP_ENABLE_EXCEPTIONS` diff --git a/lib/include/CL/SDK/CLI.h b/lib/include/CL/SDK/CLI.h new file mode 100644 index 00000000..f04410b5 --- /dev/null +++ b/lib/include/CL/SDK/CLI.h @@ -0,0 +1,147 @@ +#pragma once + +// OpenCL SDK includes +#include + +// STL includes +#include // realloc +#include // bool +#include // memcpy, strcmp, strtoul + +// cargs includes +#include + +typedef struct cag_option cag_option; + +cag_option *add_CLI_options(cag_option *opts, size_t *const num_opts, + cag_option *add_opts, size_t add_num_opts) +{ + cag_option *tmp = NULL; + + tmp = (cag_option *)realloc( + opts, sizeof(cag_option) * (*num_opts + add_num_opts)); + if (tmp) + { + memcpy(tmp + *num_opts, add_opts, sizeof(cag_option) * add_num_opts); + *num_opts += add_num_opts; + } + + return tmp; +} + +enum ParseState +{ + ParsedOK, + NotParsed, + ParseError +}; + +typedef enum ParseState ParseState; + +cag_option DiagnosticOptions[] = { + { .identifier = 'h', + .access_letters = "h", + .access_name = "help", + .description = "Show this help" }, + + { .identifier = 'q', + .access_letters = "q", + .access_name = "quiet", + .description = "Suppress standard output" }, + + { .identifier = 'v', + .access_letters = "v", + .access_name = "verbose", + .description = "Extra informational output" } +}; + +ParseState parse_DiagnosticOptions(const char identifier, + struct cl_sdk_options_Diagnostic *diag_opts) +{ + switch (identifier) + { + case 'q': diag_opts->quiet = true; return ParsedOK; + case 'v': diag_opts->verbose = true; return ParsedOK; + } + return NotParsed; +} + +cag_option SingleDeviceOptions[] = { + { .identifier = 'p', + .access_letters = "p", + .access_name = "platform", + .value_name = "(positive integer)", + .description = "Index of platform to use" }, + + { .identifier = 'd', + .access_letters = "d", + .access_name = "device", + .value_name = "(positive integer)", + .description = "Index of device to use" }, + + { .identifier = 't', + .access_letters = "t", + .access_name = "type", + .value_name = "(all|cpu|gpu|acc|def|cus)", + .description = "Type of device to use" } +}; + +// TODO: error handling +cl_device_type get_dev_type(const char *in) +{ + if (!strcmp(in, "all")) + return CL_DEVICE_TYPE_ALL; + else if (!strcmp(in, "cpu")) + return CL_DEVICE_TYPE_CPU; + else if (!strcmp(in, "gpu")) + return CL_DEVICE_TYPE_GPU; + else if (!strcmp(in, "acc")) + return CL_DEVICE_TYPE_ACCELERATOR; + else if (!strcmp(in, "def")) + return CL_DEVICE_TYPE_DEFAULT; + else if (!strcmp(in, "cus")) + return CL_DEVICE_TYPE_CUSTOM; + else + return CL_DEVICE_TYPE_ALL; // CL_INVALID_DEVICE_TYPE;// "Unkown device + // type after cli parse. Should not have + // happened." +} + +ParseState +parse_SingleDeviceOptions(const char identifier, + cag_option_context *cag_context, + struct cl_sdk_options_SingleDevice *dev_opts) +{ + const char *value; + +#define IF_ERR(op) \ + if ((value = cag_option_get_value(cag_context))) \ + { \ + op; \ + return ParsedOK; \ + } \ + else \ + return ParseError; + + switch (identifier) + { + case 'p': IF_ERR(dev_opts->triplet.plat_index = strtoul(value, NULL, 0)) + case 'd': IF_ERR(dev_opts->triplet.dev_index = strtoul(value, NULL, 0)) + case 't': IF_ERR(dev_opts->triplet.dev_type = get_dev_type(value)) + } + return NotParsed; + +#undef IF_ERR +} + +#define PARS_OPTIONS(parser, state) \ + do \ + { \ + if (state == NotParsed) state = parser; \ + if (state == ParseError) \ + { \ + fprintf(stderr, "Parse error\n"); \ + identifier = 'h'; \ + state = ParsedOK; \ + } \ + } while (0) diff --git a/lib/include/CL/SDK/CLI.hpp b/lib/include/CL/SDK/CLI.hpp new file mode 100644 index 00000000..6937c2cf --- /dev/null +++ b/lib/include/CL/SDK/CLI.hpp @@ -0,0 +1,147 @@ +#pragma once + +// OpenCL SDK includes +#include "OpenCLSDKCpp_Export.h" +#include + +// OpenCL Utils includes +#include + +// TCLAP includes +#include + +// STL includes +#include // std::shared_ptr, std::make_shared +#include // std::make_tuple +#include // std::vector + +namespace cl { +namespace sdk { + template auto parse(); + + template + Option comprehend(Parsers... parsers); + + namespace detail { + template + auto comprehend_helper(std::tuple parser) + { + return util::detail::apply(comprehend, parser); + } + } + + template + std::tuple + parse_cli(int argc, char* argv[], + std::string banner = "OpenCL SDK sample template") + { + TCLAP::CmdLine cli(banner); + + auto parsers = + std::make_tuple(std::make_pair(Options{}, parse())...); + + util::detail::for_each_in_tuple(parsers, [&](auto&& parser) { + util::detail::for_each_in_tuple( + parser.second, [&](auto&& arg) { cli.add(arg.get()); }); + }); + + cli.parse(argc, argv); + + return util::detail::transform_tuple(parsers, [](auto&& parser) { + return detail::comprehend_helper< + std::remove_reference_t>(parser.second); + }); + } +} +} + +// SDK built-in CLI parsers + +template <> auto cl::sdk::parse() +{ + return std::make_tuple( + std::make_shared("v", "verbose", + "Extra informational output", false), + std::make_shared("q", "quiet", + "Suppress standard output", false)); +} +template <> +cl::sdk::options::Diagnostic cl::sdk::comprehend( + std::shared_ptr verbose_arg, + std::shared_ptr quiet_arg) +{ + return options::Diagnostic{ verbose_arg->getValue(), + quiet_arg->getValue() }; +} + +SDKCPP_EXPORT extern std::unique_ptr> + valid_dev_constraint; + +template <> auto cl::sdk::parse() +{ + std::vector valid_dev_strings{ "all", "cpu", "gpu", + "acc", "cus", "def" }; + valid_dev_constraint = + std::make_unique>( + valid_dev_strings); + + return std::make_tuple(std::make_shared>( + "p", "platform", "Index of platform to use", + false, 0, "positive integral"), + std::make_shared>( + "d", "device", "Index of device to use", false, + 0, "positive integral"), + std::make_shared>( + "t", "type", "Type of device to use", false, + "def", valid_dev_constraint.get())); +} +template <> +cl::sdk::options::SingleDevice +cl::sdk::comprehend( + std::shared_ptr> platform_arg, + std::shared_ptr> device_arg, + std::shared_ptr> type_arg) +{ + auto device_type = [](std::string in) -> cl_device_type { + if (in == "all") + return CL_DEVICE_TYPE_ALL; + else if (in == "cpu") + return CL_DEVICE_TYPE_CPU; + else if (in == "gpu") + return CL_DEVICE_TYPE_GPU; + else if (in == "acc") + return CL_DEVICE_TYPE_ACCELERATOR; + else if (in == "cus") + return CL_DEVICE_TYPE_CUSTOM; + else if (in == "def") + return CL_DEVICE_TYPE_DEFAULT; + else + throw std::logic_error{ + "Unkown device type after cli parse. Should not have happened." + }; + }; + + return options::SingleDevice{ platform_arg->getValue(), + device_arg->getValue(), + device_type(type_arg->getValue()) }; +} + +template <> auto cl::sdk::parse() +{ + return std::make_tuple( + std::make_shared>("x", "width", "Width of window", + false, 800, "positive integral"), + std::make_shared>( + "y", "height", "Height of window", false, 800, "positive integral"), + std::make_shared("f", "fullscreen", + "Fullscreen window", false)); +} +template <> +cl::sdk::options::Window cl::sdk::comprehend( + std::shared_ptr> width_arg, + std::shared_ptr> height_arg, + std::shared_ptr fullscreen_arg) +{ + return options::Window{ width_arg->getValue(), height_arg->getValue(), + fullscreen_arg->getValue() }; +} diff --git a/lib/include/CL/SDK/Context.h b/lib/include/CL/SDK/Context.h new file mode 100644 index 00000000..127c724b --- /dev/null +++ b/lib/include/CL/SDK/Context.h @@ -0,0 +1,20 @@ +#pragma once + +// OpenCL SDK includes +#include "OpenCLSDK_Export.h" + +// OpenCL SDK includes +#include + +// OpenCL includes +#include + +SDK_EXPORT +cl_context cl_sdk_get_context_by_triplet( + const struct cl_sdk_options_DeviceTriplet* const triplet, + cl_int* const error); + +SDK_EXPORT +cl_device_id cl_sdk_get_device_by_triplet( + const struct cl_sdk_options_DeviceTriplet* const triplet, + cl_int* const error); diff --git a/lib/include/CL/SDK/Context.hpp b/lib/include/CL/SDK/Context.hpp new file mode 100644 index 00000000..7cf1e8b3 --- /dev/null +++ b/lib/include/CL/SDK/Context.hpp @@ -0,0 +1,18 @@ +#pragma once + +// OpenCL SDK includes +#include +#include + +namespace cl { +namespace sdk { + Context get_context(options::DeviceTriplet triplet, + cl_int* error = nullptr); +} +} + +cl::Context cl::sdk::get_context(options::DeviceTriplet triplet, cl_int* error) +{ + return cl::util::get_context(triplet.plat_index, triplet.dev_index, + triplet.dev_type, error); +} \ No newline at end of file diff --git a/lib/include/CL/SDK/Image.h b/lib/include/CL/SDK/Image.h new file mode 100644 index 00000000..5aa65c8e --- /dev/null +++ b/lib/include/CL/SDK/Image.h @@ -0,0 +1,19 @@ +#pragma once + +// OpenCL SDK includes +#include "OpenCLSDK_Export.h" + +// OpenCL includes +#include + +typedef struct cl_sdk_image +{ + int width, height, pixel_size; + unsigned char* pixels; +} cl_sdk_image; + +SDK_EXPORT +cl_sdk_image cl_sdk_read_image(const char* file_name, cl_int* err); + +SDK_EXPORT +cl_int cl_sdk_write_image(const char* file_name, const cl_sdk_image* im); diff --git a/lib/include/CL/SDK/Image.hpp b/lib/include/CL/SDK/Image.hpp new file mode 100644 index 00000000..1da5dc01 --- /dev/null +++ b/lib/include/CL/SDK/Image.hpp @@ -0,0 +1,23 @@ +#pragma once + +// OpenCL SDK includes +#include "OpenCLSDKCpp_Export.h" + +// OpenCL includes +#include + +namespace cl { +namespace sdk { + struct Image + { + int width, height, pixel_size; + cl::vector pixels; + }; + + SDKCPP_EXPORT + Image read_image(const char* file_name, cl_int* err); + + SDKCPP_EXPORT + cl_int write_image(const char* file_name, const Image& image); +} +} diff --git a/lib/include/CL/SDK/InteropContext.hpp b/lib/include/CL/SDK/InteropContext.hpp new file mode 100644 index 00000000..01d751ba --- /dev/null +++ b/lib/include/CL/SDK/InteropContext.hpp @@ -0,0 +1,19 @@ +#pragma once + +// OpenCL SDK includes +#include "OpenCLSDKCpp_Export.h" + +// OpenCL includes +#include + +namespace cl { +namespace sdk { + vector + SDKCPP_EXPORT get_interop_context_properties(const cl::Device& plat, + cl_int* error = nullptr); + + Context SDKCPP_EXPORT get_interop_context(cl_uint plat_id, cl_uint dev_id, + cl_device_type type, + cl_int* error = nullptr); +} +} diff --git a/lib/include/CL/SDK/InteropWindow.hpp b/lib/include/CL/SDK/InteropWindow.hpp new file mode 100644 index 00000000..98ba44f7 --- /dev/null +++ b/lib/include/CL/SDK/InteropWindow.hpp @@ -0,0 +1,51 @@ +#pragma once + +// OpenCL SDK includes +#include "OpenCLSDKCpp_Export.h" + +// OpenCL Utils includes +#include + +// OpenCL includes +#include + +// SFML includes +#include +#include + +namespace cl { +namespace sdk { + class SDKCPP_EXPORT InteropWindow : public sf::Window { + public: + explicit InteropWindow( + sf::VideoMode mode, const sf::String& title, + sf::Uint32 style = sf::Style::Default, + const sf::ContextSettings& settings = sf::ContextSettings{}, + cl_uint platform_id = 0, cl_uint device_id = 0, + cl_bitfield device_type = CL_DEVICE_TYPE_DEFAULT); + + void run(); + + protected: + // Core functionality to be overriden + virtual void initializeGL() = 0; // Function that initializes all OpenGL + // assets needed to draw a scene + virtual void initializeCL() = 0; // Function that initializes all OpenCL + // assets needed to draw a scene + virtual void + updateScene() = 0; // Function that holds scene update guaranteed not to + // conflict with drawing + virtual void render() = 0; // Function that does the native rendering + virtual void event( + const sf::Event& e) = 0; // Function that handles render area resize + + cl::Context opencl_context; + bool cl_khr_gl_event_supported; + + private: + cl_uint plat_id; + cl_uint dev_id; + cl_bitfield dev_type; + }; +} +} diff --git a/lib/include/CL/SDK/OpenCLSDK_Config.in.h b/lib/include/CL/SDK/OpenCLSDK_Config.in.h new file mode 100644 index 00000000..c358b41b --- /dev/null +++ b/lib/include/CL/SDK/OpenCLSDK_Config.in.h @@ -0,0 +1,3 @@ +#pragma once + +#cmakedefine OPENCL_SDK_BUILD_OPENGL_SAMPLES diff --git a/lib/include/CL/SDK/Options.h b/lib/include/CL/SDK/Options.h new file mode 100644 index 00000000..6f381b25 --- /dev/null +++ b/lib/include/CL/SDK/Options.h @@ -0,0 +1,31 @@ +#pragma once + +// STL includes +#include + +// OpenCL includes +#include + +struct cl_sdk_options_DeviceTriplet +{ + cl_uint plat_index; + cl_uint dev_index; + cl_device_type dev_type; +}; + +struct cl_sdk_options_Diagnostic +{ + bool verbose; + bool quiet; +}; + +struct cl_sdk_options_SingleDevice +{ + struct cl_sdk_options_DeviceTriplet triplet; +}; + +struct cl_sdk_options_MultiDevice +{ + struct cl_sdk_options_DeviceTriplet* triplets; + size_t number; +}; diff --git a/lib/include/CL/SDK/Options.hpp b/lib/include/CL/SDK/Options.hpp new file mode 100644 index 00000000..116ea0d0 --- /dev/null +++ b/lib/include/CL/SDK/Options.hpp @@ -0,0 +1,35 @@ +#pragma once + +// OpenCL includes +#include + +namespace cl { +namespace sdk { + namespace options { + struct DeviceTriplet + { + cl_uint plat_index; + cl_uint dev_index; + cl_device_type dev_type; + }; + struct Diagnostic + { + bool verbose, quiet; + }; + struct SingleDevice + { + DeviceTriplet triplet; + }; + struct MultiDevice + { + cl::vector triplets; + }; + struct Window + { + int width; + int height; + bool fullscreen; + }; + } +} +} diff --git a/lib/include/CL/SDK/Random.h b/lib/include/CL/SDK/Random.h new file mode 100644 index 00000000..89783f6a --- /dev/null +++ b/lib/include/CL/SDK/Random.h @@ -0,0 +1,128 @@ +#pragma once + +// STL includes +#include // uint64_t, uint32_t +#include // bool +#include // ldexpf + +/* + * PCG Random Number Generation for C. + * + * Copyright 2014 Melissa O'Neill + * + * 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. + * + * For additional information about the PCG random number generation scheme, + * including its license and other licensing options, visit + * + * http://www.pcg-random.org + */ + +// *Really* minimal PCG32 code / (c) 2014 M.E. O'Neill / pcg-random.org +// Licensed under Apache License 2.0 (NO WARRANTY, etc. see website) + +typedef struct +{ + uint64_t state; + uint64_t inc; +} pcg32_random_t; + +// pcg32_random() +// pcg32_random_r(rng) +// Generate a uniformly distributed 32-bit random number + +uint32_t pcg32_random_r(pcg32_random_t* rng) +{ + uint64_t oldstate = rng->state; + // Advance internal state + rng->state = oldstate * 6364136223846793005ULL + (rng->inc | 1); + // Calculate output function (XSH RR), uses old state for max ILP + uint32_t xorshifted = (uint32_t)(((oldstate >> 18u) ^ oldstate) >> 27u); + uint32_t rot = oldstate >> 59u; + return (xorshifted >> rot) | (xorshifted << ((0 - rot) & 31)); +} + +// give almost uniformly distributed random float in [0, 1) +cl_float pcg32_random_float(pcg32_random_t* rng) +{ + return ldexpf((float)pcg32_random_r(rng), -32); +} + +// give almost uniformly distributed random float in [low, high) +cl_float pcg32_random_float_range(pcg32_random_t* rng, cl_float low, + cl_float hi) +{ + return ldexpf((float)pcg32_random_r(rng), -32) * (hi - low) + low; +} + +// pcg32_srandom(initstate, initseq) +// pcg32_srandom_r(rng, initstate, initseq): +// Seed the rng. Specified in two parts, state initializer and a +// sequence selection constant (a.k.a. stream id) + +void pcg32_srandom_r(pcg32_random_t* rng, uint64_t initstate, uint64_t initseq) +{ + rng->state = 0U; + rng->inc = (initseq << 1u) | 1u; + pcg32_random_r(rng); + rng->state += initstate; + pcg32_random_r(rng); +} + +// fill array with random floats in [0, 1) +void cl_sdk_fill_with_random_floats(pcg32_random_t* rng, cl_float* arr, + const size_t len) +{ + for (size_t index = 0; index < len; ++index) + arr[index] = pcg32_random_float(rng); +} + +void cl_sdk_fill_with_random_floats_range(pcg32_random_t* rng, cl_float* arr, + const size_t len, const cl_float low, + const cl_float hi) +{ + cl_float diff = hi - low; + for (size_t index = 0; index < len; ++index) + arr[index] = pcg32_random_float(rng) * diff + low; +} + +// return uniformly distributed numbers in the range [low, hi] +// use rejection sampling from uniform bit distribution +void cl_sdk_fill_with_random_ints_range(pcg32_random_t* rng, cl_int* arr, + const size_t len, const cl_int low, + const cl_int hi) +{ + const uint32_t diff = hi - low, bits_of_uint32_t = 32, + bits_needed = diff ? (uint32_t)log2(diff) + 1 : 1, + mask = diff ? (1u << bits_needed) - 1 : 0; + for (size_t index = 0; index < len; ++index) + { + uint32_t res; + bool reject = true; + do + { + res = pcg32_random_r(rng); // get 32 random bits + // and take enough of them to cover [0..diff] range + for (uint32_t i = 0; i < bits_of_uint32_t / bits_needed; ++i) + if ((res & mask) <= diff) + { // no rejection + res &= mask; // take this number + reject = false; + break; + } + else // take next piece of bits + res >>= bits_needed; + } while (reject); + arr[index] = low + (cl_int)res; + } +} diff --git a/lib/include/CL/SDK/Random.hpp b/lib/include/CL/SDK/Random.hpp new file mode 100644 index 00000000..93bead88 --- /dev/null +++ b/lib/include/CL/SDK/Random.hpp @@ -0,0 +1,23 @@ +#pragma once + +// OpenCL SDK includes +#include // cl::util::detail::for_each_arg + +// STL includes +#include // std::generate_n +#include // std::begin +#include + +namespace cl { +namespace sdk { + template + void fill_with_random(PRNG&& prng, Containers&&... containers) + { + util::detail::for_each_arg( + [&](auto&& container) { + std::generate_n(std::begin(container), container.size(), prng); + }, + containers...); + } +} +} diff --git a/lib/include/CL/SDK/SDK.h b/lib/include/CL/SDK/SDK.h new file mode 100644 index 00000000..884c91d2 --- /dev/null +++ b/lib/include/CL/SDK/SDK.h @@ -0,0 +1,13 @@ +#pragma once + +// OpenCL SDK includes +#include "OpenCLSDK_Export.h" + +#include +#include +#include +#include +#include + +// OpenCL includes +#include diff --git a/lib/include/CL/SDK/SDK.hpp b/lib/include/CL/SDK/SDK.hpp new file mode 100644 index 00000000..36d1b525 --- /dev/null +++ b/lib/include/CL/SDK/SDK.hpp @@ -0,0 +1,15 @@ +#pragma once + +// OpenCL SDK includes +#include "OpenCLSDK_Export.h" +#include "OpenCLSDK_Config.h" + +#include +#include +#ifdef OPENCL_SDK_BUILD_OPENGL_SAMPLES +#include +#include +#endif + +// OpenCL includes +#include diff --git a/lib/include/CL/Utils/Context.h b/lib/include/CL/Utils/Context.h new file mode 100644 index 00000000..cebb8b9e --- /dev/null +++ b/lib/include/CL/Utils/Context.h @@ -0,0 +1,50 @@ +#pragma once + +// OpenCL Utils includes +#include "OpenCLUtils_Export.h" + +// OpenCL includes +#include + +// STL includes +#include + +UTILS_EXPORT +cl_context cl_util_get_context(const cl_uint plat_id, const cl_uint dev_id, + const cl_device_type type, cl_int* const error); +UTILS_EXPORT +cl_device_id cl_util_get_device(const cl_uint plat_id, const cl_uint dev_id, + const cl_device_type type, cl_int* const error); + +UTILS_EXPORT +cl_int cl_util_print_device_info(const cl_device_id device); + +UTILS_EXPORT +char* cl_util_get_device_info(const cl_device_id device, + const cl_device_info info, cl_int* const error); +UTILS_EXPORT +char* cl_util_get_platform_info(const cl_platform_id platform, + const cl_platform_info info, + cl_int* const error); + +// build program and show log if build is not successful +UTILS_EXPORT +cl_int cl_util_build_program(const cl_program pr, const cl_device_id dev, + const char* const opt); + +#define GET_CURRENT_TIMER(time) \ + struct timespec time; \ + timespec_get(&time, TIME_UTC); \ + { \ + } + +#define TIMER_DIFFERENCE(dt, time1, time2) \ + { \ + dt = (time2.tv_sec - time1.tv_sec) * 1000000000 \ + + (time2.tv_nsec - time1.tv_nsec); \ + } + +#define START_TIMER GET_CURRENT_TIMER(start_timer1) +#define STOP_TIMER(dt) \ + GET_CURRENT_TIMER(stop_timer2) \ + TIMER_DIFFERENCE(dt, start_timer1, stop_timer2) diff --git a/lib/include/CL/Utils/Context.hpp b/lib/include/CL/Utils/Context.hpp new file mode 100644 index 00000000..bd1110c3 --- /dev/null +++ b/lib/include/CL/Utils/Context.hpp @@ -0,0 +1,17 @@ +#pragma once + +// OpenCL SDK includes +#include "OpenCLUtilsCpp_Export.h" + +#include + +// OpenCL includes +#include + +namespace cl { +namespace util { + Context UTILSCPP_EXPORT get_context(cl_uint plat_id, cl_uint dev_id, + cl_device_type type, + cl_int* error = nullptr); +} +} diff --git a/lib/include/CL/Utils/Detail.hpp b/lib/include/CL/Utils/Detail.hpp new file mode 100644 index 00000000..49cccd02 --- /dev/null +++ b/lib/include/CL/Utils/Detail.hpp @@ -0,0 +1,84 @@ +#pragma once + +// STL includes +#include +#include // std::forward, std::integer_sequence +#include // std::tuple, std::get +#include // std::initializer_list + +namespace cl { +namespace util { + namespace detail { + // Borrowed from: + // https://www.fluentcpp.com/2019/03/05/for_each_arg-applying-a-function-to-each-argument-of-a-function-in-cpp/ + template F for_each_arg(F f, Args&&... args) + { + (void)std::initializer_list{ ( + (void)f(std::forward(args)), 0)... }; + return f; + } + + namespace impl { + // Borrowed from: https://stackoverflow.com/a/16387374/1476661 + template + void for_each_in_tuple(T&& t, F&& f, + std::integer_sequence) + { + auto l = { + (std::forward(f)(std::get(std::forward(t))), 0)... + }; + (void)l; + } + } + template + void for_each_in_tuple(std::tuple const& t, F&& f) + { + impl::for_each_in_tuple( + t, std::forward(f), + std::make_integer_sequence()); + } + + namespace impl { + // Borrowed from + // https://codereview.stackexchange.com/questions/193420/apply-a-function-to-each-element-of-a-tuple-map-a-tuple + template + auto transform_tuple(Tuple&& t, F&& f, std::index_sequence) + { + return std::make_tuple(std::forward(f)(std::get(t))...); + } + } + template + auto transform_tuple(const std::tuple& t, F&& f) + { + return impl::transform_tuple( + t, std::forward(f), + std::make_index_sequence{}); + } + + namespace impl { + // Borrowed from + // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3658.html + // with modifications of Casey Carter at + // https://stackoverflow.com/a/51365112/1476661 + template + auto apply(F&& f, Tuple&& args, std::index_sequence) + -> decltype(std::forward(f)( + std::get(std::forward(args))...)) + { + return std::forward(f)( + std::get(std::forward(args))...); + } + } + template >::value>> + auto apply(F&& f, Tuple&& args) + -> decltype(impl::apply(std::forward(f), + std::forward(args), Indices())) + { + return impl::apply(std::forward(f), std::forward(args), + Indices()); + } + } +} +} diff --git a/lib/include/CL/Utils/Device.hpp b/lib/include/CL/Utils/Device.hpp new file mode 100644 index 00000000..0a8aed8b --- /dev/null +++ b/lib/include/CL/Utils/Device.hpp @@ -0,0 +1,21 @@ +#pragma once + +#include "OpenCLUtilsCpp_Export.h" +#include + +#include + +namespace cl { +namespace util { + bool UTILSCPP_EXPORT opencl_c_version_contains( + const cl::Device& device, const cl::string& version_fragment); + + bool UTILSCPP_EXPORT supports_extension(const cl::Device& device, + const cl::string& extension); + +#ifdef CL_VERSION_3_0 + bool UTILSCPP_EXPORT supports_feature(const cl::Device& device, + const cl::string& feature_name); +#endif +} +} diff --git a/lib/include/CL/Utils/Error.h b/lib/include/CL/Utils/Error.h new file mode 100644 index 00000000..bf6e24bf --- /dev/null +++ b/lib/include/CL/Utils/Error.h @@ -0,0 +1,88 @@ +#pragma once + +// OpenCL Utils includes +#include "OpenCLUtils_Export.h" + +// OpenCL Utils includes +#include + +// STL includes +#include // fprintf + +// OpenCL includes +#include + +// RET = function returns error code +// PAR = functions sets error code in the paremeter + +#ifdef _DEBUG + +#define OCLERROR_RET(func, err, label) \ + do \ + { \ + err = func; \ + if (err != CL_SUCCESS) \ + { \ + cl_util_print_error(err); \ + fprintf(stderr, "on line %d, in file %s\n%s\n", __LINE__, \ + __FILE__, #func); \ + goto label; \ + } \ + } while (0) + +#define OCLERROR_PAR(func, err, label) \ + do \ + { \ + func; \ + if (err != CL_SUCCESS) \ + { \ + cl_util_print_error(err); \ + fprintf(stderr, "on line %d, in file %s\n%s\n", __LINE__, \ + __FILE__, #func); \ + goto label; \ + } \ + } while (0) + +#define MEM_CHECK(func, err, label) \ + do \ + { \ + if ((func) == NULL) \ + { \ + err = CL_OUT_OF_HOST_MEMORY; \ + cl_util_print_error(err); \ + fprintf(stderr, "on line %d, in file %s\n%s\n", __LINE__, \ + __FILE__, #func); \ + goto label; \ + } \ + } while (0) + +#else + +#define OCLERROR_RET(func, err, label) \ + do \ + { \ + err = func; \ + if (err != CL_SUCCESS) goto label; \ + } while (0) + +#define OCLERROR_PAR(func, err, label) \ + do \ + { \ + func; \ + if (err != CL_SUCCESS) goto label; \ + } while (0) + +#define MEM_CHECK(func, err, label) \ + do \ + { \ + if ((func) == NULL) \ + { \ + err = CL_OUT_OF_HOST_MEMORY; \ + goto label; \ + } \ + } while (0) + +#endif + +UTILS_EXPORT +void cl_util_print_error(cl_int error); diff --git a/lib/include/CL/Utils/Error.hpp b/lib/include/CL/Utils/Error.hpp new file mode 100644 index 00000000..83bb1a13 --- /dev/null +++ b/lib/include/CL/Utils/Error.hpp @@ -0,0 +1,70 @@ +#pragma once + +// OpenCL Utils includes +#include "OpenCLUtils_Export.h" + +// OpenCL Utils includes +#include + +// OpenCL includes +#include + +namespace cl { +namespace util { +#if defined(CL_HPP_ENABLE_EXCEPTIONS) + /*! \brief Exception class + * + * This may be thrown by SDK utility functions when + * CL_HPP_ENABLE_EXCEPTIONS is defined. + */ + class Error : public std::exception { + private: + int err_; + const char* errStr_; + + public: + /*! \brief Create a new SDK error exception for a given error code + * and corresponding message. + * + * \param err error code value. + * + * \param errStr a descriptive string that must remain in scope until + * handling of the exception has concluded. If set, it + * will be returned by what(). + */ + Error(cl_int err, const char* errStr = NULL): err_(err), errStr_(errStr) + {} + + ~Error() throw() {} + + /*! \brief Get error string associated with exception + * + * \return A memory pointer to the error message string. + */ + virtual const char* what() const throw() + { + if (errStr_ == NULL) + { + return "empty"; + } + else + { + return errStr_; + } + } + + /*! \brief Get error code associated with exception + * + * \return The error code. + */ + cl_int err(void) const { return err_; } + }; +#endif + + namespace detail { + UTILS_EXPORT cl_int errHandler(cl_int err, cl_int* errPtr, + const char* errStr = nullptr); + } + +} +} diff --git a/lib/include/CL/Utils/ErrorCodes.h b/lib/include/CL/Utils/ErrorCodes.h new file mode 100644 index 00000000..a1f9d4a8 --- /dev/null +++ b/lib/include/CL/Utils/ErrorCodes.h @@ -0,0 +1,5 @@ +#pragma once + +#define CL_UTIL_INDEX_OUT_OF_RANGE -2000 +#define CL_UTIL_DEVICE_NOT_INTEROPERABLE -2001 +#define CL_UTIL_FILE_OPERATION_ERROR -2002 diff --git a/lib/include/CL/Utils/Event.h b/lib/include/CL/Utils/Event.h new file mode 100644 index 00000000..f144e215 --- /dev/null +++ b/lib/include/CL/Utils/Event.h @@ -0,0 +1,13 @@ +#pragma once + +// OpenCL Utils includes +#include "OpenCLUtils_Export.h" + +// OpenCL includes +#include + +UTILS_EXPORT +cl_ulong cl_util_get_event_duration(const cl_event event, + const cl_profiling_info start, + const cl_profiling_info end, + cl_int* const error); \ No newline at end of file diff --git a/lib/include/CL/Utils/Event.hpp b/lib/include/CL/Utils/Event.hpp new file mode 100644 index 00000000..e5a6577e --- /dev/null +++ b/lib/include/CL/Utils/Event.hpp @@ -0,0 +1,21 @@ +#pragma once + +// OpenCL SDK includes +#include "OpenCLUtilsCpp_Export.h" + +// STL includes +#include + +// OpenCL includes +#include + +namespace cl { +namespace util { + template + auto get_duration(cl::Event& ev) + { + return std::chrono::duration_cast(std::chrono::nanoseconds{ + ev.getProfilingInfo() - ev.getProfilingInfo() }); + } +} +} diff --git a/lib/include/CL/Utils/File.h b/lib/include/CL/Utils/File.h new file mode 100644 index 00000000..62c8e95a --- /dev/null +++ b/lib/include/CL/Utils/File.h @@ -0,0 +1,42 @@ +#pragma once + +// OpenCL Utils includes +#include "OpenCLUtils_Export.h" + +// OpenCL includes +#include + +// read all the text file contents securely in ANSI C89 +// return pointer to C-string with file contents +// can handle streams with no known size and no support for fseek +// based on https://stackoverflow.com/questions/14002954/ by Nominal Animal +UTILS_EXPORT +char* cl_util_read_text_file(const char* const filename, size_t* const length, + cl_int* const error); + +// read all the binary file contents securely in ANSI C89 +// return pointer to file contents +// can handle streams with no known size and no support for fseek +// based on https://stackoverflow.com/questions/14002954/ by Nominal Animal +UTILS_EXPORT +unsigned char* cl_util_read_binary_file(const char* const filename, + size_t* const length, + cl_int* const error); + +// write binaries of OpenCL compiled program +// binaries are written as separate files for each device +// with file name "(program_file_name)_(name of device).bin" +// based on variant of Logan +// http://logan.tw/posts/2014/11/22/pre-compile-the-opencl-kernel-program-part-2/ +UTILS_EXPORT +cl_int cl_util_write_binaries(const cl_program program, + const char* const program_file_name); + +// read binaries of OpenCL compiled program +// from files of file names "(program_file_name)_(name of device).bin" +UTILS_EXPORT +cl_program cl_util_read_binaries(const cl_context context, + const cl_device_id* const devices, + const cl_uint num_devices, + const char* const program_file_name, + cl_int* const error); diff --git a/lib/include/CL/Utils/File.hpp b/lib/include/CL/Utils/File.hpp new file mode 100644 index 00000000..984a3238 --- /dev/null +++ b/lib/include/CL/Utils/File.hpp @@ -0,0 +1,49 @@ +#pragma once + +// OpenCL SDK includes +#include + +// STL includes +#include +#include + +namespace cl { +namespace util { + // Scott Meyers, Effective STL, Addison-Wesley Professional, 2001, Item 29 + // with error handling + UTILSCPP_EXPORT + std::string read_text_file(const char* const filename, cl_int* const error) + { + std::ifstream in(filename); + if (in.good()) + { + try + { + std::string red((std::istreambuf_iterator(in)), + std::istreambuf_iterator()); + if (in.good() && in.eof()) + { + if (error != nullptr) *error = CL_SUCCESS; + return red; + } + else + { + detail::errHandler(CL_UTIL_FILE_OPERATION_ERROR, error, + "File read error!"); + return std::string(); + } + } catch (std::bad_alloc& ex) + { + detail::errHandler(CL_OUT_OF_RESOURCES, error, + "Bad allocation!"); + return std::string(); + } + } + else + { + detail::errHandler(CL_INVALID_VALUE, error, "No file!"); + return std::string(); + } + } +} +} diff --git a/lib/include/CL/Utils/InteropContext.hpp b/lib/include/CL/Utils/InteropContext.hpp new file mode 100644 index 00000000..2d8fdbfd --- /dev/null +++ b/lib/include/CL/Utils/InteropContext.hpp @@ -0,0 +1,18 @@ +#pragma once + +#include "OpenCLUtilsCpp_Export.h" +#include + +#include + +namespace cl { +namespace util { + vector + UTILSCPP_EXPORT get_interop_context_properties(const cl::Device& plat, + cl_int* error = nullptr); + + Context UTILSCPP_EXPORT get_interop_context(int plat_id, int dev_id, + cl_device_type type, + cl_int* error = nullptr); +} +} diff --git a/lib/include/CL/Utils/Platform.hpp b/lib/include/CL/Utils/Platform.hpp new file mode 100644 index 00000000..9957d76b --- /dev/null +++ b/lib/include/CL/Utils/Platform.hpp @@ -0,0 +1,16 @@ +#pragma once + +#include "OpenCLUtilsCpp_Export.h" +#include + +#include + +namespace cl { +namespace util { + bool UTILSCPP_EXPORT supports_extension(const cl::Platform& platform, + const cl::string& extension); + + bool UTILSCPP_EXPORT platform_version_contains( + const cl::Platform& platform, const cl::string& version_fragment); +} +} diff --git a/lib/include/CL/Utils/Utils.h b/lib/include/CL/Utils/Utils.h new file mode 100644 index 00000000..9d1c2471 --- /dev/null +++ b/lib/include/CL/Utils/Utils.h @@ -0,0 +1,11 @@ +#pragma once + +// OpenCL Utils includes +#include "OpenCLUtils_Export.h" + +#include +#include +#include + +// OpenCL includes +#include diff --git a/lib/include/CL/Utils/Utils.hpp b/lib/include/CL/Utils/Utils.hpp new file mode 100644 index 00000000..40dd8d79 --- /dev/null +++ b/lib/include/CL/Utils/Utils.hpp @@ -0,0 +1,14 @@ +#pragma once + +// OpenCL Utils includes +#include "OpenCLUtils_Export.h" + +#include +#include +#include +#include +#include +#include + +// OpenCL includes +#include diff --git a/lib/src/SDK/CLI.cpp b/lib/src/SDK/CLI.cpp new file mode 100644 index 00000000..a53a5e17 --- /dev/null +++ b/lib/src/SDK/CLI.cpp @@ -0,0 +1,5 @@ +// OpenCL SDK includes +#include + +SDKCPP_EXPORT std::unique_ptr> + valid_dev_constraint; diff --git a/lib/src/SDK/Context.c b/lib/src/SDK/Context.c new file mode 100644 index 00000000..b18625e1 --- /dev/null +++ b/lib/src/SDK/Context.c @@ -0,0 +1,25 @@ +// OpenCL SDK includes +#include + +// OpenCL Utils includes +#include + +// STL includes +#include // malloc, free +#include // printf + +cl_context cl_sdk_get_context_by_triplet( + const struct cl_sdk_options_DeviceTriplet* const triplet, + cl_int* const error) +{ + return cl_util_get_context(triplet->plat_index, triplet->dev_index, + triplet->dev_type, error); +} + +cl_device_id cl_sdk_get_device_by_triplet( + const struct cl_sdk_options_DeviceTriplet* const triplet, + cl_int* const error) +{ + return cl_util_get_device(triplet->plat_index, triplet->dev_index, + triplet->dev_type, error); +} diff --git a/lib/src/SDK/Image.c b/lib/src/SDK/Image.c new file mode 100644 index 00000000..cc5459ff --- /dev/null +++ b/lib/src/SDK/Image.c @@ -0,0 +1,89 @@ +// OpenCL SDK includes +#include + +// OpenCL Utils includes +#include + +// STL includes +#include // fprintf +#include // tolower + +// stb includes +#define STB_IMAGE_IMPLEMENTATION +#include +#define STB_IMAGE_WRITE_IMPLEMENTATION +#include + +// OpenCL includes +#include + +cl_sdk_image cl_sdk_read_image(const char* const file_name, cl_int* const error) +{ + cl_int err = CL_SUCCESS; + + cl_sdk_image im = { + .width = 0, .height = 0, .pixel_size = 1, .pixels = NULL + }; + im.pixels = stbi_load(file_name, &im.width, &im.height, &im.pixel_size, 0); + + if (im.width && im.height && im.pixel_size && im.pixels) + err = CL_SUCCESS; + else + { + fprintf(stderr, "File read error!"); + err = CL_INVALID_ARG_VALUE; + } + + if (error != NULL) *error = err; + return im; +} + +static char* to_lowercase(const char* const s, char* const d, const size_t n) +{ + for (size_t i = 0; i < n; ++i) d[i] = tolower(s[i]); + return d; +} + +cl_int cl_sdk_write_image(const char* const file_name, + const cl_sdk_image* const im) +{ + cl_int error = CL_SUCCESS; + char fext[5] = { 0, 0, 0, 0, 0 }; + +#define IF_EXT(ext, func, err_text) \ + if (!strcmp(to_lowercase(file_name + strlen(file_name) - 4, fext, 4), \ + ext)) \ + { \ + if (!func) \ + { \ + fprintf(stderr, err_text); \ + error = CL_INVALID_ARG_VALUE; \ + } \ + } + + IF_EXT(".png", + stbi_write_png(file_name, im->width, im->height, im->pixel_size, + im->pixels, 0), + "Not possible to write PNG file!\n") + else IF_EXT( + ".bmp", + stbi_write_bmp(file_name, im->width, im->height, im->pixel_size, + im->pixels), + "Not possible to write BMP file!\n") else IF_EXT(".jpg", + stbi_write_jpg( + file_name, + im->width, + im->height, + im->pixel_size, + im->pixels, 80), + "Not possible to " + "write JPG " + "file!\n") else + { + fprintf(stderr, "Unknown file extension!\n"); + error = CL_IMAGE_FORMAT_NOT_SUPPORTED; + } + +#undef IF_EXT + return error; +} diff --git a/lib/src/SDK/Image.cpp b/lib/src/SDK/Image.cpp new file mode 100644 index 00000000..c71c6447 --- /dev/null +++ b/lib/src/SDK/Image.cpp @@ -0,0 +1,99 @@ +// OpenCL SDK includes +#include + +// OpenCL Utils includes +#include + +// stb includes +#define STB_IMAGE_IMPLEMENTATION +#include +#define STB_IMAGE_WRITE_IMPLEMENTATION +#include + +// STL includes +#include // std::vector +#include + +#if __cplusplus < 201703L +#include +#else +#include +#endif + +// OpenCL includes +#include + +namespace cl { +namespace sdk { + Image read_image(const char* const file_name, cl_int* const error = nullptr) + { + cl_int err = CL_SUCCESS; + + Image im; + unsigned char* data = + stbi_load(file_name, &im.width, &im.height, &im.pixel_size, 0); + im.pixels.insert(im.pixels.end(), data, + data + im.width * im.height * im.pixel_size); + + if (im.width && im.height && im.pixel_size + && im.pixels.size() == im.width * im.height * im.pixel_size) + err = CL_SUCCESS; + else + cl::util::detail::errHandler(CL_INVALID_ARG_VALUE, &err, + "File read error!"); + + if (error != NULL) *error = err; + return im; + } + + cl_int write_image(const char* file_name, const Image& image) + { + cl_int error = CL_SUCCESS; + +#if __cplusplus >= 201703L + std::filesystem::path fn(file_name); + std::string extension = fn.extension().string(); +#else + const char* extpos = strrchr(file_name, '.'); + if (extpos == nullptr) + cl::util::detail::errHandler(CL_INVALID_ARG_VALUE, &error, + "No file extension!"); + std::string extension(extpos); +#endif + + // solution by Timmmm https://stackoverflow.com/questions/11635 + auto str_compare = [](const string& a, const string& b) { + return std::equal( + a.begin(), a.end(), b.begin(), b.end(), + [](char a, char b) { return tolower(a) == tolower(b); }); + }; + + if (str_compare(extension, ".png")) + { + if (!stbi_write_png(file_name, image.width, image.height, + image.pixel_size, image.pixels.data(), 0)) + cl::util::detail::errHandler(CL_INVALID_ARG_VALUE, &error, + "Not possible to write PNG file!"); + } + else if (str_compare(extension, ".bmp")) + { + if (!stbi_write_bmp(file_name, image.width, image.height, + image.pixel_size, image.pixels.data())) + cl::util::detail::errHandler(CL_INVALID_ARG_VALUE, &error, + "Not possible to write BMP file!"); + } + else if (str_compare(extension, ".jpg")) + { + if (!stbi_write_jpg(file_name, image.width, image.height, + image.pixel_size, image.pixels.data(), 80)) + cl::util::detail::errHandler(CL_INVALID_ARG_VALUE, &error, + "Not possible to write JPG file!"); + } + else + cl::util::detail::errHandler(CL_IMAGE_FORMAT_NOT_SUPPORTED, &error, + "Unknown file extension!"); + + return error; + } +} +} diff --git a/lib/src/SDK/InteropContext.cpp b/lib/src/SDK/InteropContext.cpp new file mode 100644 index 00000000..33e388e7 --- /dev/null +++ b/lib/src/SDK/InteropContext.cpp @@ -0,0 +1,108 @@ +// Platform includes +// +// Note: gl.h need to be included before glxew.h which will define the +// glXGetCurrent...() functions. +#ifdef _WIN32 +#define NOMINMAX +#include +#include // wglGetCurrent...() +#endif +#ifdef __linux__ +#include +#undef None +#endif + +// OpenCL SDK includes +#include + +// OpenCL Utils includes +#include + +cl::vector +cl::sdk::get_interop_context_properties(const cl::Device& device, cl_int*) +{ + return cl::vector{ + CL_CONTEXT_PLATFORM, + reinterpret_cast( + cl::Platform{ device.getInfo() }()), +#ifdef _WIN32 + CL_WGL_HDC_KHR, + reinterpret_cast(wglGetCurrentDC()), + CL_GL_CONTEXT_KHR, + reinterpret_cast(wglGetCurrentContext()), +#endif +#ifdef __linux__ + CL_GLX_DISPLAY_KHR, + reinterpret_cast(glXGetCurrentDisplay()), + CL_GL_CONTEXT_KHR, + reinterpret_cast(glXGetCurrentContext()), +#endif + 0 + }; +} + +cl::Context cl::sdk::get_interop_context(cl_uint plat_id, cl_uint dev_id, + cl_device_type type, cl_int* error) +{ + cl::vector platforms; + cl_int plat_err = cl::Platform::get(&platforms); + + if (plat_err == CL_SUCCESS) + { + if (plat_id < platforms.size()) + { + cl::vector devices; + cl_int dev_err = platforms[plat_id].getDevices(type, &devices); + + if (dev_err == CL_SUCCESS) + { + if (dev_id < devices.size()) + { + cl_int ctx_err = CL_SUCCESS; + auto props = + get_interop_context_properties(devices[dev_id]); + cl::Context context; +#if defined(CL_HPP_ENABLE_EXCEPTIONS) + try + { +#endif + context = cl::Context(devices[dev_id], props.data(), + nullptr, nullptr, &ctx_err); +#if defined(CL_HPP_ENABLE_EXCEPTIONS) + } catch (cl::Error& e) + { + ctx_err = e.err(); + } +#endif + if (ctx_err == CL_SUCCESS) + return context; + else + { + cl::util::detail::errHandler( + CL_UTIL_DEVICE_NOT_INTEROPERABLE, error, + "Selected device isn't interoperable with the " + "current OpenGL context."); + return cl::Context{}; + } + } + else + cl::util::detail::errHandler( + CL_UTIL_INDEX_OUT_OF_RANGE, error, + "Invalid device index provided for cl::Context " + "cl::sdk::get_context()"); + } + else + cl::util::detail::errHandler(plat_err, error); + } + else + cl::util::detail::errHandler(CL_UTIL_INDEX_OUT_OF_RANGE, error, + "Invalid platform index provided for " + "cl::Context cl::sdk::get_context()"); + } + else + cl::util::detail::errHandler(plat_err, error, + "Failed to get platforms inside " + "cl::Context cl::sdk::get_context()"); + + return cl::Context{}; +} diff --git a/lib/src/SDK/InteropWindow.cpp b/lib/src/SDK/InteropWindow.cpp new file mode 100644 index 00000000..97325ec2 --- /dev/null +++ b/lib/src/SDK/InteropWindow.cpp @@ -0,0 +1,43 @@ +// OpenCL SDK includes +#include +#include + +cl::sdk::InteropWindow::InteropWindow(sf::VideoMode mode, + const sf::String& title, sf::Uint32 style, + const sf::ContextSettings& settings, + cl_uint platform_id, cl_uint device_id, + cl_bitfield device_type) + : sf::Window{ mode, title, style, settings }, plat_id{ platform_id }, + dev_id{ device_id }, dev_type{ device_type } +{} + +void cl::sdk::InteropWindow::run() +{ + setActive(true); + + initializeGL(); + + opencl_context = get_interop_context(plat_id, dev_id, dev_type); + + cl_khr_gl_event_supported = opencl_context.getInfo() + .at(0) + .getInfo() + .find("cl_khr_gl_event") + != cl::string::npos; + + initializeCL(); + + while (isOpen()) + { + render(); + + display(); + + updateScene(); + + sf::Event ev; + while (pollEvent(ev)) event(ev); + } + + setActive(false); +} diff --git a/lib/src/SDK/SDK.c b/lib/src/SDK/SDK.c new file mode 100644 index 00000000..cab9ea55 --- /dev/null +++ b/lib/src/SDK/SDK.c @@ -0,0 +1,5 @@ +// OpenCL SDK includes +#include + +#include "Context.c" +#include "Image.c" diff --git a/lib/src/SDK/SDK.cpp b/lib/src/SDK/SDK.cpp new file mode 100644 index 00000000..81c083b1 --- /dev/null +++ b/lib/src/SDK/SDK.cpp @@ -0,0 +1,6 @@ +// OpenCL SDK includes +#include + +#include "Image.cpp" +#include "InteropContext.cpp" +#include "InteropWindow.cpp" diff --git a/lib/src/Utils/Context.c b/lib/src/Utils/Context.c new file mode 100644 index 00000000..7974c0a0 --- /dev/null +++ b/lib/src/Utils/Context.c @@ -0,0 +1,252 @@ +// OpenCL Utils includes +#include +#include + +// STL includes +#include // malloc, free +#include // printf + +UTILS_EXPORT +cl_context cl_util_get_context(const cl_uint plat_id, const cl_uint dev_id, + const cl_device_type type, cl_int *const error) +{ + cl_int err = CL_SUCCESS; + cl_context result = NULL; + cl_platform_id *platforms; + cl_uint num_platforms = 0; + cl_device_id *devices; + cl_uint num_devices = 0; + + OCLERROR_RET(clGetPlatformIDs(0, NULL, &num_platforms), err, end); + MEM_CHECK(platforms = (cl_platform_id *)malloc(sizeof(cl_platform_id) + * num_platforms), + err, end); + OCLERROR_RET(clGetPlatformIDs(num_platforms, platforms, NULL), err, plat); + + if (plat_id >= num_platforms) + { + fprintf(stderr, + "Invalid platform index provided for cl_util_get_context()\n"); + err = CL_UTIL_INDEX_OUT_OF_RANGE; + goto plat; + } + + OCLERROR_RET( + clGetDeviceIDs(platforms[plat_id], type, 0, NULL, &num_devices), err, + plat); + MEM_CHECK(devices = + (cl_device_id *)malloc(sizeof(cl_device_id) * num_devices), + err, plat); + OCLERROR_RET( + clGetDeviceIDs(platforms[plat_id], type, num_devices, devices, NULL), + err, dev); + + if (dev_id >= num_devices) + { + fprintf(stderr, + "Invalid device index provided for cl_util_get_context()\n"); + err = CL_UTIL_INDEX_OUT_OF_RANGE; + goto dev; + } + + OCLERROR_PAR( + result = clCreateContext(NULL, 1, devices + dev_id, NULL, NULL, &err), + err, dev); + +dev: + free(devices); +plat: + free(platforms); +end: + if (error != NULL) *error = err; + return result; +} + +UTILS_EXPORT +cl_device_id cl_util_get_device(const cl_uint plat_id, const cl_uint dev_id, + const cl_device_type type, cl_int *const error) +{ + cl_int err = CL_SUCCESS; + cl_device_id result = NULL; + cl_platform_id *platforms; + cl_uint num_platforms = 0; + cl_device_id *devices; + cl_uint num_devices = 0; + + OCLERROR_RET(clGetPlatformIDs(0, NULL, &num_platforms), err, end); + MEM_CHECK(platforms = (cl_platform_id *)malloc(sizeof(cl_platform_id) + * num_platforms), + err, end); + OCLERROR_RET(clGetPlatformIDs(num_platforms, platforms, NULL), err, plat); + + if (plat_id >= num_platforms) + { + fprintf(stderr, + "Invalid platform index provided for cl_util_get_context()\n"); + err = CL_UTIL_INDEX_OUT_OF_RANGE; + goto plat; + } + + OCLERROR_RET( + clGetDeviceIDs(platforms[plat_id], type, 0, NULL, &num_devices), err, + plat); + MEM_CHECK(devices = + (cl_device_id *)malloc(sizeof(cl_device_id) * num_devices), + err, plat); + OCLERROR_RET( + clGetDeviceIDs(platforms[plat_id], type, num_devices, devices, NULL), + err, dev); + + if (dev_id >= num_devices) + { + fprintf(stderr, + "Invalid device index provided for cl_util_get_context()\n"); + err = CL_UTIL_INDEX_OUT_OF_RANGE; + goto dev; + } + + result = devices[dev_id]; + +dev: + free(devices); +plat: + free(platforms); +end: + if (error != NULL) *error = err; + return result; +} + +UTILS_EXPORT +cl_int cl_util_print_device_info(const cl_device_id device) +{ + cl_int error = CL_SUCCESS; + char *name = NULL; + + cl_platform_id platform; + OCLERROR_PAR(clGetDeviceInfo(device, CL_DEVICE_PLATFORM, + sizeof(cl_platform_id), &platform, NULL), + error, nam); + + OCLERROR_PAR( + name = cl_util_get_platform_info(platform, CL_PLATFORM_VENDOR, &error), + error, ven); + printf("Selected platform by %s\n", name); + +ven: + free(name); + OCLERROR_PAR(name = cl_util_get_device_info(device, CL_DEVICE_NAME, &error), + error, ocl); + printf("Selected device: %s\n", name); + +ocl: + free(name); + OCLERROR_PAR(name = cl_util_get_device_info( + device, CL_DEVICE_OPENCL_C_VERSION, &error), + error, nam); + printf("%s\n\n", name); + +nam: + free(name); + return error; +} + +UTILS_EXPORT +char *cl_util_get_platform_info(const cl_platform_id platform, + const cl_platform_info info, + cl_int *const error) +{ + cl_int err = CL_SUCCESS; + char *name = NULL; + size_t n = 0; + + switch (info) + { + case CL_PLATFORM_PROFILE: + case CL_PLATFORM_VERSION: + case CL_PLATFORM_NAME: + case CL_PLATFORM_VENDOR: + case CL_PLATFORM_EXTENSIONS: + OCLERROR_RET(clGetPlatformInfo(platform, info, 0, NULL, &n), err, + end); + MEM_CHECK(name = (char *)malloc(sizeof(char) * (n + 1)), err, end); + OCLERROR_RET( + clGetPlatformInfo(platform, info, sizeof(char) * n, name, NULL), + err, end); + name[n] = '\0'; + if (error != NULL) *error = err; + return name; + } + +end: + free(name); + if (error != NULL) *error = err; + return NULL; +} + +UTILS_EXPORT +char *cl_util_get_device_info(const cl_device_id device, + const cl_device_info info, cl_int *const error) +{ + cl_int err = CL_SUCCESS; + char *name = NULL; + size_t n = 0; + + switch (info) + { + case CL_DEVICE_EXTENSIONS: + case CL_DEVICE_NAME: + case CL_DEVICE_VENDOR: + case CL_DEVICE_PROFILE: + case CL_DEVICE_VERSION: +#ifdef CL_VERSION_1_1 + case CL_DEVICE_OPENCL_C_VERSION: +#endif +#ifdef CL_VERSION_1_2 + case CL_DEVICE_BUILT_IN_KERNELS: +#endif +#ifdef CL_VERSION_2_1 + case CL_DEVICE_IL_VERSION: +#endif +#ifdef CL_VERSION_3_0 + case CL_DEVICE_LATEST_CONFORMANCE_VERSION_PASSED: +#endif + case CL_DRIVER_VERSION: + OCLERROR_RET(clGetDeviceInfo(device, info, 0, NULL, &n), err, end); + MEM_CHECK(name = (char *)malloc(sizeof(char) * (n + 1)), err, end); + OCLERROR_RET( + clGetDeviceInfo(device, info, sizeof(char) * n, name, NULL), + err, end); + name[n] = '\0'; + if (error != NULL) *error = err; + return name; + } + +end: + free(name); + if (error != NULL) *error = err; + return NULL; +} + +// build program and show log if build is not successful +UTILS_EXPORT +cl_int cl_util_build_program(const cl_program pr, const cl_device_id dev, + const char *const opt) +{ + cl_int err = clBuildProgram(pr, 1, &dev, opt, NULL, NULL); + if (err != CL_SUCCESS) + { // no error handling here as error from build program is more valuable + char *program_log; + size_t log_size = 0; + clGetProgramBuildInfo(pr, dev, CL_PROGRAM_BUILD_LOG, 0, NULL, + &log_size); + if ((program_log = (char *)malloc((log_size + 1) * sizeof(char)))) + { + clGetProgramBuildInfo(pr, dev, CL_PROGRAM_BUILD_LOG, log_size, + program_log, NULL); + program_log[log_size] = '\0'; + printf("Build log is:\n\n%s\nOptions:\n%s\n\n", program_log, opt); + free(program_log); + } + } + return err; +} diff --git a/lib/src/Utils/Context.cpp b/lib/src/Utils/Context.cpp new file mode 100644 index 00000000..7882998f --- /dev/null +++ b/lib/src/Utils/Context.cpp @@ -0,0 +1,42 @@ +// OpenCL SDK includes +#include + +cl::Context cl::util::get_context(cl_uint plat_id, cl_uint dev_id, + cl_device_type type, cl_int* error) +{ + cl::vector platforms; + cl_int plat_err = cl::Platform::get(&platforms); + + if (plat_err == CL_SUCCESS) + { + if (plat_id < platforms.size()) + { + cl::vector devices; + cl_int dev_err = platforms[plat_id].getDevices(type, &devices); + + if (dev_err == CL_SUCCESS) + { + if (dev_id < devices.size()) + { + return cl::Context(devices[dev_id]); + } + else + detail::errHandler(CL_UTIL_INDEX_OUT_OF_RANGE, error, + "Invalid device index provided for " + "cl::Context cl::sdk::get_context()"); + } + else + detail::errHandler(dev_err, error); + } + else + detail::errHandler(CL_UTIL_INDEX_OUT_OF_RANGE, error, + "Invalid platform index provided for " + "cl::Context cl::sdk::get_context()"); + } + else + detail::errHandler(plat_err, error, + "Failed to get platforms inside cl::Context " + "cl::sdk::get_context()"); + + return cl::Context{}; +} diff --git a/lib/src/Utils/Device.cpp b/lib/src/Utils/Device.cpp new file mode 100644 index 00000000..fab39c99 --- /dev/null +++ b/lib/src/Utils/Device.cpp @@ -0,0 +1,31 @@ +#include + +#include + +bool cl::util::opencl_c_version_contains(const cl::Device& device, + const cl::string& version_fragment) +{ + return device.getInfo().find(version_fragment) + != cl::string::npos; +} + +bool cl::util::supports_extension(const cl::Device& device, + const cl::string& extension) +{ + return device.getInfo().find(extension) + != cl::string::npos; +} + +#ifdef CL_VERSION_3_0 +bool cl::util::supports_feature(const cl::Device& device, + const cl::string& feature_name) +{ + auto c_features = device.getInfo(); + auto feature_is_work_group_reduce = [&](const cl_name_version& name_ver) { + return cl::string{ name_ver.name } == feature_name; + }; + return std::find_if(c_features.cbegin(), c_features.cend(), + feature_is_work_group_reduce) + != c_features.cend(); +} +#endif diff --git a/lib/src/Utils/Error.c b/lib/src/Utils/Error.c new file mode 100644 index 00000000..ac00dbe2 --- /dev/null +++ b/lib/src/Utils/Error.c @@ -0,0 +1,221 @@ +// OpenCL Utils includes +#include + +void cl_util_print_error(const cl_int error) +{ + switch (error) + { + case CL_SUCCESS: break; + case CL_DEVICE_NOT_FOUND: + fprintf(stderr, "\nError: CL_DEVICE_NOT_FOUND\n"); + break; + case CL_DEVICE_NOT_AVAILABLE: + fprintf(stderr, "\nError: CL_DEVICE_NOT_AVAILABLE\n"); + break; + case CL_COMPILER_NOT_AVAILABLE: + fprintf(stderr, "\nError: CL_COMPILER_NOT_AVAILABLE\n"); + break; + case CL_MEM_OBJECT_ALLOCATION_FAILURE: + fprintf(stderr, "\nError: CL_MEM_OBJECT_ALLOCATION_FAILURE\n"); + break; + case CL_OUT_OF_RESOURCES: + fprintf(stderr, "\nError: CL_OUT_OF_RESOURCES\n"); + break; + case CL_OUT_OF_HOST_MEMORY: + fprintf(stderr, "\nError: CL_OUT_OF_HOST_MEMORY\n"); + break; + case CL_PROFILING_INFO_NOT_AVAILABLE: + fprintf(stderr, "\nError: CL_PROFILING_INFO_NOT_AVAILABLE\n"); + break; + case CL_MEM_COPY_OVERLAP: + fprintf(stderr, "\nError: CL_MEM_COPY_OVERLAP\n"); + break; + case CL_IMAGE_FORMAT_MISMATCH: + fprintf(stderr, "\nError: CL_IMAGE_FORMAT_MISMATCH\n"); + break; + case CL_IMAGE_FORMAT_NOT_SUPPORTED: + fprintf(stderr, "\nError: CL_IMAGE_FORMAT_NOT_SUPPORTED\n"); + break; + case CL_BUILD_PROGRAM_FAILURE: + fprintf(stderr, "\nError: CL_BUILD_PROGRAM_FAILURE\n"); + break; + case CL_MAP_FAILURE: + fprintf(stderr, "\nError: CL_MAP_FAILURE\n"); + break; +#ifdef CL_VERSION_1_1 + case CL_MISALIGNED_SUB_BUFFER_OFFSET: + fprintf(stderr, "\nError: CL_MISALIGNED_SUB_BUFFER_OFFSET\n"); + break; + case CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST: + fprintf(stderr, + "\nError: CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST\n"); + break; +#endif +#ifdef CL_VERSION_1_2 + case CL_COMPILE_PROGRAM_FAILURE: + fprintf(stderr, "\nError: CL_COMPILE_PROGRAM_FAILURE\n"); + break; + case CL_LINKER_NOT_AVAILABLE: + fprintf(stderr, "\nError: CL_LINKER_NOT_AVAILABLE\n"); + break; + case CL_LINK_PROGRAM_FAILURE: + fprintf(stderr, "\nError: CL_LINK_PROGRAM_FAILURE\n"); + break; + case CL_DEVICE_PARTITION_FAILED: + fprintf(stderr, "\nError: CL_DEVICE_PARTITION_FAILED\n"); + break; + case CL_KERNEL_ARG_INFO_NOT_AVAILABLE: + fprintf(stderr, "\nError: CL_KERNEL_ARG_INFO_NOT_AVAILABLE\n"); + break; +#endif + case CL_INVALID_VALUE: + fprintf(stderr, "\nError: CL_INVALID_VALUE\n"); + break; + case CL_INVALID_DEVICE_TYPE: + fprintf(stderr, "\nError: CL_INVALID_DEVICE_TYPE\n"); + break; + case CL_INVALID_PLATFORM: + fprintf(stderr, "\nError: CL_INVALID_PLATFORM\n"); + break; + case CL_INVALID_DEVICE: + fprintf(stderr, "\nError: CL_INVALID_DEVICE\n"); + break; + case CL_INVALID_CONTEXT: + fprintf(stderr, "\nError: CL_INVALID_CONTEXT\n"); + break; + case CL_INVALID_QUEUE_PROPERTIES: + fprintf(stderr, "\nError: CL_INVALID_QUEUE_PROPERTIES\n"); + break; + case CL_INVALID_COMMAND_QUEUE: + fprintf(stderr, "\nError: CL_INVALID_COMMAND_QUEUE\n"); + break; + case CL_INVALID_HOST_PTR: + fprintf(stderr, "\nError: CL_INVALID_HOST_PTR\n"); + break; + case CL_INVALID_MEM_OBJECT: + fprintf(stderr, "\nError: CL_INVALID_MEM_OBJECT\n"); + break; + case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR: + fprintf(stderr, "\nError: CL_INVALID_IMAGE_FORMAT_DESCRIPTOR\n"); + break; + case CL_INVALID_IMAGE_SIZE: + fprintf(stderr, "\nError: CL_INVALID_IMAGE_SIZE\n"); + break; + case CL_INVALID_SAMPLER: + fprintf(stderr, "\nError: CL_INVALID_SAMPLER\n"); + break; + case CL_INVALID_BINARY: + fprintf(stderr, "\nError: CL_INVALID_BINARY\n"); + break; + case CL_INVALID_BUILD_OPTIONS: + fprintf(stderr, "\nError: CL_INVALID_BUILD_OPTIONS\n"); + break; + case CL_INVALID_PROGRAM: + fprintf(stderr, "\nError: CL_INVALID_PROGRAM\n"); + break; + case CL_INVALID_PROGRAM_EXECUTABLE: + fprintf(stderr, "\nError: CL_INVALID_PROGRAM_EXECUTABLE\n"); + break; + case CL_INVALID_KERNEL_NAME: + fprintf(stderr, "\nError: CL_INVALID_KERNEL_NAME\n"); + break; + case CL_INVALID_KERNEL_DEFINITION: + fprintf(stderr, "\nError: CL_INVALID_KERNEL_DEFINITION\n"); + break; + case CL_INVALID_KERNEL: + fprintf(stderr, "\nError: CL_INVALID_KERNEL\n"); + break; + case CL_INVALID_ARG_INDEX: + fprintf(stderr, "\nError: CL_INVALID_ARG_INDEX\n"); + break; + case CL_INVALID_ARG_VALUE: + fprintf(stderr, "\nError: CL_INVALID_ARG_VALUE\n"); + break; + case CL_INVALID_ARG_SIZE: + fprintf(stderr, "\nError: CL_INVALID_ARG_SIZE\n"); + break; + case CL_INVALID_KERNEL_ARGS: + fprintf(stderr, "\nError: CL_INVALID_KERNEL_ARGS\n"); + break; + case CL_INVALID_WORK_DIMENSION: + fprintf(stderr, "\nError: CL_INVALID_WORK_DIMENSION\n"); + break; + case CL_INVALID_WORK_GROUP_SIZE: + fprintf(stderr, "\nError: CL_INVALID_WORK_GROUP_SIZE\n"); + break; + case CL_INVALID_WORK_ITEM_SIZE: + fprintf(stderr, "\nError: CL_INVALID_WORK_ITEM_SIZE\n"); + break; + case CL_INVALID_GLOBAL_OFFSET: + fprintf(stderr, "\nError: CL_INVALID_GLOBAL_OFFSET\n"); + break; + case CL_INVALID_EVENT_WAIT_LIST: + fprintf(stderr, "\nError: CL_INVALID_EVENT_WAIT_LIST\n"); + break; + case CL_INVALID_EVENT: + fprintf(stderr, "\nError: CL_INVALID_EVENT\n"); + break; + case CL_INVALID_OPERATION: + fprintf(stderr, "\nError: CL_INVALID_OPERATION\n"); + break; + case CL_INVALID_GL_OBJECT: + fprintf(stderr, "\nError: CL_INVALID_GL_OBJECT\n"); + break; + case CL_INVALID_BUFFER_SIZE: + fprintf(stderr, "\nError: CL_INVALID_BUFFER_SIZE\n"); + break; + case CL_INVALID_MIP_LEVEL: + fprintf(stderr, "\nError: CL_INVALID_MIP_LEVEL\n"); + break; + case CL_INVALID_GLOBAL_WORK_SIZE: + fprintf(stderr, "\nError: CL_INVALID_GLOBAL_WORK_SIZE\n"); + break; +#ifdef CL_VERSION_1_1 + case CL_INVALID_PROPERTY: + fprintf(stderr, "\nError: CL_INVALID_PROPERTY\n"); + break; +#endif +#ifdef CL_VERSION_1_2 + case CL_INVALID_IMAGE_DESCRIPTOR: + fprintf(stderr, "\nError: CL_INVALID_IMAGE_DESCRIPTOR\n"); + break; + case CL_INVALID_COMPILER_OPTIONS: + fprintf(stderr, "\nError: CL_INVALID_COMPILER_OPTIONS\n"); + break; + case CL_INVALID_LINKER_OPTIONS: + fprintf(stderr, "\nError: CL_INVALID_LINKER_OPTIONS\n"); + break; + case CL_INVALID_DEVICE_PARTITION_COUNT: + fprintf(stderr, "\nError: CL_INVALID_DEVICE_PARTITION_COUNT\n"); + break; +#endif +#ifdef CL_VERSION_2_0 + case CL_INVALID_PIPE_SIZE: + fprintf(stderr, "\nError: CL_INVALID_PIPE_SIZE\n"); + break; + case CL_INVALID_DEVICE_QUEUE: + fprintf(stderr, "\nError: CL_INVALID_DEVICE_QUEUE\n"); + break; +#endif +#ifdef CL_VERSION_2_2 + case CL_INVALID_SPEC_ID: + fprintf(stderr, "\nError: CL_INVALID_SPEC_ID\n"); + break; + case CL_MAX_SIZE_RESTRICTION_EXCEEDED: + fprintf(stderr, "\nError: CL_MAX_SIZE_RESTRICTION_EXCEEDED\n"); + break; +#endif + // SDK errors + case CL_UTIL_INDEX_OUT_OF_RANGE: + fprintf(stderr, "\nError: CL_UTIL_INDEX_OUT_OF_RANGE\n"); + break; + case CL_UTIL_DEVICE_NOT_INTEROPERABLE: + fprintf(stderr, "\nError: CL_UTIL_DEVICE_NOT_INTEROPERABLE\n"); + break; + case CL_UTIL_FILE_OPERATION_ERROR: + fprintf(stderr, "\nError: CL_UTIL_FILE_OPERATION_ERROR\n"); + break; + // end of SDK errors + default: fprintf(stderr, "\nUnknown error: %i\n", error); break; + } +} diff --git a/lib/src/Utils/Error.cpp b/lib/src/Utils/Error.cpp new file mode 100644 index 00000000..fbfcc925 --- /dev/null +++ b/lib/src/Utils/Error.cpp @@ -0,0 +1,19 @@ +// OpenCL SDK includes +#include + +#if defined(CL_HPP_ENABLE_EXCEPTIONS) +cl_int cl::util::detail::errHandler(cl_int err, cl_int*, const char* errStr) +{ + if (err != CL_SUCCESS) throw cl::util::Error{ err, errStr }; + return err; +} +#else +cl_int cl::util::detail::errHandler(cl_int err, cl_int* errPtr, const char*) +{ + if (err != CL_SUCCESS) + { + if (errPtr != nullptr) *errPtr = err; + } + return err; +} +#endif \ No newline at end of file diff --git a/lib/src/Utils/Event.c b/lib/src/Utils/Event.c new file mode 100644 index 00000000..f770e9a3 --- /dev/null +++ b/lib/src/Utils/Event.c @@ -0,0 +1,23 @@ +// OpenCL Utils includes +#include + +cl_ulong cl_util_get_event_duration(const cl_event event, + const cl_profiling_info start, + const cl_profiling_info end, + cl_int* const error) +{ + cl_int err = CL_SUCCESS; + cl_ulong start_time = 0, end_time = 0; + OCLERROR_RET(clGetEventProfilingInfo(event, start, sizeof(cl_ulong), + &start_time, NULL), + err, end); + OCLERROR_RET( + clGetEventProfilingInfo(event, end, sizeof(cl_ulong), &end_time, NULL), + err, end); + if (error != NULL) *error = err; + return end_time - start_time; + +end: + if (error != NULL) *error = err; + return 0; +} diff --git a/lib/src/Utils/File.c b/lib/src/Utils/File.c new file mode 100644 index 00000000..f4488342 --- /dev/null +++ b/lib/src/Utils/File.c @@ -0,0 +1,331 @@ +// OpenCL SDK includes +#include + +// STL includes +#include // realloc, free +#include // fopen, ferror, fread, fclose +#include // memset + +// read all the text file contents securely in ANSI C89 +// return pointer to C-string with file contents +// can handle streams with no known size and no support for fseek +// based on https://stackoverflow.com/questions/14002954/ by Nominal Animal +UTILS_EXPORT +char *cl_util_read_text_file(const char *const filename, size_t *const length, + cl_int *const error) +{ + cl_int err = CL_SUCCESS; + char *data = NULL, *temp; + size_t size = 0; + size_t used = 0; + size_t n; + FILE *in; + + /* Size of each input chunk to be read and allocate for. */ +#define READALL_CHUNK 2097152 + +#define IF_ERR(func, error_type, label) \ + do \ + { \ + if (func) \ + { \ + err = error_type; \ + goto label; \ + } \ + } while (0) + + /* File name can not be NULL. */ + IF_ERR(!filename, CL_INVALID_ARG_VALUE, end); + + /* Open file. */ + IF_ERR(!(in = fopen(filename, "r")), CL_INVALID_VALUE, end); + + /* A read error already occurred? */ + IF_ERR(ferror(in), CL_UTIL_FILE_OPERATION_ERROR, fl); + + while (1) + { + if (used + READALL_CHUNK + 1 > size) + { + size = used + READALL_CHUNK + 1; + + /* Overflow check. */ + IF_ERR(size <= used, CL_OUT_OF_RESOURCES, nodata); + + MEM_CHECK(temp = (char *)realloc(data, size), err, nodata); + data = temp; + } + + /* Read file in chunks. */ + n = fread(data + used, 1, READALL_CHUNK, in); + if (n == 0) break; + + used += n; + } + + /* A read error already occurred? */ + IF_ERR(ferror(in), CL_UTIL_FILE_OPERATION_ERROR, nodata); + + /* Put null termination. */ + MEM_CHECK(temp = (char *)realloc(data, used + 1), err, nodata); + data = temp; + data[used] = '\0'; + if (length != NULL) *length = used; + +fl: + fclose(in); +end: + if (error != NULL) *error = err; + return data; + +nodata: + fclose(in); + free(data); + if (error != NULL) *error = err; + return NULL; + +#undef IF_ERR +} + +UTILS_EXPORT +unsigned char *cl_util_read_binary_file(const char *const filename, + size_t *const length, + cl_int *const error) +{ + cl_int err = CL_SUCCESS; + unsigned char *data = NULL, *temp; + size_t size = 0; + size_t used = 0; + size_t n; + FILE *in; + + /* Size of each input chunk to be read and allocate for. */ +#define READALL_CHUNK 2097152 + +#define IF_ERR(func, error_type, label) \ + do \ + { \ + if (func) \ + { \ + err = error_type; \ + goto label; \ + } \ + } while (0) + + /* File name can not be NULL. */ + IF_ERR(!filename, CL_INVALID_ARG_VALUE, end); + + /* Open file. */ + IF_ERR(!(in = fopen(filename, "rb")), CL_INVALID_VALUE, end); + + /* A read error already occurred? */ + IF_ERR(ferror(in), CL_UTIL_FILE_OPERATION_ERROR, fl); + + while (1) + { + if (used + READALL_CHUNK + 1 > size) + { + size = used + READALL_CHUNK + 1; + + /* Overflow check. */ + IF_ERR(size <= used, CL_OUT_OF_RESOURCES, nodata); + + MEM_CHECK(temp = (unsigned char *)realloc(data, size), err, nodata); + data = temp; + } + + /* Read file in chunks. */ + n = fread(data + used, 1, READALL_CHUNK, in); + if (n == 0) break; + + used += n; + } + + /* A read error already occurred? */ + IF_ERR(ferror(in), CL_UTIL_FILE_OPERATION_ERROR, nodata); + + /* Truncate to the real size. */ + MEM_CHECK(temp = (unsigned char *)realloc(data, used), err, nodata); + data = temp; + if (length != NULL) *length = used; + +fl: + fclose(in); +end: + if (error != NULL) *error = err; + return data; + +nodata: + fclose(in); + free(data); + if (error != NULL) *error = err; + return NULL; + +#undef IF_ERR +} + +// function to write binaries of OpenCL compiled program +// binaries are written as separate files for each device +// with file name "(program_file_name)_(name of device).bin" +// based on variant of Logan +// http://logan.tw/posts/2014/11/22/pre-compile-the-opencl-kernel-program-part-2/ +UTILS_EXPORT +cl_int cl_util_write_binaries(const cl_program program, + const char *const program_file_name) +{ + cl_int error = CL_SUCCESS; + + cl_uint num_devices = 0; + size_t binaries_size_alloc_size = 0; + size_t binaries_ptr_alloc_size = 0; + size_t *binaries_size = NULL; + unsigned char **binaries_ptr = NULL; + cl_device_id *devices = NULL; + + // read number of devices + OCLERROR_RET(clGetProgramInfo(program, CL_PROGRAM_NUM_DEVICES, + sizeof(cl_uint), &num_devices, NULL), + error, end); + if (num_devices == 0) return CL_INVALID_PROGRAM_EXECUTABLE; + + // read the binaries size + binaries_size_alloc_size = sizeof(size_t) * num_devices; + MEM_CHECK(binaries_size = (size_t *)malloc(binaries_size_alloc_size), error, + end); + + OCLERROR_RET(clGetProgramInfo(program, CL_PROGRAM_BINARY_SIZES, + binaries_size_alloc_size, binaries_size, + NULL), + error, end); + + // read the binaries + binaries_ptr_alloc_size = sizeof(unsigned char *) * num_devices; + MEM_CHECK(binaries_ptr = (unsigned char **)malloc(binaries_ptr_alloc_size), + error, end); + memset(binaries_ptr, 0, binaries_ptr_alloc_size); + + for (cl_uint i = 0; i < num_devices; ++i) + MEM_CHECK(binaries_ptr[i] = (unsigned char *)malloc(binaries_size[i]), + error, end); + + OCLERROR_RET(clGetProgramInfo(program, CL_PROGRAM_BINARIES, + binaries_ptr_alloc_size, binaries_ptr, NULL), + error, end); + + // query devices + MEM_CHECK(devices = + (cl_device_id *)malloc(sizeof(cl_device_id) * num_devices), + error, end); + OCLERROR_RET(clGetProgramInfo(program, CL_PROGRAM_DEVICES, + sizeof(cl_device_id) * num_devices, devices, + NULL), + error, end); + + // write the binaries to files + for (cl_uint i = 0; i < num_devices; ++i) + { + // get device name + char name_data[201]; + OCLERROR_RET(clGetDeviceInfo(devices[i], CL_DEVICE_NAME, + sizeof(name_data) - 1, name_data, NULL), + error, end); + name_data[200] = '\0'; + // create output file name + char filename[256]; + snprintf(filename, sizeof(filename), "%s-%s.bin", program_file_name, + name_data); + + // write the binary to the output file + FILE *f = fopen(filename, "wb"); + if (f != NULL) + { + if (fwrite(binaries_ptr[i], sizeof(unsigned char), binaries_size[i], + f) + != binaries_size[i]) + error = CL_UTIL_FILE_OPERATION_ERROR; + fclose(f); + } + else + error = CL_INVALID_VALUE; + } + +end: // cleanup + if (binaries_ptr != NULL) + { + for (cl_uint i = 0; i < num_devices; ++i) free(binaries_ptr[i]); + free(binaries_ptr); + } + free(binaries_size); + + return error; +} + +// function to read binaries of OpenCL compiled program +// read binaries from files of file names "(program_file_name)_(name of +// device).bin" +UTILS_EXPORT +cl_program cl_util_read_binaries(const cl_context context, + const cl_device_id *const devices, + const cl_uint num_devices, + const char *const program_file_name, + cl_int *const error) +{ + cl_int err = CL_SUCCESS; + size_t binaries_size_alloc_size = 0; + size_t binaries_ptr_alloc_size = 0; + size_t *binaries_size = NULL; + unsigned char **binaries_ptr = NULL; + cl_program program = NULL; + + // array for binaries' sizes + binaries_size_alloc_size = sizeof(size_t) * num_devices; + MEM_CHECK(binaries_size = (size_t *)malloc(binaries_size_alloc_size), err, + end); + + // array for the binaries + binaries_ptr_alloc_size = sizeof(unsigned char *) * num_devices; + MEM_CHECK(binaries_ptr = (unsigned char **)malloc(binaries_ptr_alloc_size), + err, end); + memset(binaries_ptr, 0, binaries_ptr_alloc_size); + + // read binaries from files + for (cl_uint i = 0; i < num_devices; ++i) + { + // get device name + char name_data[201]; + OCLERROR_RET(clGetDeviceInfo(devices[i], CL_DEVICE_NAME, + sizeof(name_data) - 1, name_data, NULL), + err, end); + name_data[200] = '\0'; + // create input file name + char filename[256]; + snprintf(filename, sizeof(filename), "%s-%s.bin", program_file_name, + name_data); + + binaries_ptr[i] = + cl_util_read_binary_file(filename, binaries_size + i, &err); + if (err == CL_INVALID_VALUE) + { + fprintf(stderr, "No suitable file %s found\n", filename); + goto end; + } + else if (err != CL_SUCCESS) + goto end; + } + + OCLERROR_PAR(program = clCreateProgramWithBinary( + context, num_devices, devices, binaries_size, + (const unsigned char **)binaries_ptr, &err, NULL), + err, end); + +end: // cleanup + if (binaries_ptr != NULL) + { + for (cl_uint i = 0; i < num_devices; ++i) free(binaries_ptr[i]); + free(binaries_ptr); + } + free(binaries_size); + + if (error != NULL) *error = err; + return program; +} diff --git a/lib/src/Utils/Platform.cpp b/lib/src/Utils/Platform.cpp new file mode 100644 index 00000000..bc26de50 --- /dev/null +++ b/lib/src/Utils/Platform.cpp @@ -0,0 +1,15 @@ +#include + +bool cl::util::supports_extension(const cl::Platform& platform, + const cl::string& extension) +{ + return platform.getInfo().find(extension) + != cl::string::npos; +} + +bool cl::util::platform_version_contains(const cl::Platform& platform, + const cl::string& version_fragment) +{ + return platform.getInfo().find(version_fragment) + != cl::string::npos; +} \ No newline at end of file diff --git a/lib/src/Utils/Utils.c b/lib/src/Utils/Utils.c new file mode 100644 index 00000000..e28a2dfd --- /dev/null +++ b/lib/src/Utils/Utils.c @@ -0,0 +1,7 @@ +// OpenCL Utils includes +#include + +#include "Error.c" +#include "File.c" +#include "Context.c" +#include "Event.c" diff --git a/lib/src/Utils/Utils.cpp b/lib/src/Utils/Utils.cpp new file mode 100644 index 00000000..5bbea86f --- /dev/null +++ b/lib/src/Utils/Utils.cpp @@ -0,0 +1,7 @@ +// OpenCL Utils includes +#include + +#include "Error.cpp" +#include "Platform.cpp" +#include "Device.cpp" +#include "Context.cpp" diff --git a/samples/CMakeLists.txt b/samples/CMakeLists.txt index bbf33380..0834853a 100644 --- a/samples/CMakeLists.txt +++ b/samples/CMakeLists.txt @@ -18,6 +18,11 @@ else() set(OPENCL_SAMPLE_CONFIGS ${CMAKE_BUILD_TYPE}) endif() +# add math library to link if needed +# method by Michael Ambrus, https://stackoverflow.com/questions/34625627 +include(CheckLibraryExists) +CHECK_LIBRARY_EXISTS(m sin "" HAVE_LIB_M) + # Usage: # add_sample( # TEST # optional, adds a ctest for the sample @@ -29,10 +34,10 @@ endif() # INCLUDES ... # optional, specifies additional include directories for the sample # LIBS ... # optional, specifies additional libraries for the sample # ) -function(add_sample) +macro(add_sample) set(options TEST) set(one_value_args TARGET VERSION CATEGORY) - set(multi_value_args SOURCES KERNELS INCLUDES LIBS) + set(multi_value_args SOURCES KERNELS SHADERS INCLUDES LIBS) cmake_parse_arguments(OPENCL_SAMPLE "${options}" "${one_value_args}" "${multi_value_args}" ${ARGN} @@ -45,27 +50,99 @@ function(add_sample) add_executable(${OPENCL_SAMPLE_TARGET} ${OPENCL_SAMPLE_SOURCES}) - target_include_directories(${OPENCL_SAMPLE_TARGET} PRIVATE ${OPENCL_SDK_INCLUDE_DIRS} ${OPENCL_SAMPLE_INCLUDES}) - target_link_libraries(${OPENCL_SAMPLE_TARGET} OpenCL ${OPENCL_SAMPLE_LIBS}) + target_include_directories(${OPENCL_SAMPLE_TARGET} + PRIVATE + ${OPENCL_SDK_INCLUDE_DIRS} + ${OPENCL_SAMPLE_INCLUDES} + ) + target_link_libraries(${OPENCL_SAMPLE_TARGET} + PRIVATE + cargs + OpenCL::Headers + OpenCL::HeadersCpp + OpenCL::OpenCL + OpenCL::Utils + OpenCL::UtilsCpp + OpenCL::SDK + OpenCL::SDKCpp + $<$:m> + ${OPENCL_SAMPLE_LIBS} + ) + target_compile_definitions(${OPENCL_SAMPLE_TARGET} + PRIVATE + CL_TARGET_OPENCL_VERSION=${OPENCL_SAMPLE_VERSION} + CL_HPP_TARGET_OPENCL_VERSION=${OPENCL_SAMPLE_VERSION} + CL_HPP_MINIMUM_OPENCL_VERSION=${OPENCL_SAMPLE_VERSION} + CL_HPP_ENABLE_EXCEPTIONS + $<$:_CRT_SECURE_NO_WARNINGS> # TODO: remove + ) + + set_target_properties(${OPENCL_SAMPLE_TARGET} + PROPERTIES + RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_BINDIR}" + INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}" + FOLDER "Samples/${OPENCL_SAMPLE_CATEGORY}/${OPENCL_SAMPLE_TARGET}" + ) - target_compile_definitions(${OPENCL_SAMPLE_TARGET} PRIVATE CL_HPP_ENABLE_EXCEPTIONS) - target_compile_definitions(${OPENCL_SAMPLE_TARGET} PRIVATE CL_TARGET_OPENCL_VERSION=${OPENCL_SAMPLE_VERSION}) - target_compile_definitions(${OPENCL_SAMPLE_TARGET} PRIVATE CL_HPP_TARGET_OPENCL_VERSION=${OPENCL_SAMPLE_VERSION}) - target_compile_definitions(${OPENCL_SAMPLE_TARGET} PRIVATE CL_HPP_MINIMUM_OPENCL_VERSION=${OPENCL_SAMPLE_VERSION}) - if (WIN32) - target_compile_definitions(${OPENCL_SAMPLE_TARGET} PRIVATE _CRT_SECURE_NO_WARNINGS) + # We register utility targets that copy kernel/shader code to build tree so that samples can be run from there. + # We can't use OPENCL_SAMPLE_TARGET-device-code as a target name, because we often have two samples (C and CXX) + # refering to the same device source code. Instead we use CURRENT_FOLDER_NAME and check for the utility target + # already existing. If it does, we don't register redundant custom_commands and targets. (They would only cause + # conflicting jobs in parallel MSBuild builds. Ninja is smart enough.) Either way, we add a convenience dependence + # of OPENCL_SAMPLE_TARGET on the utility to make sure building the host code copies kernels too. + get_filename_component(CURRENT_FOLDER_NAME ${CMAKE_CURRENT_SOURCE_DIR} NAME) + if(NOT TARGET ${CURRENT_FOLDER_NAME}-device-code) + set(DEVICE_CODE_OUTPUTS) + foreach(DEVICE_CODE_SOURCE IN LISTS OPENCL_SAMPLE_KERNELS OPENCL_SAMPLE_SHADERS) + # NOTE: if() and foreach() could be omitted if CMake ver > 3.20 (COMMAND and OUTPUT needs genexpr) + if(CMAKE_CONFIGURATION_TYPES) + foreach(CONFIG_TYPE IN LISTS CMAKE_CONFIGURATION_TYPES) + add_custom_command( + OUTPUT "${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_BINDIR}/${CONFIG_TYPE}/${DEVICE_CODE_SOURCE}" + COMMAND ${CMAKE_COMMAND} + ARGS -E copy_if_different + "${CMAKE_CURRENT_LIST_DIR}/${DEVICE_CODE_SOURCE}" + "${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_BINDIR}/${CONFIG_TYPE}/${DEVICE_CODE_SOURCE}" + DEPENDS ${DEVICE_CODE_SOURCE} + COMMENT "Copying ${DEVICE_CODE_SOURCE}" + ) + list(APPEND DEVICE_CODE_OUTPUTS "${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_BINDIR}/${CONFIG_TYPE}/${DEVICE_CODE_SOURCE}") + endforeach() + else() + add_custom_command( + OUTPUT "${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_BINDIR}/${DEVICE_CODE_SOURCE}" + COMMAND ${CMAKE_COMMAND} + ARGS -E copy_if_different + "${CMAKE_CURRENT_LIST_DIR}/${DEVICE_CODE_SOURCE}" + "${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_BINDIR}/${DEVICE_CODE_SOURCE}" + DEPENDS ${DEVICE_CODE_SOURCE} + COMMENT "Copying ${DEVICE_CODE_SOURCE}" + ) + list(APPEND DEVICE_CODE_OUTPUTS "${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_BINDIR}/${DEVICE_CODE_SOURCE}") + endif() + endforeach() + add_custom_target(${CURRENT_FOLDER_NAME}-device-code + DEPENDS ${DEVICE_CODE_OUTPUTS} + ) endif() - - set_target_properties(${OPENCL_SAMPLE_TARGET} PROPERTIES FOLDER "Samples/${OPENCL_SAMPLE_CATEGORY}/${OPENCL_SAMPLE_TARGET}") + add_dependencies(${OPENCL_SAMPLE_TARGET} + ${CURRENT_FOLDER_NAME}-device-code + ) foreach(CONFIG ${OPENCL_SAMPLE_CONFIGS}) - install(TARGETS ${OPENCL_SAMPLE_TARGET} CONFIGURATIONS ${CONFIG} DESTINATION ${CONFIG}) - install(FILES ${OPENCL_SAMPLE_KERNELS} CONFIGURATIONS ${CONFIG} DESTINATION ${CONFIG}) + install(TARGETS ${OPENCL_SAMPLE_TARGET} CONFIGURATIONS ${CONFIG} DESTINATION ${CMAKE_INSTALL_BINDIR}) + install(FILES ${OPENCL_SAMPLE_KERNELS} CONFIGURATIONS ${CONFIG} DESTINATION ${CMAKE_INSTALL_BINDIR}) + install(FILES ${OPENCL_SAMPLE_SHADERS} CONFIGURATIONS ${CONFIG} DESTINATION ${CMAKE_INSTALL_BINDIR}) endforeach() - if(OPENCL_SAMPLE_TEST) - add_test(NAME ${OPENCL_SAMPLE_TARGET} COMMAND ${OPENCL_SAMPLE_TARGET}) + if(OPENCL_SDK_TEST_SAMPLES AND OPENCL_SAMPLE_TEST) + add_test( + NAME ${OPENCL_SAMPLE_TARGET} + COMMAND ${OPENCL_SAMPLE_TARGET} + WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR} + ) endif() -endfunction() +endmacro() add_subdirectory(core) +add_subdirectory(extensions) diff --git a/samples/core/CMakeLists.txt b/samples/core/CMakeLists.txt index 00b36a1a..75d8357d 100644 --- a/samples/core/CMakeLists.txt +++ b/samples/core/CMakeLists.txt @@ -15,4 +15,7 @@ add_subdirectory(enumopencl) add_subdirectory(copybuffer) add_subdirectory(copybufferkernel) - +add_subdirectory(saxpy) +add_subdirectory(reduce) +add_subdirectory(blur) +add_subdirectory(binaries) diff --git a/samples/core/binaries/CMakeLists.txt b/samples/core/binaries/CMakeLists.txt new file mode 100644 index 00000000..17dd56df --- /dev/null +++ b/samples/core/binaries/CMakeLists.txt @@ -0,0 +1,20 @@ +# Copyright (c) 2021 The Khronos Group Inc. +# +# 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. + +add_sample( + TEST + TARGET binaries + VERSION 300 + SOURCES main.c + KERNELS Collatz.cl) diff --git a/samples/core/binaries/Collatz.cl b/samples/core/binaries/Collatz.cl new file mode 100644 index 00000000..4da2fbca --- /dev/null +++ b/samples/core/binaries/Collatz.cl @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2021 The Khronos Group Inc. + * + * 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. + */ + +kernel void Collatz( + global int * const result +) { + const size_t gli = get_global_id(0); + const size_t ind = gli - get_global_offset(0); + + int steps = 0; + + ulong n = gli + 1; + + while (n != 1) { + if (steps > INT_MAX - 3) { + steps = 0; + break; + } + if (n & 1) { + ulong m = 3 * n + 1; + if (m < n) { + steps = -steps - 1; + break; + } + n = m >> 1; + steps += 2; + } + else { + n >>= 1; + ++steps; + } + } + + result[ind] = steps; +} diff --git a/samples/core/binaries/README.md b/samples/core/binaries/README.md new file mode 100644 index 00000000..ad76ce9a --- /dev/null +++ b/samples/core/binaries/README.md @@ -0,0 +1,54 @@ +# Binaries + +## Sample Purpose + +This sample intends to demonstrate how to use separate compilation and consumption of OpenCL program by saving and loading program binaries. + +## Key APIs and Concepts + +The binary of a compiled program can be extracted from the program by invoking `clGetProgramInfo` with `CL_PROGRAM_BINARIES` parameter. Each device is provided with separate binary, and this binary can be saved into a file, and then loaded into the same runtime for a specified context to use on the same device. Loaded binaries could be used for `clCreateProgramWithBinary` invocation that constructs OpenCL program out of them. As a result offline compilation of the program becomes possible. + +### Application flow + +The application once a platform and a device is selected tries to read corresponding binary file from the disk. In the case of success the program is built from the binary and executed. If the binary file is not present in the folder of the program then kernel `.cl` file is loaded, built for the specified device, saved as a binary file, loaded and executed. + +#### Event profiling + +While events are multi-purpose in OpenCL, they are the handles through which synchronization and profiling can be done, here we only demonstrate their profiling capabilities. Event profiling is turned on by creating the queue as such: +```c +cl_command_queue_properties props[] = { CL_QUEUE_PROPERTIES, CL_QUEUE_PROFILING_ENABLE, 0 }; +queue = clCreateCommandQueueWithProperties(context, device, props, &error); +``` +We do not have to test for this capability, as it's mandatory for a device to provide profiling capabilities. + +To record the execution time of every blur step, we save the associated events like this: +```c +cl_event pass; +clEnqueueNDRangeKernel(queue, Collatz, 1, NULL, &length, NULL, 0, NULL, &pass); +clWaitForEvents(1, &pass); +``` +Calling the kernel returns the event associated with it. Instead calling finish on the queue, we may as well wait for all events in `passes` to signal completion. (For a complete list of event state, refer to the [Execution Model](https://www.khronos.org/registry/OpenCL/specs/3.0-unified/html/OpenCL_API.html#_execution_model) chapter of the OpenCL API spec). + +Because most often we measure durations between event state transitions, we use the utility `cl_ulong cl_util_get_event_duration(cl_event event, cl_profiling_info start, cl_profiling_info end, cl_int *error)` to get duration in nanoseconds between the states `start` and `end`. +_(Note: the main reason why net kernel execution time doesn't amount to the time measured by the host are due to dispatching kernel binaries to the device which happen on the first execution, as the sample doesn't invoke a so called warm-up kernel. By doing so, one can reduce the difference to minimal runtime overhead.)_ + +### Kernel logic + +Kernel is testing Collatz conjecture that states that the sequential application of rules + +1) if `n` is odd, `n` -> `3*n+1` +2) if `n` is even, `n` -> `n/2` + +to any of positive integer numbers results ultimately in a loop of `1`->`4`->`2`->`1` etc. (See [Wikipedia article](https://en.wikipedia.org/wiki/Collatz_conjecture) for a brief introduction.) It writes down the number of iterations needed to get into the circle for each of the unique global work-item ID values (plus 1). + +## Used API surface + +```c +cl_util_get_device(const cl_uint plat_id, const cl_uint dev_id, const cl_device_type type, cl_int * const error) +cl_util_print_device_info(const cl_device_id device) +cl_util_read_binaries(const cl_context context, const cl_device_id * const devices, const cl_uint num_devices, const char * const program_file_name, cl_int * const error) +cl_util_build_program(const cl_program pr, const cl_device_id dev, const char * const opt) +cl_util_read_text_file(const char * const filename, size_t * const length, cl_int * const error) +cl_util_write_binaries(const cl_program program, const char * const program_file_name) +cl_util_print_error(const cl_int error) +``` diff --git a/samples/core/binaries/main.c b/samples/core/binaries/main.c new file mode 100644 index 00000000..4a13d922 --- /dev/null +++ b/samples/core/binaries/main.c @@ -0,0 +1,317 @@ +/* + * Copyright (c) 2021 The Khronos Group Inc. + * + * 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. + */ + +// OpenCL SDK includes +#include +#include +#include + +// STL includes +#include +#include +#include +#include + +// Sample-specific option +struct options_Binaries +{ + size_t start; + size_t length; +}; + +cag_option BinariesOptions[] = { { .identifier = 'l', + .access_letters = "l", + .access_name = "length", + .value_name = "(positive integer)", + .description = "Length of range to test" }, + + { .identifier = 's', + .access_letters = "s", + .access_name = "start", + .value_name = "(positive integer)", + .description = "Starting number" } }; + +ParseState parse_BinariesOptions(const char identifier, + cag_option_context *cag_context, + struct options_Binaries *opts) +{ + const char *value; + + switch (identifier) + { + case 's': + if ((value = cag_option_get_value(cag_context))) + { + opts->start = strtoull(value, NULL, 0); + return ParsedOK; + } + else + return ParseError; + case 'l': + if ((value = cag_option_get_value(cag_context))) + { + opts->length = strtoull(value, NULL, 0); + return ParsedOK; + } + else + return ParseError; + } + return NotParsed; +} + +cl_int parse_options(int argc, char *argv[], + struct cl_sdk_options_Diagnostic *diag_opts, + struct cl_sdk_options_SingleDevice *dev_opts, + struct options_Binaries *binaries_opts) +{ + cl_int error = CL_SUCCESS; + struct cag_option *opts = NULL, *tmp = NULL; + size_t n = 0; + + /* Prepare all options array. */ + MEM_CHECK(opts = add_CLI_options(opts, &n, DiagnosticOptions, + CAG_ARRAY_SIZE(DiagnosticOptions)), + error, end); + MEM_CHECK(tmp = add_CLI_options(opts, &n, SingleDeviceOptions, + CAG_ARRAY_SIZE(SingleDeviceOptions)), + error, end); + opts = tmp; + MEM_CHECK(tmp = add_CLI_options(opts, &n, BinariesOptions, + CAG_ARRAY_SIZE(BinariesOptions)), + error, end); + opts = tmp; + + char identifier; + cag_option_context cag_context; + + /* Prepare the context and iterate over all options. */ + cag_option_prepare(&cag_context, opts, n, argc, argv); + while (cag_option_fetch(&cag_context)) + { + ParseState state = NotParsed; + identifier = cag_option_get(&cag_context); + + PARS_OPTIONS(parse_DiagnosticOptions(identifier, diag_opts), state); + PARS_OPTIONS( + parse_SingleDeviceOptions(identifier, &cag_context, dev_opts), + state); + PARS_OPTIONS( + parse_BinariesOptions(identifier, &cag_context, binaries_opts), + state); + + if (identifier == 'h') + { + printf("Usage: binaries [OPTION]...\n"); + printf("Option name and value should be separated by '=' or a " + "space\n"); + printf("Demonstrates saving and loading of compiled binary OpenCL " + "programs for specific device.\n\n"); + cag_option_print(opts, n, stdout); + exit((state == ParseError) ? CL_INVALID_ARG_VALUE : CL_SUCCESS); + } + } + +end: + free(opts); + return error; +} + + +cl_int print_timings(struct timespec start, struct timespec end, + const cl_event *const event_list, cl_uint event_number) +{ + cl_int error = CL_SUCCESS; + + cl_ulong time_host, time_device = 0; + TIMER_DIFFERENCE(time_host, start, end) + for (cl_uint i = 0; i < event_number; ++i) + { + time_device += cl_util_get_event_duration( + event_list[i], CL_PROFILING_COMMAND_START, CL_PROFILING_COMMAND_END, + &error); + if (error != CL_SUCCESS) return error; + } + printf("Execution time as seen by host: %llu us, by device: %llu us\n", + (unsigned long long)(time_host + 500) / 1000, + (unsigned long long)(time_device + 500) / 1000); + + return error; +} + + +int main(int argc, char *argv[]) +{ + cl_int error = CL_SUCCESS; + cl_int end_error = CL_SUCCESS; + cl_platform_id platform; + cl_device_id device; + cl_context context; + cl_command_queue queue; + + cl_program program; + + /// Parse command-line options + struct cl_sdk_options_Diagnostic diag_opts = { .quiet = false, + .verbose = false }; + struct cl_sdk_options_SingleDevice dev_opts = { + .triplet = { 0, 0, CL_DEVICE_TYPE_ALL } + }; + struct options_Binaries binaries_opts = { .start = 1, .length = 100000 }; + + OCLERROR_RET( + parse_options(argc, argv, &diag_opts, &dev_opts, &binaries_opts), error, + end); + + /// Create runtime objects based on user preference or default + OCLERROR_PAR(device = cl_util_get_device(dev_opts.triplet.plat_index, + dev_opts.triplet.dev_index, + dev_opts.triplet.dev_type, &error), + error, end); + OCLERROR_PAR(context = + clCreateContext(NULL, 1, &device, NULL, NULL, &error), + error, end); + + if (!diag_opts.quiet) cl_util_print_device_info(device); + + /// Try to read binary + program = cl_util_read_binaries(context, &device, 1, "Collatz", &error); + + if (error != CL_SUCCESS) + { // if binary not present, compile and save + const char *kernel_location = "./Collatz.cl"; + char *kernel = NULL; + size_t program_size = 0; + char *options = NULL; + + OCLERROR_PAR(kernel = cl_util_read_text_file(kernel_location, + &program_size, &error), + error, cont); + printf("OpenCL file red... "); + + OCLERROR_PAR(program = clCreateProgramWithSource(context, 1, + (const char **)&kernel, + &program_size, &error), + error, ker); + OCLERROR_RET(cl_util_build_program(program, device, options), error, + prgs); + + OCLERROR_RET(cl_util_write_binaries(program, "Collatz"), error, prgs); + printf("Binary file written.\n\n"); + + prgs: + OCLERROR_RET(clReleaseProgram(program), end_error, que); + ker: + free(kernel); + + OCLERROR_PAR(program = cl_util_read_binaries(context, &device, 1, + "Collatz", &error), + error, cont); + } + + // if the binary is already present - calculate + printf("Saved program found\n"); + OCLERROR_RET(cl_util_build_program(program, device, NULL), error, prg); + + /// Create all remaining runtime objects + OCLERROR_RET(clGetDeviceInfo(device, CL_DEVICE_PLATFORM, + sizeof(cl_platform_id), &platform, NULL), + error, prg); +#if CL_HPP_TARGET_OPENCL_VERSION >= 200 + cl_command_queue_properties props[] = { CL_QUEUE_PROPERTIES, + CL_QUEUE_PROFILING_ENABLE, 0 }; + OCLERROR_PAR(queue = clCreateCommandQueueWithProperties(context, device, + props, &error), + error, prg); +#else + OCLERROR_PAR(queue = clCreateCommandQueue( + context, device, CL_QUEUE_PROFILING_ENABLE, &error), + error, prg); +#endif + + cl_kernel Collatz; + OCLERROR_PAR(Collatz = clCreateKernel(program, "Collatz", &error), error, + que); + + const size_t length = binaries_opts.length; + const size_t start = binaries_opts.start - 1; + /// Prepare vector of values to extract results + cl_int *v = NULL; + MEM_CHECK(v = (cl_int *)malloc(sizeof(cl_int) * length), error, col); + + /// Initialize device-side storage + cl_mem buf; + OCLERROR_PAR(buf = clCreateBuffer(context, + CL_MEM_WRITE_ONLY | CL_MEM_HOST_READ_ONLY, + sizeof(cl_int) * length, NULL, &error), + error, vec); + + /// Run kernel + cl_event pass; + OCLERROR_RET(clSetKernelArg(Collatz, 0, sizeof(cl_mem), &buf), error, buff); + + GET_CURRENT_TIMER(start_time) + OCLERROR_RET(clEnqueueNDRangeKernel(queue, Collatz, 1, &start, &length, + NULL, 0, NULL, &pass), + error, buff); + OCLERROR_RET(clWaitForEvents(1, &pass), error, buff); + GET_CURRENT_TIMER(end_time) + + if (diag_opts.verbose) print_timings(start_time, end_time, &pass, 1); + + OCLERROR_RET(clEnqueueReadBuffer(queue, buf, CL_BLOCKING, 0, + sizeof(cl_int) * length, v, 0, NULL, NULL), + error, buff); + + /// Show results + int max_steps = 0; + size_t max_ind = -1; + for (size_t i = 0; i < length; ++i) + if (v[i] < 0) + { + fprintf(stderr, "Number %zu gets out of 64 bits at step %i\n", + start + 1 + i, -v[i]); + } + else if ((v[i] == 0) && (start + i != 0)) + { + fprintf(stderr, "Number %zu did not converge to 1 at step %i\n", + start + 1 + i, INT_MAX - 2); + } + else if (v[i] > max_steps) + { + max_steps = v[i]; + max_ind = start + 1 + i; + } + printf("From %zu numbers checked starting from %zu, maximum %i steps was " + "needed to get to 1 for number %zu\n", + length, start + 1, max_steps, max_ind); + + /// Cleanup +buff: + OCLERROR_RET(clReleaseMemObject(buf), end_error, vec); +vec: + free(v); +col: + OCLERROR_RET(clReleaseKernel(Collatz), end_error, que); +que: + OCLERROR_RET(clReleaseCommandQueue(queue), end_error, prg); +prg: + OCLERROR_RET(clReleaseProgram(program), end_error, cont); +cont: + OCLERROR_RET(clReleaseContext(context), end_error, end); +end: + if (error != CL_SUCCESS) cl_util_print_error(error); + return error; +} diff --git a/samples/core/blur/CMakeLists.txt b/samples/core/blur/CMakeLists.txt new file mode 100644 index 00000000..9ed4fb16 --- /dev/null +++ b/samples/core/blur/CMakeLists.txt @@ -0,0 +1,20 @@ +# Copyright (c) 2021 The Khronos Group Inc. +# +# 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. + +add_sample( + TEST + TARGET blur + VERSION 300 + SOURCES main.c + KERNELS blur.cl) diff --git a/samples/core/blur/README.md b/samples/core/blur/README.md new file mode 100644 index 00000000..061683ed --- /dev/null +++ b/samples/core/blur/README.md @@ -0,0 +1,68 @@ +# Blur + +## Sample Purpose + +This sample intends to demonstrate how to use different techniques of data exchange between workitems in workgroup, query various extensions applicable and use compile options to touch up kernel sources at runtime to produce the best kernel implementation for the task. + +## Key APIs and Concepts + +The tasks that are memory bound need reduction of memory accesses to the minimum possible. It can be achieved by exchange of the data between the workitems in the same workgroup. + +The most important aspect of this sample is to demonstrate different ways of data exchange: through the use of local memory and through the use of OpenCL 3.0 extensions of `cl_khr_subgroup_shuffle` and `cl_khr_subgroup_shuffle_relative`. + +### Application flow + +The application once a device is selected queries its supported image formats and uses the format closest to the format of image to apply blur to. Then to find out what variants of blur are possible to execute on the device it is queried about several features. + +First the type of local memory is checked and whether local memory is actually not different from global, then local memory exchange blur step is skipped. Second the application queries whether the device is capable of executing built-in `sub_group_shuffle` and/or `sub_group_shuffle_up/down` intrinsics. If not, the corresponding steps are also skipped. + +Image buffers are created, and the OpenCL program is compiled with different options for general steps of no data exchange and local memory data exchange and for specialized steps of sub-group data exchange. Kernels used for box and Gaussian blur allow decomposition into 1D convolutions and it is used for speedup of the blur calculations. + +Local memory exchange algorithm proceeds by first collectively loading all the pixels needed for workgroup into local memory and then read the pixels sequentially into each of workitems. + +Subgroup exchange algorithm does not use local memory but instead exchanges data directly between different workitems in the subgroup. Note that for the subgroup data exchange to work correctly all the workitems sourcing data for exchange should encounter `sub_group_shuffle[_up/down]` operations. The kernels otherwise are conceptually simple, they read data first and then exchange it shuffling up in the workgroup while 0-th subgroup workitem reads new pixel from the image. + +#### Event profiling + +While events are multi-purpose in OpenCL, they are the handles through which synchronization and profiling can be done, here we only demonstrate their profiling capabilities. Event profiling is turned on by creating the queue as such: +```c +cl_command_queue_properties props[] = { CL_QUEUE_PROPERTIES, CL_QUEUE_PROFILING_ENABLE, 0 }; +queue = clCreateCommandQueueWithProperties(context, device, props, &error); +``` +We do not have to test for this capability, as it's mandatory for a device to provide profiling capabilities. + +To record the execution time of every blur step, we save the associated events like this: +```c +cl_event pass[2]; +clEnqueueNDRangeKernel(queue, blur1, 2, origin, image_size, NULL, 0, NULL, pass + 0); +clEnqueueNDRangeKernel(queue, blur2, 2, origin, image_size, NULL, 0, NULL, pass + 1); +clWaitForEvents(2, pass); +``` +Calling the kernel returns the event associated with it. Instead calling finish on the queue, we may as well wait for all events in `passes` to signal completion. (For a complete list of event state, refer to the [Execution Model](https://www.khronos.org/registry/OpenCL/specs/3.0-unified/html/OpenCL_API.html#_execution_model) chapter of the OpenCL API spec). + +Because most often we measure durations between event state transitions, we use the utility `cl_ulong cl_util_get_event_duration(cl_event event, cl_profiling_info start, cl_profiling_info end, cl_int *error)` to get duration in nanoseconds between the states `start` and `end`. +_(Note: the main reason why net kernel execution time doesn't amount to the time measured by the host are due to dispatching kernel binaries to the device which happen on the first execution, as the sample doesn't invoke a so called warm-up kernel. By doing so, one can reduce the difference to minimal runtime overhead.)_ + +## Kernel logic + +### Vanilla single-pass 2D blur + +### Dual-pass 1D blur + +### Local memory exchange blur + +### Sub-group exchange blur + +### Used API surface + +```c +cl_util_get_device(const cl_uint plat_id, const cl_uint dev_id, const cl_device_type type, cl_int * const error) +cl_util_get_device_info(const cl_device_id device, const cl_device_info info, cl_int * const error) +cl_util_print_device_info(const cl_device_id device) +cl_util_read_text_file(const char * const filename, size_t * const length, cl_int * const error) +cl_util_build_program(const cl_program pr, const cl_device_id dev, const char * const opt) +cl_sdk_read_image(const char * const file_name, cl_int * const error) +cl_sdk_write_image(const char * const file_name, const cl_sdk_image * const im) +cl_util_get_event_duration(const cl_event event, const cl_profiling_info start, const cl_profiling_info end, cl_int * const error) +cl_util_print_error(const cl_int error) +``` diff --git a/samples/core/blur/blur.cl b/samples/core/blur/blur.cl new file mode 100644 index 00000000..807e5e6f --- /dev/null +++ b/samples/core/blur/blur.cl @@ -0,0 +1,511 @@ +kernel void blur_box( + read_only image2d_t input_image, + write_only image2d_t output_image, + int size +) +{ + const int width = get_image_width(input_image); + const int height = get_image_height(input_image); + // coordinates of the pixel to work on + const int2 coord = { get_global_id(0), get_global_id(1) }; + + uint4 sum = 0; + uint num = 0; + int2 shift; + for (shift.x = -size; shift.x <= size; ++shift.x) + for (shift.y = -size; shift.y <= size; ++shift.y) { + int2 cur = coord + shift; + if ((0 <= cur.x) && (cur.x < width) && (0 <= cur.y) && (cur.y < height)) { + ++num; + sum += read_imageui(input_image, cur); + } + } + write_imageui(output_image, coord, (sum + num / 2) / num); +} + + +kernel void blur_box_horizontal( + read_only image2d_t input_image, + write_only image2d_t output_image, + int size +) +{ + const int width = get_global_size(0); + const int height = get_global_size(1); + const int2 coord = { get_global_id(0), get_global_id(1) }; + + uint4 sum = 0; + uint num = 0; + int2 shift = 0; + for (shift.x = -size; shift.x <= size; ++shift.x) { + int2 cur = coord + shift; + if ((0 <= cur.x) && (cur.x < width)) { + ++num; + sum += read_imageui(input_image, cur); + } + } + write_imageui(output_image, coord, (sum + num / 2) / num); +} + +kernel void blur_box_vertical( + read_only image2d_t input_image, + write_only image2d_t output_image, + int size +) +{ + const int width = get_global_size(0); + const int height = get_global_size(1); + const int2 coord = { get_global_id(0), get_global_id(1) }; + + uint4 sum = 0; + uint num = 0; + int2 shift = 0; + for (shift.y = -size; shift.y <= size; ++shift.y) { + int2 cur = coord + shift; + if ((0 <= cur.y) && (cur.y < height)) { + ++num; + sum += read_imageui(input_image, cur); + } + } + write_imageui(output_image, coord, (sum + num / 2) / num); +} + + +kernel void blur_kernel_horizontal( + read_only image2d_t input_image, + write_only image2d_t output_image, + int size, + constant float * kern +) +{ + const int width = get_image_width(input_image); + const int height = get_image_height(input_image); + const int2 coord = { get_global_id(0), get_global_id(1) }; + + float4 sum = 0; + float weight = 0; + int2 shift = 0; + for (shift.x = -size; shift.x <= size; ++shift.x) { + int2 cur = coord + shift; + if ((0 <= cur.x) && (cur.x < width)) { + const float w = kern[size + shift.x]; + weight += w; + sum += convert_float4(read_imageui(input_image, cur)) * w; + } + } + uint4 res = convert_uint4(round(sum / weight)); + write_imageui(output_image, coord, res); +} + +kernel void blur_kernel_vertical( + read_only image2d_t input_image, + write_only image2d_t output_image, + int size, + constant float * kern +) +{ + const int width = get_image_width(input_image); + const int height = get_image_height(input_image); + const int2 coord = { get_global_id(0), get_global_id(1) }; + + float4 sum = 0; + float weight = 0; + int2 shift = 0; + for (shift.y = -size; shift.y <= size; ++shift.y) { + int2 cur = coord + shift; + if ((0 <= cur.y) && (cur.y < height)) { + const float w = kern[size + shift.y]; + weight += w; + sum += convert_float4(read_imageui(input_image, cur)) * w; + } + } + write_imageui(output_image, coord, convert_uint4(round(sum / weight))); +} + + +kernel void blur_box_horizontal_exchange( + read_only image2d_t input_image, + write_only image2d_t output_image, + int size, + local uchar4 * line +) +{ + const int width = get_image_width(input_image); + const int height = get_image_height(input_image); + const int2 coord = { get_global_id(0), get_global_id(1) }; + + const int grs = get_local_size(0); + const int lid = get_local_id(0); + // coordinates of the leftmost and rightmost pixels needed for the workgroup + const int start = get_group_id(0) * grs; + const int2 start_coord = { max(start - size, 0), coord.y }; + const int2 end_coord = { min(start + grs + size, width - 1), coord.y}; + + // copy all pixels needed for workgroup into local memory + int2 cur = start_coord + (int2)(lid, 0); + uint pos = lid; + while (cur.x <= end_coord.x) { + line[pos] = convert_uchar4(read_imageui(input_image, cur)); + cur.x += grs; + pos += grs; + } + barrier(CLK_LOCAL_MEM_FENCE); + + // blur + if (coord.x < width) { + uint4 sum = 0; + uint num = 0; + pos = lid + (start - size - start_coord.x); + for (cur.x = coord.x - size; cur.x <= coord.x + size; ++cur.x, ++pos) + if ((0 <= cur.x) && (cur.x < width)) { + ++num; + sum += convert_uint4(line[pos]); + } + write_imageui(output_image, coord, (sum + num / 2) / num); + } +} + +kernel void blur_box_vertical_exchange( + read_only image2d_t input_image, + write_only image2d_t output_image, + int size, + local uchar4 * line +) +{ + const int width = get_image_width(input_image); + const int height = get_image_height(input_image); + const int2 coord = { get_global_id(0), get_global_id(1) }; + + const int grs = get_local_size(1); + const int lid = get_local_id(1); + // coordinates of the topmost and lowest pixels needed for the workgroup + const int start = get_group_id(1) * grs; + const int2 start_coord = { coord.x, max(start - size, 0) }; + const int2 end_coord = { coord.x, min(start + grs + size, height - 1) }; + + // copy all pixels needed for workgroup into local memory + int2 cur = start_coord + (int2)(0, lid); + uint pos = lid; + while (cur.y <= end_coord.y) { + line[pos] = convert_uchar4(read_imageui(input_image, cur)); + cur.y += grs; + pos += grs; + } + barrier(CLK_LOCAL_MEM_FENCE); + + // blur + if (coord.y < height) { + uint4 sum = 0; + uint num = 0; + pos = lid + (start - size - start_coord.y); + for (cur.y = coord.y - size; cur.y <= coord.y + size; ++cur.y, ++pos) + if ((0 <= cur.y) && (cur.y < height)) { + ++num; + sum += convert_uint4(line[pos]); + } + write_imageui(output_image, coord, (sum + num / 2) / num); + } +} + + +kernel void blur_kernel_horizontal_exchange( + read_only image2d_t input_image, + write_only image2d_t output_image, + int size, + constant float * kern, + local uchar4 * line +) +{ + const int width = get_image_width(input_image); + const int height = get_image_height(input_image); + const int2 coord = { get_global_id(0), get_global_id(1) }; + + const int grs = get_local_size(0); + const int lid = get_local_id(0); + // coordinates of the leftmost and rightmost pixels needed for the workgroup + const int start = get_group_id(0) * grs; + const int2 start_coord = { max(start - size, 0), coord.y }; + const int2 end_coord = { min(start + grs + size, width - 1), coord.y}; + + // copy all pixels needed for workgroup into local memory + int2 cur = start_coord + (int2)(lid, 0); + uint pos = lid; + while (cur.x <= end_coord.x) { + line[pos] = convert_uchar4(read_imageui(input_image, cur)); + cur.x += grs; + pos += grs; + } + barrier(CLK_LOCAL_MEM_FENCE); + + // blur + if (coord.x < width) { + float4 sum = 0; + float weight = 0; + pos = lid + (start - size - start_coord.x); + for (int shift = -size; shift <= size; ++shift, ++pos) { + cur.x = coord.x + shift; + if ((0 <= cur.x) && (cur.x < width)) { + float w = kern[size + shift]; + weight += w; + sum += convert_float4(line[pos]) * w; + } + } + write_imageui(output_image, coord, convert_uint4(round(sum / weight))); + } +} + +kernel void blur_kernel_vertical_exchange( + read_only image2d_t input_image, + write_only image2d_t output_image, + int size, + constant float * kern, + local uchar4 * line +) +{ + const int width = get_image_width(input_image); + const int height = get_image_height(input_image); + const int2 coord = { get_global_id(0), get_global_id(1) }; + + const int grs = get_local_size(1); + const int lid = get_local_id(1); + // coordinates of the topmost and lowest pixels needed for the workgroup + const int start = get_group_id(1) * grs; + const int2 start_coord = { coord.x, max(start - size, 0) }; + const int2 end_coord = { coord.x, min(start + grs + size, height - 1) }; + + // copy all pixels needed for workgroup into local memory + int2 cur = start_coord + (int2)(0, lid); + uint pos = lid; + while (cur.y <= end_coord.y) { + line[pos] = convert_uchar4(read_imageui(input_image, cur)); + cur.y += grs; + pos += grs; + } + barrier(CLK_LOCAL_MEM_FENCE); + + // blur + if (coord.y < height) { + float4 sum = 0; + float weight = 0; + pos = lid + (start - size - start_coord.y); + for (int shift = -size; shift <= size; ++shift, ++pos) { + cur.y = coord.y + shift; + if ((0 <= cur.y) && (cur.y < height)) { + float w = kern[size + shift]; + weight += w; + sum += convert_float4(line[pos]) * w; + } + } + write_imageui(output_image, coord, convert_uint4(round(sum / weight))); + } +} + + +#if defined(USE_SUBGROUP_EXCHANGE_RELATIVE) || defined(USE_SUBGROUP_EXCHANGE) + +kernel void blur_box_horizontal_subgroup_exchange( + read_only image2d_t input_image, + write_only image2d_t output_image, + int size +) +{ + const int width = get_image_width(input_image); + const int height = get_image_height(input_image); + const int2 coord = { get_global_id(0), get_global_id(1) }; + + if (coord.x < width) { + uint4 pixel = 0; + uint4 sum = 0; + uint num = 0; + + // initial read + int2 cur = coord + (int2)(size, 0); + if (cur.x < width) { + pixel = read_imageui(input_image, cur); + sum = pixel; + num = 1; + } + // shifts and reads + const uint sglid = get_sub_group_local_id(); + const uint shift = (sglid != 0); + for (int i = size - 1; i >= -size; --i) { + --cur.x; +#if defined(USE_SUBGROUP_EXCHANGE_RELATIVE) + pixel = (uint4)(sub_group_shuffle_up(pixel.s0, shift), + sub_group_shuffle_up(pixel.s1, shift), + sub_group_shuffle_up(pixel.s2, shift), + sub_group_shuffle_up(pixel.s3, shift)); +#elif defined(USE_SUBGROUP_EXCHANGE) + pixel = (uint4)(sub_group_shuffle(pixel.s0, sglid - shift), + sub_group_shuffle(pixel.s1, sglid - shift), + sub_group_shuffle(pixel.s2, sglid - shift), + sub_group_shuffle(pixel.s3, sglid - shift)); +#endif + if ((cur.x >= 0) && (cur.x < width)) { + if (!shift) // 0th workitem reads new pixel + pixel = read_imageui(input_image, cur); + sum += pixel; + ++num; + } + } + + write_imageui(output_image, coord, (sum + num / 2) / num); + } +} + +kernel void blur_box_vertical_subgroup_exchange( + read_only image2d_t input_image, + write_only image2d_t output_image, + int size +) +{ + const int width = get_image_width(input_image); + const int height = get_image_height(input_image); + const int2 coord = { get_global_id(0), get_global_id(1) }; + + if (coord.y < height) { + uint4 pixel = 0; + uint4 sum = 0; + uint num = 0; + + // initial read + int2 cur = coord + (int2)(0, size); + if (cur.y < height) { + pixel = read_imageui(input_image, cur); + sum = pixel; + num = 1; + } + // shifts and reads + const uint sglid = get_sub_group_local_id(); + const uint shift = (sglid != 0); + for (int i = size - 1; i >= -size; --i) { + --cur.y; +#if defined(USE_SUBGROUP_EXCHANGE_RELATIVE) + pixel = (uint4)(sub_group_shuffle_up(pixel.s0, shift), + sub_group_shuffle_up(pixel.s1, shift), + sub_group_shuffle_up(pixel.s2, shift), + sub_group_shuffle_up(pixel.s3, shift)); +#elif defined(USE_SUBGROUP_EXCHANGE) + pixel = (uint4)(sub_group_shuffle(pixel.s0, sglid - shift), + sub_group_shuffle(pixel.s1, sglid - shift), + sub_group_shuffle(pixel.s2, sglid - shift), + sub_group_shuffle(pixel.s3, sglid - shift)); +#endif + if ((cur.y >= 0) && (cur.y < height)) { + if (!shift) // 0th workitem reads new pixel + pixel = read_imageui(input_image, cur); + sum += pixel; + ++num; + } + } + + write_imageui(output_image, coord, (sum + num / 2) / num); + } +} + + +kernel void blur_kernel_horizontal_subgroup_exchange( + read_only image2d_t input_image, + write_only image2d_t output_image, + int size, + constant float * kern +) +{ + const int width = get_image_width(input_image); + const int height = get_image_height(input_image); + const int2 coord = { get_global_id(0), get_global_id(1) }; + + if (coord.x < width) { + uint4 pixel = 0; + float4 sum = 0; + float weight = 0; + + // initial read + int2 cur = coord + (int2)(size, 0); + if (cur.x < width) { + pixel = read_imageui(input_image, cur); + weight = kern[2 * size]; + sum = convert_float4(pixel) * weight; + } + // shifts and reads + const uint sglid = get_sub_group_local_id(); + const uint shift = (sglid != 0); + for (int i = size - 1; i >= -size; --i) { + --cur.x; +#if defined(USE_SUBGROUP_EXCHANGE_RELATIVE) + pixel = (uint4)(sub_group_shuffle_up(pixel.s0, shift), + sub_group_shuffle_up(pixel.s1, shift), + sub_group_shuffle_up(pixel.s2, shift), + sub_group_shuffle_up(pixel.s3, shift)); +#elif defined(USE_SUBGROUP_EXCHANGE) + pixel = (uint4)(sub_group_shuffle(pixel.s0, sglid - shift), + sub_group_shuffle(pixel.s1, sglid - shift), + sub_group_shuffle(pixel.s2, sglid - shift), + sub_group_shuffle(pixel.s3, sglid - shift)); +#endif + if ((cur.x >= 0) && (cur.x < width)) { + if (!shift) // 0th workitem reads new pixel + pixel = read_imageui(input_image, cur); + float w = kern[size + i]; + weight += w; + sum += convert_float4(pixel) * w; + } + } + + write_imageui(output_image, coord, convert_uint4(round(sum / weight))); + } +} + +kernel void blur_kernel_vertical_subgroup_exchange( + read_only image2d_t input_image, + write_only image2d_t output_image, + int size, + constant float * kern +) +{ + const int width = get_image_width(input_image); + const int height = get_image_height(input_image); + const int2 coord = { get_global_id(0), get_global_id(1) }; + + if (coord.y < height) { + uint4 pixel = 0; + float4 sum = 0; + float weight = 0; + + // initial read + int2 cur = coord + (int2)(0, size); + if (cur.y < height) { + pixel = read_imageui(input_image, cur); + weight = kern[2 * size]; + sum = convert_float4(pixel) * weight; + } + // shifts and reads + const uint sglid = get_sub_group_local_id(); + const uint shift = (sglid != 0); + for (int i = size - 1; i >= -size; --i) { + --cur.y; +#if defined(USE_SUBGROUP_EXCHANGE_RELATIVE) + pixel = (uint4)(sub_group_shuffle_up(pixel.s0, shift), + sub_group_shuffle_up(pixel.s1, shift), + sub_group_shuffle_up(pixel.s2, shift), + sub_group_shuffle_up(pixel.s3, shift)); +#elif defined(USE_SUBGROUP_EXCHANGE) + pixel = (uint4)(sub_group_shuffle(pixel.s0, sglid - shift), + sub_group_shuffle(pixel.s1, sglid - shift), + sub_group_shuffle(pixel.s2, sglid - shift), + sub_group_shuffle(pixel.s3, sglid - shift)); +#endif + if ((cur.y >= 0) && (cur.y < height)) { + if (!shift) // 0th workitem reads new pixel + pixel = read_imageui(input_image, cur); + float w = kern[size + i]; + sum += convert_float4(pixel) * w; + weight += w; + } + } + + write_imageui(output_image, coord, convert_uint4(round(sum / weight))); + } +} + +#endif // USE_SUBGROUP_EXCHANGE_RELATIVE || USE_SUBGROUP_EXCHANGE diff --git a/samples/core/blur/default_image.h b/samples/core/blur/default_image.h new file mode 100644 index 00000000..579b162b --- /dev/null +++ b/samples/core/blur/default_image.h @@ -0,0 +1,15837 @@ +/* Generated by bin2c from image by Andrew Svk + * https://unsplash.com/photos/7oJ4D_ewB7c */ + +/* Contents of file andrew-svk-7oJ4D_ewB7c-unsplash.png */ +const size_t andrew_svk_7oJ4D_ewB7c_unsplash_png_size = 189954; +const unsigned char andrew_svk_7oJ4D_ewB7c_unsplash_png[189954] = { + 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D, + 0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x01, 0x98, 0x00, 0x00, 0x01, 0x10, + 0x08, 0x02, 0x00, 0x00, 0x00, 0x02, 0xBA, 0xF5, 0xB7, 0x00, 0x00, 0x01, + 0x1C, 0x69, 0x43, 0x43, 0x50, 0x49, 0x43, 0x43, 0x20, 0x70, 0x72, 0x6F, + 0x66, 0x69, 0x6C, 0x65, 0x00, 0x00, 0x28, 0x91, 0x63, 0x60, 0x60, 0xE2, + 0xC9, 0x49, 0xCE, 0x2D, 0x66, 0x12, 0x60, 0x60, 0xC8, 0xCD, 0x2B, 0x29, + 0x0A, 0x72, 0x77, 0x52, 0x88, 0x88, 0x8C, 0x52, 0x60, 0xBF, 0xC3, 0xC0, + 0xC8, 0x20, 0xC9, 0xC0, 0xCC, 0xA0, 0xC9, 0x60, 0x99, 0x98, 0x5C, 0x5C, + 0xE0, 0x18, 0x10, 0xE0, 0xC3, 0x80, 0x13, 0x7C, 0xBB, 0x06, 0x54, 0x0D, + 0x04, 0x97, 0x75, 0x41, 0x66, 0xE1, 0x56, 0x87, 0x15, 0x70, 0xA5, 0xA4, + 0x16, 0x27, 0x03, 0xE9, 0x3F, 0x40, 0x1C, 0x97, 0x5C, 0x50, 0x54, 0xC2, + 0xC0, 0xC0, 0x18, 0x03, 0x64, 0x73, 0x97, 0x97, 0x14, 0x80, 0xD8, 0x19, + 0x40, 0xB6, 0x48, 0x52, 0x36, 0x98, 0x5D, 0x03, 0x62, 0x17, 0x01, 0x1D, + 0x08, 0x64, 0x4F, 0x00, 0xB1, 0xD3, 0x21, 0xEC, 0x25, 0x60, 0x35, 0x10, + 0xF6, 0x0E, 0xB0, 0x9A, 0x90, 0x20, 0x67, 0x20, 0xFB, 0x0C, 0x90, 0xED, + 0x90, 0x8E, 0xC4, 0x4E, 0x42, 0x62, 0x43, 0xED, 0x05, 0x01, 0xE6, 0x64, + 0x23, 0x12, 0x5D, 0x4D, 0x04, 0x28, 0x49, 0xAD, 0x28, 0x01, 0xD1, 0x9E, + 0x11, 0x0C, 0x0C, 0xA0, 0x30, 0x85, 0x88, 0x22, 0xC2, 0x0A, 0x21, 0xC6, + 0x2C, 0x06, 0xC4, 0xC6, 0x0C, 0x0C, 0x4C, 0x4B, 0x10, 0x62, 0xF9, 0x8B, + 0x18, 0x18, 0x2C, 0xBE, 0x02, 0xC5, 0x27, 0x20, 0xC4, 0x92, 0x66, 0x32, + 0x30, 0x6C, 0x6F, 0x65, 0x60, 0x90, 0xB8, 0x85, 0x10, 0x53, 0x59, 0xC0, + 0xC0, 0xC0, 0xDF, 0xC2, 0xC0, 0xB0, 0xED, 0x7C, 0x72, 0x69, 0x51, 0x19, + 0xD4, 0x6A, 0x29, 0x20, 0x3E, 0xCD, 0x78, 0x92, 0x39, 0x99, 0x75, 0x12, + 0x47, 0x36, 0xF7, 0x37, 0x01, 0x7B, 0xD1, 0x40, 0x69, 0x13, 0xC5, 0x8F, + 0x9A, 0x13, 0x8C, 0x24, 0xAC, 0x27, 0xB9, 0xB1, 0x06, 0x96, 0xC7, 0xBE, + 0xCD, 0x2E, 0xA8, 0x62, 0xED, 0xDC, 0x38, 0xAB, 0x66, 0x4D, 0xE6, 0xFE, + 0xDA, 0xCB, 0x87, 0x5F, 0x1A, 0xFC, 0xFF, 0x0F, 0x00, 0xEE, 0x93, 0x53, + 0x96, 0xD2, 0xC6, 0x80, 0x56, 0x00, 0x00, 0x00, 0x09, 0x70, 0x48, 0x59, + 0x73, 0x00, 0x00, 0x0B, 0x12, 0x00, 0x00, 0x0B, 0x12, 0x01, 0xD2, 0xDD, + 0x7E, 0xFC, 0x00, 0x00, 0x20, 0x00, 0x49, 0x44, 0x41, 0x54, 0x78, 0x9C, + 0x8C, 0xBD, 0x59, 0x8F, 0x2C, 0x4B, 0x92, 0x1E, 0x66, 0x8B, 0x7B, 0x44, + 0xE4, 0x52, 0x55, 0x67, 0xB9, 0x4B, 0x77, 0x4F, 0x37, 0x1B, 0x33, 0xC4, + 0x50, 0xE4, 0x48, 0xE0, 0x22, 0x3D, 0x09, 0xD0, 0x0B, 0xFF, 0x90, 0x20, + 0x40, 0xBF, 0x50, 0x7A, 0xD0, 0x83, 0x1E, 0x28, 0x90, 0x18, 0x0C, 0xC5, + 0x6D, 0x7A, 0x7A, 0x99, 0x5E, 0xEE, 0x72, 0xEE, 0xA9, 0x25, 0x33, 0x23, + 0xC2, 0xDD, 0xCC, 0xF8, 0x60, 0xEE, 0x1E, 0x9E, 0x59, 0x75, 0x87, 0x8C, + 0x0B, 0x9C, 0x5B, 0x95, 0x15, 0xE9, 0xAB, 0xD9, 0x67, 0x8B, 0x9B, 0x99, + 0xE3, 0xBF, 0xFD, 0xF7, 0xBF, 0x8E, 0x81, 0xA7, 0x21, 0x0C, 0x43, 0x08, + 0x44, 0x06, 0x06, 0x80, 0x00, 0x06, 0x06, 0x44, 0x04, 0x06, 0x80, 0x06, + 0x80, 0xA2, 0x62, 0x06, 0x4B, 0xCA, 0xA6, 0x06, 0xFE, 0x20, 0x12, 0x00, + 0x22, 0x02, 0x82, 0x88, 0x02, 0x00, 0x31, 0x83, 0x19, 0x22, 0x20, 0xA0, + 0x9A, 0x31, 0xA3, 0x88, 0x8A, 0x28, 0x02, 0x02, 0x82, 0xAA, 0x65, 0xD1, + 0x94, 0xC5, 0xCC, 0x0C, 0x90, 0x11, 0x89, 0x31, 0x30, 0x1D, 0x77, 0x23, + 0x12, 0x8A, 0xE8, 0x92, 0x72, 0xCE, 0x62, 0x06, 0x59, 0x54, 0xD4, 0xB2, + 0xA8, 0x88, 0x8C, 0x43, 0x18, 0x62, 0x48, 0x59, 0x97, 0x94, 0xD7, 0x24, + 0x22, 0x06, 0x00, 0x6A, 0x60, 0x3E, 0x44, 0x00, 0x33, 0x33, 0x03, 0x30, + 0x10, 0x53, 0x33, 0x00, 0x40, 0x00, 0x30, 0x00, 0x35, 0x43, 0x00, 0x42, + 0x44, 0x34, 0x00, 0x40, 0x44, 0x44, 0x04, 0x00, 0x33, 0x55, 0x45, 0x05, + 0x30, 0x03, 0x55, 0x53, 0x50, 0x53, 0x34, 0xF3, 0x17, 0x20, 0x30, 0x02, + 0xC2, 0x92, 0x14, 0xC0, 0x54, 0xB1, 0x4E, 0x14, 0xCC, 0x3B, 0x03, 0x50, + 0x33, 0x30, 0x33, 0x00, 0x00, 0x34, 0x33, 0x66, 0x9A, 0x22, 0xA5, 0xAC, + 0x63, 0x24, 0x44, 0xBC, 0xDF, 0xC7, 0xFB, 0x5D, 0xFC, 0x7C, 0x5A, 0x3F, + 0xBD, 0xAC, 0x7F, 0xF6, 0x71, 0x8F, 0x08, 0x39, 0xDB, 0xFB, 0xBB, 0x29, + 0x32, 0x8E, 0x43, 0xD8, 0xEF, 0x06, 0x42, 0xF8, 0x0F, 0xBF, 0xFE, 0xFE, + 0xEF, 0x3F, 0x9D, 0x0D, 0xB0, 0xB4, 0x02, 0x65, 0xC5, 0x11, 0x4B, 0x5F, + 0x88, 0x10, 0x03, 0xAF, 0x49, 0xCD, 0x00, 0x11, 0xC4, 0x4C, 0x0D, 0x08, + 0xC0, 0xCC, 0xD4, 0x20, 0x30, 0x12, 0x62, 0x12, 0x43, 0xAC, 0x03, 0xF1, + 0x5D, 0x00, 0x20, 0x84, 0xE3, 0x14, 0x10, 0x21, 0x12, 0x25, 0xB5, 0x25, + 0xC9, 0x18, 0x29, 0x89, 0x9D, 0x66, 0xF1, 0x4E, 0xB0, 0x4C, 0xE8, 0xF6, + 0xF9, 0xB1, 0x3F, 0xF8, 0xE7, 0xBE, 0x70, 0x08, 0x86, 0x4E, 0x0A, 0x65, + 0x81, 0xB7, 0xC7, 0xAC, 0x2D, 0x0B, 0x12, 0xDA, 0xFF, 0xFA, 0x57, 0x3F, + 0xFD, 0xF0, 0xB0, 0xB3, 0x8D, 0x4C, 0xD0, 0xCA, 0x03, 0x21, 0x04, 0x66, + 0xEA, 0x7B, 0xF4, 0xBF, 0xD6, 0x76, 0x4C, 0x55, 0x45, 0xC4, 0xCC, 0x44, + 0x24, 0xA5, 0x9C, 0x52, 0xF6, 0x77, 0x98, 0xC9, 0x0C, 0x54, 0xD5, 0x1B, + 0x42, 0x44, 0x44, 0x62, 0x46, 0x22, 0x24, 0x22, 0xFF, 0x6E, 0x25, 0x06, + 0xF3, 0xD7, 0x54, 0xCB, 0xAF, 0xDE, 0x38, 0x33, 0x0D, 0x31, 0x0E, 0x31, + 0x72, 0x0C, 0x56, 0xFE, 0x0C, 0xC8, 0x64, 0x66, 0xE8, 0xE3, 0x56, 0x53, + 0x55, 0x2B, 0x34, 0x53, 0x17, 0x84, 0xEA, 0xCF, 0xE6, 0xFF, 0x99, 0xA9, + 0xB5, 0x47, 0x4D, 0x45, 0x54, 0x54, 0x24, 0x4B, 0x16, 0x55, 0x55, 0x11, + 0x55, 0xB1, 0xBE, 0xDF, 0x7E, 0xA6, 0x21, 0x10, 0x07, 0x66, 0x66, 0x22, + 0xF2, 0x61, 0x23, 0x02, 0x11, 0x02, 0x00, 0x33, 0x77, 0x24, 0x5A, 0xE6, + 0x82, 0x88, 0xF5, 0xB5, 0xDB, 0x3F, 0xF9, 0x42, 0xF9, 0x4C, 0xEB, 0x1A, + 0x3A, 0x19, 0x03, 0x00, 0xA8, 0x9A, 0x88, 0x00, 0x80, 0xAA, 0xFA, 0xD7, + 0x89, 0xA8, 0xDB, 0x88, 0xB2, 0x86, 0x65, 0xC5, 0x14, 0xFB, 0xD5, 0xB3, + 0xD6, 0x0A, 0x42, 0xB7, 0xA4, 0x00, 0x60, 0xAA, 0xEA, 0x0D, 0xB6, 0x31, + 0x38, 0x13, 0x22, 0x12, 0x21, 0x6D, 0x8B, 0x86, 0x18, 0x23, 0x85, 0x10, + 0x42, 0x08, 0x60, 0x96, 0x25, 0xAB, 0x9A, 0x8A, 0x22, 0x51, 0x99, 0x3A, + 0x02, 0x21, 0x31, 0x13, 0x22, 0x70, 0x60, 0x55, 0x45, 0x44, 0x55, 0x93, + 0xAC, 0x59, 0x44, 0x6B, 0xBB, 0x3E, 0xF7, 0x35, 0x6B, 0xCA, 0x92, 0xB2, + 0xCE, 0xAB, 0xA4, 0xAC, 0x00, 0xE0, 0x6F, 0x88, 0x99, 0x81, 0x31, 0x11, + 0x18, 0x1C, 0xA6, 0x18, 0x44, 0x0C, 0x41, 0x35, 0x18, 0x98, 0xCD, 0x6B, + 0x4A, 0x59, 0x08, 0x31, 0x04, 0x8E, 0x81, 0x54, 0x35, 0x57, 0x6E, 0x4E, + 0xA2, 0x60, 0x80, 0x8E, 0x5E, 0x75, 0x83, 0x22, 0x33, 0x33, 0x49, 0x99, + 0x1E, 0x82, 0xA9, 0x19, 0x88, 0xA8, 0x99, 0x11, 0x11, 0x33, 0x13, 0x62, + 0x36, 0x33, 0x30, 0x42, 0x12, 0x55, 0x33, 0x03, 0x84, 0x94, 0xD5, 0xD4, + 0x04, 0x11, 0x32, 0x22, 0x82, 0xAA, 0x8D, 0x43, 0x58, 0xD7, 0xEC, 0x7C, + 0xC0, 0x8C, 0x00, 0x10, 0x03, 0x02, 0x80, 0xA8, 0x99, 0x59, 0x60, 0x1A, + 0x02, 0xEF, 0x86, 0x70, 0x59, 0xF3, 0xE7, 0xE7, 0xD9, 0x00, 0xB4, 0x42, + 0x58, 0xE5, 0x24, 0x50, 0x6B, 0xB0, 0x50, 0xFE, 0x87, 0x80, 0xB4, 0x2D, + 0x2C, 0x38, 0xA3, 0x21, 0x56, 0x2E, 0xB0, 0x02, 0x7B, 0x00, 0x08, 0x58, + 0x3E, 0x22, 0x44, 0x03, 0x13, 0x01, 0xE7, 0xD8, 0x9E, 0x51, 0xCD, 0x77, + 0x14, 0xC0, 0xBF, 0xE4, 0x7B, 0xED, 0xAB, 0xBF, 0x66, 0x8D, 0x81, 0x86, + 0x40, 0x3E, 0xE0, 0x6F, 0x1E, 0x2F, 0x29, 0x9B, 0xAA, 0x9D, 0xE6, 0x7C, + 0x37, 0xC5, 0x25, 0xA5, 0x4F, 0x4F, 0x97, 0x7F, 0xF4, 0xF5, 0xC3, 0x6E, + 0x8A, 0x08, 0xB8, 0xAE, 0xD9, 0x87, 0x15, 0x08, 0xD5, 0x40, 0xB5, 0xEF, + 0x07, 0x9D, 0x57, 0xD4, 0x6C, 0x00, 0x78, 0xD8, 0x87, 0x39, 0xE9, 0x9A, + 0xD5, 0x87, 0x82, 0x08, 0x81, 0x49, 0xD5, 0x88, 0x48, 0x54, 0x6F, 0x90, + 0xC7, 0x67, 0x95, 0xD5, 0x98, 0x70, 0x88, 0x24, 0x62, 0x00, 0x36, 0x46, + 0x0A, 0x4C, 0x97, 0x35, 0xC3, 0x3F, 0x80, 0x61, 0x3F, 0xF2, 0xF4, 0xEF, + 0x3B, 0x8A, 0xF9, 0xE8, 0x0A, 0xD8, 0x76, 0x7F, 0x35, 0x33, 0x44, 0xD8, + 0x0F, 0x0C, 0x00, 0x97, 0x25, 0xFD, 0xE5, 0x9F, 0xBD, 0xFB, 0xF8, 0xB0, + 0x47, 0xA2, 0xBA, 0xD0, 0xD8, 0xB8, 0xBA, 0x71, 0xCE, 0xCD, 0xD7, 0x5F, + 0xF7, 0xBE, 0x71, 0x14, 0x80, 0x88, 0x81, 0x15, 0x6E, 0x44, 0xC4, 0xC6, + 0x48, 0x44, 0x88, 0x88, 0x8E, 0x02, 0x1B, 0x4F, 0x9A, 0x33, 0x9B, 0xF9, + 0x76, 0xF7, 0x80, 0x02, 0x60, 0x0E, 0x1F, 0x26, 0xEA, 0xFB, 0x88, 0x00, + 0x2A, 0x6A, 0x60, 0x8C, 0xE4, 0x82, 0x71, 0xA3, 0xEE, 0x7E, 0x1D, 0x6E, + 0xC0, 0xCB, 0x51, 0xD2, 0x29, 0x50, 0x4D, 0xC4, 0x85, 0x75, 0xEB, 0xCB, + 0x7A, 0x94, 0x6F, 0x92, 0xC0, 0xFF, 0x35, 0xD8, 0x56, 0xC3, 0x79, 0xC4, + 0x57, 0xC2, 0x51, 0x06, 0x00, 0x9C, 0xA5, 0xDB, 0x77, 0xDB, 0xE7, 0xFD, + 0xF4, 0x37, 0xD0, 0x69, 0x2D, 0x97, 0xC6, 0xA1, 0x76, 0x8D, 0x0D, 0xDD, + 0x36, 0x51, 0x54, 0xF7, 0xA2, 0x1F, 0x52, 0x83, 0xBF, 0x9B, 0xA1, 0x96, + 0xF6, 0xAF, 0x24, 0x25, 0xF4, 0xAF, 0xF5, 0x20, 0x5B, 0x65, 0x24, 0x32, + 0x23, 0x21, 0x67, 0x71, 0x09, 0x82, 0x66, 0x40, 0x84, 0x01, 0x99, 0x98, + 0x52, 0xCA, 0xFE, 0x3E, 0xB9, 0x9A, 0x83, 0x8E, 0xAA, 0x80, 0x08, 0xAA, + 0x2A, 0xD9, 0x88, 0x8C, 0x18, 0x31, 0x10, 0x31, 0x89, 0x88, 0xAB, 0x3E, + 0xDE, 0x42, 0x8C, 0x26, 0xA2, 0xF3, 0x92, 0xB2, 0x28, 0x02, 0x89, 0x2A, + 0x00, 0x89, 0x2A, 0x33, 0xBE, 0x3F, 0xEE, 0xA6, 0x81, 0x55, 0xE1, 0x30, + 0x85, 0x00, 0x00, 0x6A, 0x36, 0xAF, 0x79, 0x5E, 0xB3, 0x99, 0x21, 0x20, + 0x11, 0x8A, 0x9A, 0x28, 0x21, 0xE0, 0x30, 0x30, 0x63, 0x25, 0x4A, 0x40, + 0x22, 0x64, 0x26, 0x66, 0x72, 0x79, 0x04, 0x08, 0xCC, 0x6C, 0x66, 0x43, + 0x0C, 0x95, 0xEC, 0x74, 0x4D, 0x19, 0x01, 0x62, 0x0C, 0xCC, 0xA4, 0x6A, + 0xE3, 0x10, 0x53, 0x96, 0x9C, 0x33, 0x13, 0x89, 0x64, 0x04, 0x18, 0x42, + 0x58, 0x53, 0xCE, 0xA2, 0xCE, 0x18, 0xAE, 0x7F, 0x31, 0xA1, 0x9A, 0x69, + 0x52, 0x01, 0x33, 0x73, 0xA0, 0x35, 0x00, 0x24, 0xC4, 0x79, 0xC9, 0x48, + 0xC8, 0x84, 0x43, 0xA0, 0x71, 0xE0, 0x94, 0x35, 0x67, 0xAD, 0x7A, 0x0C, + 0x98, 0x0B, 0x5E, 0x30, 0x74, 0x75, 0x69, 0xDB, 0x0C, 0x13, 0x03, 0xBA, + 0x92, 0xF9, 0x58, 0x36, 0xBA, 0x51, 0xDA, 0x35, 0x7F, 0x8B, 0x98, 0x56, + 0xD6, 0x42, 0x44, 0x04, 0x53, 0xF3, 0xDD, 0x05, 0xFF, 0x1F, 0x21, 0x10, + 0xA1, 0x54, 0x4E, 0x70, 0x8A, 0xCA, 0x62, 0x77, 0xBB, 0x80, 0x00, 0xF7, + 0xFB, 0xE1, 0xBB, 0xE7, 0x65, 0x49, 0xB2, 0x1B, 0x82, 0xA8, 0x9D, 0x97, + 0x7C, 0xBF, 0x8B, 0x31, 0xD0, 0xFB, 0xFB, 0xDD, 0x10, 0x99, 0x10, 0xE7, + 0x25, 0xAD, 0x29, 0x13, 0x96, 0x15, 0x86, 0xAA, 0x7F, 0xA9, 0xFA, 0x40, + 0x8A, 0x24, 0x44, 0x80, 0x35, 0xAB, 0x19, 0xF8, 0x3B, 0x60, 0x80, 0x05, + 0x3A, 0x31, 0x04, 0x54, 0x35, 0x31, 0xC0, 0x6E, 0x06, 0x8D, 0x3A, 0x09, + 0xF1, 0xB2, 0xCA, 0x10, 0xF8, 0x38, 0x05, 0x00, 0x38, 0xEC, 0xE2, 0xB7, + 0x8F, 0x17, 0x35, 0xAB, 0xBA, 0xDE, 0x7F, 0x2F, 0x96, 0x35, 0xF6, 0x28, + 0xEA, 0x09, 0x18, 0xA0, 0x61, 0x13, 0x12, 0xD8, 0xBF, 0x09, 0x6A, 0xF0, + 0xE5, 0xFD, 0xF4, 0xD5, 0xFD, 0x78, 0x9A, 0x57, 0xC4, 0xE9, 0x2F, 0x7E, + 0xF6, 0x9E, 0x98, 0xFD, 0xAF, 0xCE, 0x87, 0x4D, 0x29, 0xB8, 0x69, 0xFF, + 0xC7, 0x9E, 0x0A, 0x46, 0x5A, 0xA9, 0xAE, 0x70, 0x54, 0xDD, 0x97, 0xBA, + 0x39, 0x00, 0xD4, 0xE4, 0x6A, 0x6D, 0x11, 0x09, 0xB1, 0x12, 0x42, 0x0F, + 0x64, 0x6D, 0x7D, 0x4A, 0x17, 0x8E, 0x86, 0xA5, 0x6D, 0x00, 0x04, 0x35, + 0x73, 0xF1, 0x85, 0x4C, 0x9B, 0xC6, 0x89, 0x05, 0x30, 0x1A, 0x7E, 0xB9, + 0x12, 0xA4, 0x66, 0x66, 0x0A, 0x88, 0x0D, 0x37, 0x6F, 0x56, 0xAF, 0xC9, + 0xB9, 0x9B, 0x59, 0x23, 0x56, 0xA2, 0xBD, 0x82, 0x98, 0x32, 0xEB, 0x5E, + 0x51, 0xF2, 0xA5, 0xEB, 0x61, 0xA8, 0x6B, 0xBC, 0xBC, 0xC6, 0x48, 0x02, + 0x8A, 0x8D, 0x06, 0xEA, 0xBA, 0x88, 0x6E, 0x8D, 0xFB, 0xCB, 0x0D, 0x10, + 0x7B, 0x9C, 0xDA, 0x7A, 0xB7, 0x4D, 0x07, 0xEB, 0xF5, 0x3E, 0x27, 0xC8, + 0x0A, 0x76, 0x7A, 0x03, 0x82, 0xDD, 0x6B, 0x00, 0x00, 0xCC, 0x1C, 0x63, + 0x40, 0xC0, 0x3C, 0x27, 0x30, 0x13, 0x71, 0x25, 0x4B, 0x95, 0x0B, 0xF7, + 0x10, 0xD1, 0x18, 0x23, 0x31, 0x8A, 0xAB, 0x44, 0x84, 0x44, 0x18, 0x63, + 0x30, 0x53, 0x22, 0x70, 0x51, 0x01, 0x08, 0x84, 0x40, 0xC4, 0x0E, 0x91, + 0xAE, 0x1E, 0x91, 0x9A, 0xA9, 0x11, 0xE1, 0x18, 0x78, 0x05, 0xDD, 0x8D, + 0x31, 0x8B, 0x70, 0x92, 0xE3, 0x6E, 0xB8, 0x3F, 0x8C, 0xC7, 0xFD, 0x48, + 0x84, 0x29, 0x49, 0x00, 0x00, 0x55, 0x5B, 0x4D, 0x7C, 0xE9, 0x09, 0xC0, + 0xC4, 0xCC, 0x4C, 0xC4, 0x62, 0x20, 0x53, 0x32, 0x2A, 0xD8, 0x1F, 0x03, + 0x23, 0x60, 0x0C, 0x1C, 0x22, 0x6F, 0xAB, 0xC9, 0xE4, 0x52, 0xB1, 0x49, + 0x1A, 0x51, 0x73, 0xE9, 0xA0, 0x85, 0x10, 0x41, 0x0D, 0xDC, 0x32, 0x5D, + 0xD7, 0x0C, 0x00, 0xBB, 0x29, 0xBE, 0x9C, 0x97, 0x4F, 0x9F, 0x4F, 0x44, + 0xA8, 0x66, 0xEB, 0x9A, 0x2F, 0xCB, 0xCA, 0x44, 0xCE, 0x36, 0x2E, 0xFF, + 0x44, 0x9C, 0xB4, 0x60, 0x88, 0x01, 0x11, 0x52, 0x96, 0xA5, 0x70, 0x3E, + 0x8A, 0x9A, 0x96, 0x9F, 0x9B, 0x99, 0xE9, 0x32, 0x6A, 0xE3, 0x84, 0x4D, + 0x81, 0x2A, 0x54, 0x85, 0x6E, 0x21, 0x3B, 0x04, 0x10, 0x16, 0x95, 0xCA, + 0x75, 0x4C, 0x43, 0x2C, 0x64, 0x0F, 0x68, 0xB6, 0x69, 0xCE, 0x1B, 0x7B, + 0x20, 0x8A, 0xEA, 0x17, 0xF7, 0xE3, 0x18, 0xF9, 0xE9, 0xBC, 0x66, 0xC6, + 0x35, 0xAB, 0xA8, 0xD3, 0x3B, 0xEE, 0x06, 0x06, 0x83, 0xE3, 0x3E, 0x8A, + 0x9A, 0x9A, 0x89, 0xC2, 0x9A, 0xF5, 0xB8, 0x0B, 0x5F, 0xDC, 0x4F, 0xFB, + 0x29, 0x1E, 0x76, 0x71, 0x37, 0x06, 0x33, 0x43, 0x84, 0x24, 0xF2, 0xC3, + 0xCB, 0xFC, 0x7C, 0x59, 0x09, 0x29, 0x9B, 0x12, 0xFA, 0x14, 0x8A, 0x58, + 0x6B, 0x24, 0xE4, 0xF4, 0xB7, 0x66, 0x55, 0xB3, 0x21, 0x10, 0x02, 0x24, + 0x05, 0x30, 0xC8, 0x62, 0x4C, 0x98, 0xC4, 0x7A, 0x24, 0x21, 0x44, 0x40, + 0xAC, 0xDA, 0x25, 0xAC, 0x59, 0x5F, 0xE6, 0x44, 0x08, 0xEF, 0xEF, 0x26, + 0xFF, 0x55, 0x14, 0x7A, 0x3E, 0x80, 0xBA, 0x5C, 0x6F, 0x3D, 0x58, 0x4D, + 0x8A, 0xC2, 0x6F, 0xFE, 0xC5, 0xF6, 0xEB, 0x2D, 0x53, 0xB9, 0xFA, 0x61, + 0x7A, 0x18, 0x79, 0xBF, 0x8B, 0xEF, 0xEE, 0xA7, 0xFD, 0x34, 0xEE, 0xA6, + 0x51, 0xAB, 0x2E, 0xD6, 0x56, 0xB2, 0xFD, 0x6A, 0xD7, 0xEA, 0xD8, 0xEB, + 0xA7, 0xD7, 0x7A, 0x0A, 0x93, 0x81, 0x76, 0xA2, 0x08, 0xAA, 0x22, 0x60, + 0x48, 0x06, 0x4D, 0x7F, 0x6A, 0xCD, 0x6A, 0x9B, 0x86, 0xB6, 0xD6, 0x10, + 0x31, 0x30, 0x0D, 0x21, 0xC2, 0x15, 0x03, 0x6F, 0xAC, 0x0E, 0x75, 0x7A, + 0x06, 0xC5, 0x61, 0x51, 0x7E, 0x2D, 0x64, 0x54, 0xF1, 0x4B, 0xB5, 0xD9, + 0x6B, 0x52, 0xD5, 0xA2, 0xA2, 0xB0, 0x82, 0x6D, 0x5A, 0x0F, 0x5A, 0xAF, + 0x06, 0x11, 0xE1, 0xF6, 0xE2, 0xF5, 0x1C, 0x7B, 0xDB, 0xDD, 0x3F, 0xE9, + 0xF1, 0xAB, 0xEA, 0x3B, 0xDB, 0xDE, 0xDC, 0x40, 0xB3, 0xA1, 0x81, 0x6E, + 0xEB, 0xD9, 0x10, 0xB1, 0xFF, 0xCA, 0x0D, 0xF4, 0xB4, 0x01, 0xF4, 0x6D, + 0x22, 0x01, 0x02, 0x98, 0xB6, 0x06, 0x4A, 0x17, 0x65, 0x39, 0x00, 0xDA, + 0xEC, 0x1C, 0x13, 0xFB, 0xC1, 0xF4, 0x1D, 0xF9, 0x87, 0x4C, 0x80, 0x82, + 0xD9, 0x14, 0x15, 0xD7, 0x25, 0xDB, 0x50, 0xB6, 0x8C, 0x10, 0x98, 0x89, + 0x18, 0x99, 0xC9, 0xD4, 0x88, 0x89, 0x08, 0x89, 0x10, 0x31, 0x00, 0x40, + 0xD5, 0x69, 0xCB, 0xD8, 0x98, 0xB9, 0xAE, 0x06, 0x18, 0x21, 0x12, 0x32, + 0x53, 0x0C, 0x7C, 0x9E, 0x93, 0xA8, 0xAD, 0x8B, 0xAE, 0x49, 0xD2, 0x50, + 0x1C, 0x0D, 0xCC, 0xA1, 0xB4, 0xD2, 0x3F, 0x02, 0x86, 0x00, 0xA6, 0xA0, + 0xAE, 0x1B, 0x81, 0x4D, 0x43, 0x8C, 0x81, 0x8A, 0x9E, 0x0B, 0x48, 0xEC, + 0x32, 0x10, 0xDC, 0xD8, 0x7F, 0x0D, 0xD2, 0x11, 0xDD, 0x69, 0xA2, 0x56, + 0xA1, 0xC7, 0xCC, 0x22, 0x10, 0x11, 0x1D, 0xF7, 0xA3, 0x81, 0xA9, 0xDA, + 0x5E, 0x0D, 0xDF, 0x01, 0x33, 0x01, 0x20, 0x21, 0x64, 0xD1, 0xCF, 0xCF, + 0x17, 0x03, 0x5B, 0xD6, 0xBC, 0x66, 0xC9, 0xA2, 0x66, 0x38, 0x46, 0xDE, + 0x8D, 0x43, 0x8C, 0xAE, 0xF1, 0x15, 0x05, 0x5F, 0xD5, 0x88, 0x10, 0x17, + 0x48, 0x49, 0x0B, 0x54, 0x55, 0x14, 0xF3, 0x55, 0xD5, 0x5E, 0xC0, 0x00, + 0x18, 0x80, 0x98, 0x6B, 0x13, 0x65, 0xD1, 0xB5, 0xC1, 0x5C, 0xC7, 0xCE, + 0x76, 0xAB, 0xAA, 0x5D, 0x3D, 0x66, 0x76, 0xB7, 0x8B, 0x6A, 0xF6, 0xF9, + 0xB4, 0x9E, 0x17, 0x89, 0x8C, 0x91, 0x5D, 0xC5, 0x45, 0x00, 0xCB, 0x6A, + 0x7B, 0xC2, 0x2C, 0xF6, 0x7C, 0x49, 0x4B, 0x52, 0x05, 0x58, 0xB3, 0x1C, + 0xA7, 0xF1, 0xEB, 0xF7, 0x87, 0x94, 0x95, 0xD0, 0x15, 0x07, 0xFC, 0xDB, + 0xDF, 0xFF, 0xF0, 0xDD, 0xE7, 0xCB, 0x22, 0x9A, 0xC5, 0x39, 0xC7, 0xE9, + 0xBB, 0xF0, 0x40, 0xED, 0xE7, 0x4A, 0xDA, 0x21, 0xE0, 0x9A, 0xD5, 0xED, + 0x11, 0x9F, 0xA3, 0xCA, 0xED, 0x08, 0xB5, 0xFB, 0x0E, 0x02, 0x44, 0xA6, + 0xC3, 0x14, 0xC6, 0x81, 0xD7, 0x94, 0x01, 0x70, 0x59, 0x15, 0x00, 0x68, + 0x23, 0x63, 0x43, 0x84, 0xA2, 0x4E, 0xBE, 0x52, 0x8C, 0x10, 0x8A, 0x06, + 0xE4, 0x0B, 0x62, 0x86, 0x08, 0x0A, 0x80, 0x70, 0xCD, 0x2A, 0xBD, 0x23, + 0x46, 0x4D, 0x3F, 0x1E, 0xC7, 0x2F, 0x1E, 0xF6, 0x1F, 0xDF, 0x1D, 0x86, + 0x21, 0x6E, 0x84, 0x5F, 0x99, 0xCD, 0x99, 0xDF, 0x1D, 0x40, 0x00, 0x57, + 0x38, 0xD8, 0x2F, 0x2F, 0x74, 0x2A, 0x49, 0x6F, 0xC7, 0x99, 0x19, 0x02, + 0x9A, 0x9A, 0xE1, 0x86, 0x14, 0x88, 0xC5, 0x0F, 0xEB, 0xAA, 0x13, 0x12, + 0xBA, 0xAA, 0x95, 0x55, 0x9D, 0x08, 0x88, 0x50, 0x64, 0x63, 0x57, 0x42, + 0x9C, 0xC6, 0xB1, 0xB9, 0xD2, 0x5C, 0x43, 0x0C, 0x21, 0xB4, 0xE5, 0xB6, + 0x6B, 0x43, 0xAC, 0xB8, 0x88, 0x2B, 0xDC, 0xF8, 0x14, 0xDC, 0x31, 0xA2, + 0xE5, 0xBF, 0x8D, 0xE5, 0x6E, 0x98, 0xDF, 0xAC, 0x89, 0x42, 0x24, 0x72, + 0x1D, 0x0F, 0x7C, 0x48, 0x6D, 0x3C, 0xDD, 0xCB, 0x6A, 0xC6, 0xB5, 0x11, + 0x64, 0x66, 0xE8, 0x40, 0xA1, 0x5F, 0x46, 0x00, 0x70, 0xD7, 0x21, 0x22, + 0x42, 0x9D, 0x42, 0xE5, 0x7C, 0x6D, 0x20, 0xE2, 0xAD, 0x83, 0xD5, 0xDE, + 0x8B, 0x38, 0x2A, 0x9A, 0x97, 0x2B, 0xFE, 0x0D, 0x8C, 0x6E, 0x90, 0x08, + 0x08, 0xC0, 0xAE, 0xB0, 0xD2, 0xE7, 0xAB, 0x1D, 0x06, 0xDF, 0x20, 0x63, + 0x2F, 0x15, 0xCC, 0x9A, 0x7A, 0x01, 0x88, 0xC0, 0x40, 0x08, 0x20, 0xAA, + 0x54, 0x76, 0x1F, 0x10, 0x49, 0xCD, 0x02, 0x32, 0x12, 0x19, 0x29, 0x62, + 0x71, 0x0E, 0x78, 0x0B, 0xCC, 0x08, 0x40, 0x66, 0x26, 0xB2, 0xAD, 0x2D, + 0x00, 0xB8, 0x66, 0x87, 0x00, 0x84, 0x34, 0x84, 0xA0, 0x83, 0x9D, 0xE6, + 0xD5, 0xD4, 0x44, 0x6D, 0x5E, 0xF3, 0x9A, 0x24, 0x8B, 0x46, 0x33, 0x22, + 0x0C, 0xA5, 0x2D, 0x02, 0x46, 0x72, 0x07, 0x0D, 0x00, 0x28, 0x18, 0x16, + 0x53, 0x4B, 0x00, 0x00, 0x71, 0x88, 0x01, 0xB0, 0xAC, 0x8E, 0x01, 0x60, + 0x0C, 0xDC, 0x1B, 0xF0, 0x00, 0x37, 0x6C, 0x61, 0x08, 0x44, 0x7C, 0x4B, + 0xD0, 0x6D, 0x21, 0xA6, 0xA9, 0x88, 0x47, 0x42, 0x24, 0xA6, 0x03, 0xF3, + 0x34, 0x0D, 0x22, 0x9A, 0x45, 0xCE, 0x97, 0xF5, 0xBB, 0xC7, 0xD3, 0x65, + 0x4E, 0xAA, 0xB4, 0xE6, 0x8C, 0x04, 0x31, 0xF0, 0x61, 0x8A, 0xEE, 0xFE, + 0x77, 0x0C, 0x50, 0xB5, 0x94, 0x57, 0x77, 0x09, 0x6E, 0xC2, 0xAE, 0x91, + 0x4D, 0x27, 0xC0, 0x7B, 0x56, 0xE9, 0x41, 0xC2, 0xAC, 0xA9, 0x42, 0x3E, + 0xDA, 0x46, 0x00, 0x0D, 0xCD, 0x5C, 0x55, 0x2F, 0xE6, 0xAA, 0x98, 0x5D, + 0x2E, 0xE2, 0xCE, 0xB8, 0xAC, 0x30, 0x20, 0x22, 0x00, 0x12, 0xA8, 0x82, + 0x88, 0xCD, 0x49, 0x44, 0x4D, 0x2A, 0x25, 0x29, 0xC0, 0x2A, 0x3A, 0x2F, + 0x39, 0x38, 0xE8, 0x03, 0x3E, 0x9D, 0xE6, 0x3F, 0x7E, 0x3A, 0x0F, 0x81, + 0x46, 0x24, 0x51, 0x49, 0xE2, 0xBE, 0xF3, 0xD6, 0x51, 0xF5, 0xD0, 0xBC, + 0x56, 0x56, 0x6C, 0x1B, 0xD0, 0xEB, 0xA7, 0x70, 0x11, 0x00, 0x00, 0xC4, + 0x80, 0xBB, 0x18, 0x76, 0x03, 0xDF, 0xED, 0xA2, 0x81, 0x1D, 0xF7, 0xC3, + 0x79, 0x4E, 0x88, 0x05, 0x9E, 0xAA, 0xA0, 0xC6, 0xD2, 0x62, 0x93, 0xDE, + 0xB5, 0x4B, 0x02, 0x73, 0x12, 0xF4, 0x81, 0x80, 0x99, 0x1B, 0x69, 0x50, + 0x4D, 0x8E, 0xD6, 0xA3, 0x99, 0x0D, 0x81, 0x76, 0x91, 0xD7, 0x2C, 0x3F, + 0xFB, 0xE2, 0xFE, 0xCF, 0x3E, 0x1E, 0xF7, 0xBB, 0x21, 0xC4, 0xD8, 0x2F, + 0x75, 0xFB, 0xC1, 0x9D, 0x3E, 0x4D, 0xB9, 0x78, 0x6B, 0x86, 0xDB, 0xCB, + 0x15, 0x39, 0xA4, 0x3A, 0xF5, 0xCB, 0x90, 0x0B, 0x7C, 0xA3, 0x31, 0x13, + 0x56, 0x83, 0xC8, 0x7F, 0x20, 0x2E, 0xDC, 0xE0, 0x5E, 0x00, 0xAB, 0x6A, + 0x04, 0x11, 0xAA, 0xBA, 0x1F, 0x07, 0xC7, 0x21, 0x12, 0x91, 0x4B, 0x78, + 0xB3, 0xE2, 0x05, 0xEF, 0x21, 0xF5, 0x86, 0x5A, 0xD0, 0xB6, 0xF1, 0xB4, + 0x17, 0x0A, 0x8A, 0x99, 0xB9, 0x41, 0x60, 0x55, 0x81, 0xE9, 0x15, 0xA5, + 0x2A, 0xBC, 0x5D, 0x9F, 0x02, 0x03, 0x73, 0x7D, 0x99, 0x2A, 0xAB, 0x5B, + 0xE7, 0x37, 0xF4, 0xAF, 0xAB, 0xAA, 0x3B, 0x67, 0xA0, 0xA3, 0x52, 0xC7, + 0x7D, 0x5F, 0xBA, 0x86, 0x62, 0x8D, 0x7D, 0xAE, 0x7D, 0xFC, 0xDA, 0x4F, + 0x04, 0x5D, 0x37, 0x47, 0xE8, 0xBD, 0xC3, 0xE0, 0xFE, 0x44, 0x00, 0x20, + 0xDF, 0x91, 0xD2, 0xEF, 0x15, 0x0C, 0x35, 0x16, 0xE8, 0xA6, 0xEC, 0x4E, + 0x77, 0xEC, 0x24, 0x59, 0xBF, 0x5F, 0x76, 0xAD, 0x77, 0xFB, 0xC0, 0x8A, + 0x67, 0x9C, 0x8A, 0x29, 0x56, 0xBD, 0xE7, 0x80, 0x88, 0x46, 0x00, 0x68, + 0x06, 0x4C, 0x68, 0xD5, 0xBF, 0x49, 0xAD, 0x35, 0x77, 0x11, 0x98, 0x19, + 0x11, 0x98, 0x75, 0xDE, 0x12, 0xDF, 0x32, 0x55, 0x04, 0x22, 0xC6, 0x18, + 0x78, 0x3F, 0xC6, 0x94, 0x34, 0x04, 0x3A, 0xEE, 0x87, 0xBB, 0xFD, 0x80, + 0x88, 0x39, 0x0B, 0x22, 0x04, 0x3F, 0x7A, 0xE4, 0xD7, 0xB4, 0x05, 0xA0, + 0x60, 0x6C, 0x98, 0xB2, 0x22, 0xAC, 0x29, 0x13, 0x11, 0xC5, 0x40, 0x31, + 0x84, 0x21, 0xB0, 0xAB, 0x72, 0x3D, 0x81, 0xDE, 0x50, 0x30, 0x34, 0x1F, + 0x56, 0xA7, 0x32, 0xA8, 0x36, 0x9B, 0x0F, 0x89, 0x30, 0x65, 0xCD, 0xAA, + 0x03, 0xC2, 0x9C, 0x65, 0x5E, 0xD3, 0x10, 0xE2, 0x34, 0xC4, 0xC8, 0xCC, + 0x8C, 0x7F, 0xFF, 0xCD, 0xD3, 0xB2, 0x66, 0x44, 0xD8, 0x4F, 0xC3, 0x6E, + 0x8A, 0x86, 0x38, 0xAF, 0x89, 0x10, 0x0D, 0x60, 0x4D, 0x32, 0xAF, 0x59, + 0xD5, 0x10, 0x01, 0x0C, 0xAD, 0x03, 0x1E, 0x2B, 0x44, 0x58, 0x97, 0xB8, + 0xA3, 0xD0, 0xEB, 0x11, 0x82, 0x3B, 0x4C, 0xCC, 0xA0, 0x1E, 0x6D, 0xA1, + 0x0B, 0xB7, 0xF6, 0xBA, 0x0F, 0xBE, 0x9E, 0x21, 0xC0, 0x69, 0x16, 0x42, + 0x18, 0x02, 0xB9, 0xF3, 0x7D, 0xCD, 0x9B, 0x8B, 0xC1, 0x00, 0xD4, 0xE0, + 0xBC, 0x0A, 0x34, 0x34, 0x32, 0x30, 0xB3, 0x71, 0x08, 0x31, 0xD0, 0xB2, + 0xE6, 0x1F, 0x9E, 0x2F, 0x4F, 0x97, 0x64, 0x00, 0xAB, 0x68, 0x64, 0x9C, + 0x22, 0x9B, 0xA9, 0xF8, 0xC9, 0xC7, 0x8D, 0x5D, 0xB0, 0x3D, 0xAE, 0x6D, + 0x00, 0x20, 0x10, 0xA0, 0x81, 0xAB, 0x46, 0xDB, 0xF2, 0xF6, 0xD3, 0x71, + 0x3C, 0x62, 0xC4, 0xBB, 0x5D, 0xF8, 0xEA, 0x61, 0x6F, 0x00, 0x97, 0x94, + 0x22, 0xB3, 0x59, 0x4A, 0xA2, 0x8C, 0x75, 0xC6, 0x15, 0xA0, 0x6A, 0xC3, + 0x45, 0x2D, 0x04, 0x28, 0xA8, 0x5A, 0xF5, 0x11, 0x6C, 0xAF, 0x36, 0x8F, + 0x54, 0x5D, 0x11, 0xC7, 0x40, 0x03, 0xB3, 0xAF, 0xDE, 0x4D, 0x3F, 0xFF, + 0xFA, 0xDD, 0x6E, 0x0C, 0x6A, 0xC0, 0xBC, 0x91, 0x0F, 0x76, 0x46, 0x47, + 0x4A, 0x09, 0x00, 0x62, 0x8C, 0x6F, 0x8C, 0xF9, 0x35, 0xBD, 0x99, 0x39, + 0xC9, 0x8A, 0x5E, 0x59, 0x19, 0x00, 0xD5, 0x1A, 0x36, 0x54, 0x54, 0x25, + 0x2A, 0x00, 0x4B, 0xD5, 0x0B, 0xE5, 0x3D, 0xAA, 0x9A, 0x9A, 0xA9, 0xF5, + 0x98, 0x0D, 0x08, 0x91, 0x39, 0x86, 0xC8, 0xCC, 0x3E, 0xC8, 0x9C, 0x33, + 0x54, 0xF6, 0xB0, 0xEA, 0xB1, 0xEE, 0xB5, 0x0C, 0xEF, 0xD5, 0xAE, 0xB4, + 0x9E, 0xC2, 0x96, 0x04, 0x28, 0x1B, 0x6D, 0x6F, 0x7A, 0xDC, 0xA6, 0xC5, + 0x98, 0xAF, 0x91, 0x21, 0x35, 0xF1, 0x83, 0x6D, 0x61, 0xBD, 0xD3, 0x36, + 0x59, 0x6F, 0xBF, 0xE9, 0xAA, 0x9D, 0x7A, 0x64, 0xAE, 0x7C, 0xF5, 0x5D, + 0xB8, 0x2D, 0xDB, 0xBA, 0x2B, 0xC7, 0x66, 0x58, 0x4C, 0x51, 0x73, 0x5D, + 0x6B, 0xD3, 0x79, 0x6F, 0xE9, 0xAA, 0x0C, 0xC0, 0x4D, 0x76, 0x55, 0xAB, + 0xBA, 0x45, 0x73, 0x62, 0x16, 0xE7, 0x7A, 0x47, 0x83, 0x75, 0x38, 0xD8, + 0xD4, 0x82, 0x1E, 0xB9, 0x7A, 0x20, 0xC3, 0xEE, 0x05, 0x33, 0xAB, 0xC6, + 0x31, 0x82, 0x47, 0x26, 0x54, 0xD1, 0xE3, 0xC3, 0x31, 0x8F, 0x6A, 0xE8, + 0x46, 0xDB, 0xBA, 0xEB, 0x7E, 0xED, 0xEC, 0xF0, 0xBA, 0x88, 0x44, 0x45, + 0x22, 0x30, 0x11, 0x11, 0x9A, 0xC1, 0x38, 0xC4, 0x18, 0x58, 0xD4, 0x54, + 0x15, 0x11, 0x82, 0x37, 0xA9, 0x56, 0x24, 0x11, 0x34, 0x9F, 0xA8, 0x81, + 0xBB, 0xA5, 0x11, 0x51, 0xD4, 0x0C, 0x34, 0x18, 0x60, 0x60, 0x04, 0x20, + 0xC6, 0x1E, 0xA4, 0x5E, 0x53, 0x67, 0xE7, 0xE3, 0x00, 0xA8, 0x5A, 0xB1, + 0x7F, 0xA0, 0x06, 0x92, 0xD5, 0x17, 0x31, 0x67, 0x11, 0x51, 0x15, 0xCD, + 0x22, 0xA2, 0x46, 0x80, 0x43, 0x1C, 0x95, 0x70, 0x8C, 0xE1, 0xDD, 0x71, + 0x4A, 0x59, 0xA6, 0x21, 0x12, 0xE1, 0xF9, 0xB2, 0xFA, 0xF9, 0xAB, 0xF7, + 0xB5, 0x24, 0xC9, 0x6A, 0x6A, 0x2E, 0xEE, 0x5C, 0xC3, 0x28, 0xFA, 0x54, + 0x03, 0x35, 0x2B, 0x4E, 0x5C, 0xB4, 0x57, 0x9E, 0xE6, 0x1E, 0x6F, 0xB5, + 0x90, 0xD4, 0x95, 0xDB, 0x08, 0x71, 0x6B, 0xAD, 0xC3, 0x41, 0x50, 0xB3, + 0x25, 0x17, 0x39, 0x4C, 0x08, 0x06, 0xC5, 0x61, 0x4F, 0xDB, 0xD6, 0x22, + 0x23, 0x26, 0x35, 0x26, 0xCC, 0x62, 0xCB, 0x9A, 0x52, 0xC2, 0xF3, 0x92, + 0x1E, 0x4F, 0xAB, 0x01, 0x10, 0xE1, 0x92, 0x64, 0x49, 0x30, 0x04, 0x3A, + 0x4E, 0x7C, 0x5A, 0x44, 0xD5, 0xCA, 0x59, 0xD3, 0xAB, 0x9D, 0xF3, 0x1E, + 0xD1, 0xDC, 0x4F, 0x68, 0x04, 0x80, 0x00, 0x0A, 0xDB, 0xDE, 0x3B, 0x75, + 0x68, 0x25, 0x0D, 0x42, 0x73, 0xF2, 0x00, 0x04, 0x33, 0x63, 0xC4, 0x35, + 0xCB, 0x79, 0xC9, 0xA5, 0xA1, 0x8A, 0x4E, 0xED, 0x37, 0x32, 0x00, 0xC7, + 0x83, 0x1F, 0x53, 0xF7, 0x9A, 0x67, 0xB7, 0x7D, 0xCB, 0xCC, 0xC0, 0x98, + 0x30, 0x65, 0xFB, 0xC5, 0x97, 0xFB, 0x5F, 0x7C, 0xFD, 0x6E, 0xB7, 0x1B, + 0x01, 0x20, 0xBC, 0xE5, 0x7F, 0x69, 0x54, 0x71, 0x43, 0x1E, 0x8D, 0x0D, + 0x6E, 0x3F, 0x51, 0x13, 0xC9, 0xAA, 0x9A, 0x53, 0x6E, 0xEA, 0x58, 0x73, + 0xF9, 0x57, 0x08, 0x35, 0x33, 0xAC, 0x2A, 0x9E, 0x6F, 0xFC, 0xD6, 0xB7, + 0xB7, 0xE8, 0x24, 0x5E, 0x08, 0x00, 0x21, 0x84, 0x10, 0x43, 0x70, 0xB0, + 0x20, 0xA2, 0x9C, 0x73, 0xCF, 0x72, 0xF0, 0xCA, 0x8E, 0xC3, 0xAA, 0x25, + 0xB5, 0x17, 0xDA, 0x50, 0xB1, 0xD2, 0x52, 0x3F, 0xF2, 0xD7, 0x94, 0x8F, + 0xC5, 0xE8, 0xBD, 0x72, 0xEA, 0xBD, 0xFE, 0x4A, 0x0F, 0x07, 0x66, 0x26, + 0x02, 0x88, 0x57, 0x1E, 0xFA, 0xA6, 0x3F, 0xD6, 0x17, 0xB4, 0x90, 0x00, + 0x40, 0x19, 0x05, 0x16, 0xDD, 0x0D, 0x0C, 0x04, 0x4A, 0x9C, 0x00, 0x02, + 0xBA, 0x75, 0xD8, 0x81, 0x5A, 0xD9, 0x64, 0x47, 0x59, 0x9F, 0x95, 0x76, + 0x13, 0x29, 0xD3, 0x6C, 0xE7, 0xE5, 0x05, 0x28, 0x37, 0x31, 0xBB, 0xC1, + 0xF4, 0x5B, 0xBB, 0xDC, 0x2F, 0x26, 0xB4, 0xA3, 0x64, 0xAC, 0x67, 0xC9, + 0xD5, 0x8F, 0xE1, 0x76, 0x6E, 0x60, 0x0F, 0xB9, 0xA0, 0xFE, 0xAC, 0xF9, + 0xAD, 0xC5, 0xF4, 0x6E, 0x37, 0x89, 0xD8, 0xA2, 0x55, 0x88, 0x0C, 0x02, + 0x8E, 0x10, 0x45, 0xC5, 0x9D, 0x54, 0x58, 0x3B, 0x0D, 0xB5, 0xA1, 0xA2, + 0x4D, 0x0C, 0x81, 0xC1, 0x2C, 0x67, 0xF5, 0x61, 0xB1, 0x6B, 0xA5, 0x08, + 0x43, 0xE4, 0xFD, 0x34, 0x4E, 0x63, 0x64, 0xA6, 0x10, 0x36, 0x31, 0xD2, + 0x04, 0xD7, 0x0D, 0xA5, 0x6A, 0x75, 0x21, 0x15, 0x03, 0x4D, 0xA1, 0x39, + 0x3F, 0x00, 0x40, 0xD5, 0x96, 0x75, 0x71, 0xFB, 0x7B, 0x5E, 0x12, 0x20, + 0x30, 0xD1, 0x30, 0x04, 0x37, 0x1B, 0x43, 0x08, 0x5F, 0x7D, 0xB8, 0x5B, + 0x53, 0x5E, 0xB3, 0xA4, 0x2C, 0x04, 0x18, 0x02, 0x9F, 0xE6, 0x74, 0x99, + 0x73, 0x0C, 0x94, 0x44, 0xB3, 0xA8, 0x99, 0x49, 0x39, 0x8F, 0xC3, 0x06, + 0x49, 0x57, 0xEB, 0x02, 0xD0, 0xA3, 0x58, 0xED, 0xBA, 0x8B, 0xB5, 0xA9, + 0x1E, 0x8D, 0x5E, 0x6B, 0x6B, 0x3B, 0xE5, 0xFA, 0x1D, 0xC0, 0x2D, 0xCB, + 0xF9, 0xA3, 0x08, 0x68, 0x40, 0xC5, 0x57, 0x8F, 0x59, 0x0C, 0x10, 0xEF, + 0x77, 0x61, 0x49, 0x9A, 0x45, 0x10, 0x80, 0x10, 0x4E, 0x4B, 0x66, 0x84, + 0x35, 0xEB, 0x10, 0xD9, 0x9D, 0x65, 0x50, 0xBD, 0x5D, 0xBB, 0x81, 0x01, + 0xF0, 0xB4, 0xA4, 0x02, 0x54, 0x55, 0x64, 0xDD, 0x32, 0x06, 0x42, 0xF5, + 0x58, 0xBD, 0x1A, 0x8D, 0xFF, 0xB5, 0x6A, 0x80, 0x43, 0x20, 0x26, 0xFA, + 0x7C, 0x5A, 0xD6, 0x2C, 0x1E, 0x08, 0x92, 0x45, 0xB5, 0x5A, 0x58, 0xAF, + 0xE9, 0xEF, 0x4D, 0x0B, 0xEF, 0x2D, 0xB6, 0x84, 0xA2, 0x99, 0xAA, 0x4E, + 0x91, 0x10, 0x71, 0xCD, 0x72, 0x18, 0xE9, 0x27, 0x1F, 0x0E, 0x87, 0xC3, + 0xA4, 0x9D, 0xA7, 0xB9, 0xFF, 0x7A, 0xDD, 0xE2, 0x22, 0xAE, 0xDC, 0xE2, + 0xB8, 0x89, 0xF6, 0x2A, 0x92, 0x1C, 0x8A, 0x2F, 0xD0, 0xCC, 0x3C, 0x82, + 0x48, 0xAA, 0x5D, 0xD9, 0x24, 0xA5, 0xF9, 0xE1, 0x36, 0x02, 0x12, 0x54, + 0xD0, 0x53, 0x34, 0x56, 0x35, 0xE3, 0xF2, 0x5E, 0xA7, 0x9B, 0x39, 0xAF, + 0x1A, 0x21, 0x19, 0x5B, 0x60, 0x6E, 0xF1, 0x59, 0xD5, 0x0B, 0xD1, 0x14, + 0x87, 0x2D, 0xE2, 0xA1, 0x19, 0x16, 0x95, 0xC3, 0xCD, 0xAE, 0x0F, 0x3D, + 0xDB, 0x4F, 0xDE, 0x78, 0x59, 0xC3, 0x4E, 0xFD, 0x7F, 0x93, 0x48, 0xDE, + 0x5C, 0xD2, 0x36, 0xFD, 0xF6, 0xB3, 0xDB, 0x8C, 0xCD, 0x3F, 0xD6, 0x3E, + 0xF7, 0xA7, 0x12, 0x46, 0x81, 0x66, 0xD7, 0x4D, 0x7C, 0xF3, 0xA9, 0x79, + 0xA8, 0x6B, 0x18, 0xC7, 0xCD, 0x18, 0xDE, 0x84, 0x1B, 0x55, 0xCD, 0x39, + 0x97, 0x48, 0x94, 0x36, 0x12, 0x03, 0xC9, 0x1B, 0x84, 0x79, 0xC7, 0xFD, + 0x48, 0x6E, 0x1A, 0xBC, 0x41, 0x7F, 0x5F, 0x4C, 0x66, 0x42, 0x40, 0x33, + 0xA5, 0x2E, 0xFC, 0x4D, 0x4C, 0x97, 0x35, 0xA9, 0xDA, 0x34, 0x45, 0x57, + 0xA6, 0x9A, 0x26, 0x6D, 0xAF, 0x62, 0x44, 0xAA, 0x1D, 0xEA, 0xCB, 0x62, + 0x15, 0x40, 0xBA, 0x19, 0x55, 0x45, 0xC4, 0xBF, 0x98, 0x55, 0x87, 0xC0, + 0x88, 0x28, 0xA2, 0xC1, 0x17, 0x05, 0x01, 0x10, 0x81, 0x7D, 0x77, 0x11, + 0x63, 0x44, 0x26, 0xF4, 0x60, 0x54, 0x35, 0x8D, 0x81, 0x87, 0x18, 0x63, + 0x64, 0x8F, 0x3F, 0xC4, 0xCE, 0x7C, 0xE8, 0x57, 0xBC, 0xF5, 0x87, 0x88, + 0x88, 0x94, 0xB3, 0xB4, 0xCF, 0xDD, 0x31, 0xB1, 0x7D, 0x17, 0xEC, 0xB2, + 0xA4, 0xC0, 0x64, 0x06, 0x39, 0x4B, 0x8C, 0x61, 0x1A, 0xA2, 0x47, 0x75, + 0xC4, 0xC0, 0xAE, 0xFE, 0xB2, 0x12, 0x79, 0x88, 0x0E, 0x40, 0x60, 0xDA, + 0x8D, 0x31, 0x67, 0x0D, 0x4C, 0x80, 0x78, 0x5E, 0x72, 0x15, 0x5C, 0x00, + 0x9D, 0xFF, 0xBE, 0x8D, 0x81, 0xEA, 0x02, 0x34, 0x3A, 0xAA, 0x82, 0xBA, + 0x70, 0xA7, 0x95, 0x65, 0x79, 0x03, 0x1F, 0xCA, 0xC2, 0xB9, 0xE5, 0x7A, + 0xFD, 0xB9, 0x13, 0x4E, 0xF9, 0x5A, 0xD1, 0x12, 0x8A, 0x34, 0x43, 0x80, + 0x79, 0x95, 0x55, 0x8C, 0x09, 0x91, 0x60, 0x8C, 0x9C, 0xB3, 0x3C, 0xAD, + 0x62, 0x6A, 0x0A, 0x90, 0x45, 0x77, 0x03, 0xA7, 0xAC, 0x86, 0x48, 0x84, + 0x77, 0xBB, 0xE1, 0x30, 0x19, 0xBF, 0xC0, 0x79, 0x95, 0x94, 0x8B, 0xB2, + 0x7D, 0xC3, 0x12, 0x57, 0x74, 0x0F, 0xD5, 0x72, 0xDE, 0xCC, 0x42, 0x00, + 0xF7, 0xDC, 0x1B, 0x12, 0xE2, 0x14, 0x79, 0x8A, 0x7C, 0x5A, 0xD2, 0x69, + 0x4E, 0x39, 0xF0, 0xDD, 0x3E, 0x22, 0xF2, 0xA7, 0xE7, 0x45, 0xB5, 0x28, + 0x98, 0x37, 0x24, 0xFE, 0xDF, 0x7C, 0xEA, 0x9B, 0xE5, 0x1C, 0x2A, 0x06, + 0xFA, 0x27, 0x3F, 0xFF, 0x70, 0x9E, 0x97, 0xF3, 0x9C, 0x7E, 0xF9, 0x93, + 0x77, 0xEF, 0xEE, 0xF7, 0xF6, 0xFA, 0xB0, 0xA0, 0xFB, 0xAE, 0xF3, 0x43, + 0xB1, 0x9B, 0x6C, 0x6B, 0xB0, 0x0F, 0xA7, 0x6C, 0xD4, 0x03, 0x00, 0xAA, + 0xA2, 0x66, 0xB9, 0xC6, 0x92, 0x42, 0xAF, 0xD9, 0xA1, 0xB9, 0xB1, 0x66, + 0x65, 0xE6, 0x0D, 0xDB, 0x51, 0x45, 0x19, 0x09, 0xF8, 0x4A, 0x91, 0x31, + 0x33, 0x37, 0x92, 0x88, 0x83, 0xDB, 0xF8, 0xCD, 0x80, 0x72, 0xB7, 0x4F, + 0x1F, 0x62, 0x7A, 0x25, 0x9C, 0xD4, 0xA0, 0x46, 0x87, 0x69, 0x77, 0x78, + 0x7D, 0x35, 0x24, 0x0F, 0x44, 0x81, 0x62, 0xBF, 0x80, 0x4B, 0x93, 0xFA, + 0xC2, 0x9B, 0x0B, 0xD2, 0x2C, 0xB8, 0x37, 0x57, 0xD8, 0xC7, 0xCC, 0x4C, + 0x37, 0xB6, 0x8D, 0x7F, 0xDE, 0x83, 0x85, 0xA3, 0x98, 0x2F, 0xA9, 0xDB, + 0x92, 0xA5, 0x1D, 0x42, 0x06, 0x02, 0x00, 0xB5, 0x6D, 0xD8, 0x37, 0x58, + 0xD6, 0xD6, 0xF9, 0x3A, 0xEC, 0xCE, 0x55, 0x10, 0x04, 0x8F, 0xA7, 0xEB, + 0xE2, 0x8D, 0xAD, 0x93, 0xAA, 0x37, 0x22, 0xF6, 0x15, 0x9B, 0x83, 0xDB, + 0x7C, 0x44, 0xE4, 0x6F, 0x30, 0xB1, 0x87, 0xE3, 0xFA, 0xAC, 0x45, 0xDC, + 0x8B, 0x62, 0x60, 0x50, 0x14, 0xA0, 0x6B, 0xE1, 0x77, 0x83, 0x65, 0xB5, + 0x2F, 0x17, 0x73, 0x57, 0x6E, 0x3B, 0x28, 0x48, 0x65, 0xE0, 0xB1, 0x0A, + 0x66, 0x44, 0x9A, 0x05, 0x40, 0x20, 0x8B, 0x06, 0x30, 0x53, 0x04, 0xF2, + 0x10, 0x1C, 0x30, 0x53, 0x60, 0xC6, 0x18, 0x38, 0x30, 0x31, 0xA1, 0x99, + 0x8D, 0x31, 0x86, 0x40, 0x88, 0xE0, 0x6E, 0xA9, 0x7E, 0x7D, 0xDB, 0xC4, + 0x7A, 0x2C, 0xF3, 0x87, 0xC8, 0x10, 0x21, 0x25, 0x11, 0x91, 0x10, 0x78, + 0x18, 0x62, 0x95, 0xCC, 0x98, 0xB3, 0x4E, 0xE3, 0x30, 0xC4, 0xE8, 0x7E, + 0x5D, 0xD3, 0xC1, 0x00, 0x86, 0x21, 0xB6, 0x98, 0xEF, 0x2C, 0xA6, 0x49, + 0x53, 0x96, 0x25, 0xE5, 0xE7, 0xF3, 0x9A, 0xB2, 0x88, 0x1A, 0x21, 0x30, + 0xB3, 0xB3, 0x32, 0xD5, 0x00, 0x8A, 0x1B, 0x59, 0x51, 0x9D, 0xFE, 0xDB, + 0xBF, 0xFD, 0x5F, 0xCB, 0x9E, 0xB6, 0x95, 0xA9, 0x51, 0xB2, 0xFD, 0xAB, + 0x1B, 0x35, 0xBD, 0x82, 0xB1, 0xB2, 0x7F, 0xE8, 0xD1, 0x93, 0x57, 0xB2, + 0xC2, 0xB3, 0x08, 0xD6, 0xAC, 0xA5, 0x59, 0x85, 0x35, 0xCB, 0x65, 0xA5, + 0x25, 0x89, 0x19, 0xA8, 0xD9, 0x14, 0x79, 0x8A, 0x01, 0x0F, 0x08, 0x00, + 0x4B, 0x92, 0x4B, 0xCA, 0x97, 0x25, 0xFB, 0xFB, 0x4E, 0x0D, 0x3F, 0x62, + 0xE0, 0xF5, 0x53, 0x40, 0xF3, 0xC8, 0xA9, 0xCE, 0x82, 0x86, 0xEA, 0x7A, + 0x0F, 0xEE, 0xDB, 0x06, 0x64, 0xC6, 0xBB, 0x5D, 0x1C, 0x23, 0xCF, 0xAB, + 0x24, 0xF1, 0x9D, 0x42, 0xC4, 0x6B, 0x6A, 0x78, 0x53, 0xFB, 0xAB, 0x73, + 0xEF, 0xC8, 0x14, 0xC0, 0xF4, 0x30, 0x86, 0xAF, 0x1E, 0xA6, 0xFD, 0x34, + 0x7C, 0xF9, 0x6E, 0xFF, 0xF9, 0x09, 0x7E, 0xF2, 0xE1, 0xEE, 0xFD, 0xBB, + 0xC3, 0x6B, 0x43, 0xF8, 0x6A, 0xE9, 0xBA, 0x5F, 0x55, 0x04, 0x0C, 0x10, + 0x88, 0xCA, 0x21, 0x3F, 0x68, 0x0D, 0x26, 0x2D, 0xA3, 0x77, 0x52, 0xD6, + 0x6A, 0xCE, 0xD4, 0xA0, 0x39, 0x7F, 0xA1, 0x77, 0x60, 0xD5, 0x1F, 0x80, + 0xAA, 0xE6, 0xD2, 0x74, 0x15, 0xA8, 0xF6, 0x60, 0x73, 0x2D, 0x63, 0xD1, + 0xC3, 0xFC, 0x28, 0xD0, 0x44, 0x45, 0xA5, 0x04, 0x37, 0xF5, 0x0D, 0xDE, + 0x32, 0xBC, 0x23, 0x88, 0x6D, 0x46, 0x86, 0x75, 0x4F, 0xED, 0xDD, 0xD4, + 0x8A, 0xD1, 0x5F, 0x06, 0xD0, 0xF9, 0xA4, 0xAE, 0xB7, 0xEC, 0x56, 0xD2, + 0xB7, 0xC5, 0xEF, 0x7F, 0x00, 0xC7, 0x50, 0xF3, 0xF3, 0xC4, 0xE2, 0xF6, + 0xEE, 0x7D, 0x67, 0x55, 0x9D, 0xDD, 0xE2, 0x66, 0x91, 0xB7, 0xF8, 0x27, + 0xF4, 0x43, 0x5C, 0x33, 0x50, 0x53, 0x54, 0x28, 0x51, 0x41, 0xD0, 0xB8, + 0xB2, 0x2E, 0x66, 0x41, 0xB3, 0x7A, 0xE2, 0xA1, 0x66, 0x00, 0xE6, 0x5E, + 0x86, 0x12, 0xDC, 0x5F, 0x5E, 0xED, 0x24, 0xDF, 0x6B, 0x3A, 0xB9, 0xA2, + 0x10, 0x57, 0x0C, 0xA9, 0x84, 0xF5, 0xAB, 0xBB, 0x38, 0xAB, 0xDD, 0x91, + 0x55, 0x44, 0x2C, 0x89, 0x22, 0x52, 0x64, 0x66, 0x22, 0x35, 0x23, 0xD8, + 0x16, 0xBC, 0x07, 0x90, 0x9B, 0x96, 0x5D, 0x33, 0x41, 0x40, 0xBC, 0x05, + 0x38, 0x20, 0x26, 0x40, 0x83, 0x0C, 0x62, 0x4A, 0x48, 0x66, 0x96, 0x44, + 0xC1, 0x2C, 0xB4, 0x48, 0x47, 0x87, 0x64, 0x00, 0x33, 0xE3, 0x2A, 0x28, + 0x98, 0xC9, 0x97, 0x21, 0x20, 0x02, 0x93, 0x89, 0x20, 0x80, 0xB9, 0x75, + 0xD9, 0x62, 0x5E, 0xFA, 0x2D, 0xE9, 0x7F, 0x66, 0xE6, 0x18, 0xAD, 0x0F, + 0xC5, 0xF6, 0x1F, 0x3C, 0x0A, 0xCE, 0xCC, 0xCC, 0xC8, 0x0C, 0x44, 0x44, + 0xB2, 0x35, 0xA1, 0xA5, 0x22, 0x22, 0x96, 0xB2, 0x5C, 0xE6, 0xF5, 0xB2, + 0xE4, 0x65, 0xCD, 0xA7, 0x25, 0x03, 0x40, 0x64, 0x22, 0x35, 0x42, 0x90, + 0xEA, 0x2B, 0x32, 0x0F, 0x10, 0xB0, 0xED, 0xC0, 0x0F, 0xA1, 0x66, 0x4D, + 0xD5, 0x35, 0xAF, 0xC1, 0xE8, 0x60, 0x55, 0xC3, 0xEA, 0xA4, 0x1E, 0x54, + 0x0B, 0xE6, 0x6A, 0xF0, 0x58, 0xB5, 0x2E, 0xBA, 0x8E, 0xEF, 0xC7, 0x02, + 0x61, 0xA0, 0x06, 0x00, 0x46, 0xF5, 0xFC, 0xDF, 0xAC, 0x1C, 0x12, 0x11, + 0x41, 0x60, 0x8A, 0x4C, 0x77, 0xBB, 0x78, 0x9C, 0xE2, 0x7E, 0x8A, 0x2F, + 0x97, 0xF5, 0x34, 0x27, 0x40, 0xF8, 0x70, 0xB7, 0xBB, 0xDB, 0x0D, 0x4F, + 0xE7, 0xC5, 0xD4, 0x3E, 0xBD, 0x2C, 0xCF, 0xE7, 0x35, 0x89, 0x25, 0xD1, + 0xE6, 0x48, 0x70, 0xC0, 0x69, 0x34, 0x07, 0xD7, 0xFD, 0x56, 0xB6, 0xA9, + 0x52, 0x71, 0x23, 0x2B, 0x60, 0x84, 0x94, 0xF5, 0x87, 0xB4, 0x42, 0xC9, + 0x13, 0x81, 0x1F, 0x4E, 0xEB, 0xB8, 0x12, 0x00, 0xDE, 0xEF, 0xE2, 0x92, + 0xD5, 0x63, 0x6B, 0x6F, 0xB6, 0xE6, 0xAA, 0xE5, 0x8E, 0x50, 0x9A, 0x6E, + 0x5E, 0x98, 0x81, 0xF0, 0xA7, 0xEF, 0xF7, 0x3F, 0xFB, 0xF2, 0x6E, 0x1A, + 0x63, 0x4A, 0xF9, 0xB0, 0x1B, 0xF6, 0xFB, 0xB1, 0xB9, 0x3C, 0x6E, 0x9E, + 0xC6, 0xB7, 0x5A, 0xFC, 0xEE, 0xEE, 0xB6, 0x57, 0x50, 0x40, 0x55, 0x50, + 0xF3, 0x98, 0x37, 0x28, 0xF4, 0xDA, 0xA2, 0x49, 0x4B, 0xE4, 0x64, 0xD3, + 0x37, 0xAB, 0xE3, 0x13, 0x81, 0x7C, 0xAE, 0x58, 0x02, 0x2C, 0x70, 0xCB, + 0x14, 0x6B, 0x5C, 0xAA, 0x66, 0x28, 0x9B, 0x57, 0xDE, 0xC7, 0x4D, 0x88, + 0x4C, 0x8C, 0x88, 0x21, 0x04, 0x00, 0x48, 0x29, 0xAB, 0x8A, 0xBB, 0x40, + 0x5E, 0xCB, 0xFF, 0xEB, 0x19, 0x58, 0xCF, 0xB7, 0x3D, 0x84, 0xB5, 0x85, + 0x2A, 0x3C, 0x56, 0x85, 0x8F, 0xE1, 0xDB, 0x7C, 0xDE, 0xF3, 0x9E, 0xCF, + 0xB1, 0xE7, 0xDB, 0x9B, 0x95, 0x07, 0x17, 0x4E, 0xE6, 0x27, 0xAD, 0xE5, + 0xE5, 0x66, 0xBE, 0xF4, 0x88, 0xD6, 0x0F, 0x6F, 0x73, 0x35, 0x21, 0xA2, + 0x01, 0x91, 0x99, 0x92, 0x82, 0x2A, 0x5C, 0xED, 0x29, 0x14, 0x51, 0x5D, + 0xA0, 0xAF, 0x92, 0x5C, 0x3D, 0xD9, 0x52, 0x1F, 0xF6, 0x1B, 0x84, 0x07, + 0x70, 0x8B, 0x62, 0xDD, 0x1C, 0xAB, 0x19, 0x07, 0xD8, 0xB2, 0x71, 0x40, + 0xD1, 0x1D, 0x9C, 0xDB, 0xEE, 0xA8, 0xF9, 0x18, 0x89, 0x91, 0x19, 0x5D, + 0xA7, 0xE9, 0x9B, 0xB5, 0x6A, 0x59, 0x77, 0x5A, 0xF3, 0xA6, 0xFA, 0x19, + 0x18, 0x21, 0x98, 0x16, 0x5B, 0xB4, 0xFB, 0x93, 0x01, 0x80, 0x65, 0x68, + 0x81, 0x06, 0x59, 0x35, 0x10, 0x12, 0xD5, 0x4C, 0xC3, 0x61, 0x88, 0xCE, + 0x55, 0x66, 0xEE, 0x92, 0xC0, 0x61, 0x08, 0x84, 0xC5, 0xCF, 0x22, 0x92, + 0x11, 0x91, 0xB0, 0x24, 0xD6, 0x4C, 0x53, 0x78, 0x1D, 0xB3, 0xF7, 0x7A, + 0xF2, 0xCD, 0x39, 0xD2, 0x8E, 0x99, 0x01, 0x00, 0x80, 0x55, 0xB5, 0x42, + 0x27, 0x70, 0x40, 0x33, 0x13, 0x31, 0x55, 0x53, 0xD5, 0x35, 0xCB, 0x65, + 0x4E, 0xF3, 0x2A, 0x29, 0x0B, 0x22, 0x70, 0xDD, 0xAF, 0x94, 0x35, 0x10, + 0xED, 0xC6, 0xC0, 0x88, 0xE7, 0x25, 0x99, 0x15, 0x3D, 0xA5, 0xF4, 0x0E, + 0x1E, 0xC7, 0xEF, 0x30, 0x67, 0x60, 0x25, 0xF0, 0x75, 0x5B, 0xB5, 0xBA, + 0x57, 0x4E, 0x85, 0x85, 0x44, 0x8B, 0x9A, 0x85, 0x84, 0x58, 0xB3, 0x3F, + 0x00, 0x00, 0x5A, 0xE4, 0xBD, 0x56, 0x9C, 0x02, 0x33, 0x31, 0x55, 0xB3, + 0xC3, 0x34, 0x0C, 0x01, 0x4F, 0x73, 0xAA, 0xFB, 0x08, 0xAA, 0xBA, 0x1F, + 0xC3, 0x61, 0x0C, 0x6B, 0x96, 0x31, 0xF2, 0xFD, 0x3E, 0x3E, 0x1C, 0xA6, + 0xBB, 0xC3, 0x38, 0x0E, 0x1C, 0x98, 0x08, 0xE1, 0x30, 0x45, 0xF7, 0x9D, + 0x3D, 0xDC, 0xED, 0xBE, 0x78, 0x77, 0xF8, 0xFD, 0x77, 0xCF, 0x4F, 0xE7, + 0xF5, 0xB4, 0x4A, 0xA5, 0xB4, 0x1A, 0xA5, 0xEA, 0xB4, 0xF1, 0x8A, 0x86, + 0x10, 0xAF, 0xA4, 0xE4, 0x6B, 0x3D, 0xA2, 0x89, 0x01, 0x03, 0x58, 0xB2, + 0x8A, 0x02, 0x11, 0x1C, 0xA7, 0x30, 0x04, 0xFA, 0x7C, 0x5E, 0x45, 0x00, + 0xDE, 0x42, 0xB1, 0x37, 0x7F, 0xA8, 0x5E, 0x67, 0x54, 0xB5, 0x77, 0x87, + 0xF8, 0xB3, 0x2F, 0xEF, 0xC6, 0xC1, 0x13, 0x24, 0xC3, 0x34, 0x21, 0x22, + 0xF5, 0x61, 0x01, 0x37, 0xCF, 0xC6, 0xF9, 0xF5, 0x5F, 0x67, 0x50, 0x57, + 0xB8, 0xB8, 0x7A, 0xAC, 0xA0, 0x7A, 0xD0, 0x5A, 0x7C, 0xA9, 0xB5, 0xD4, + 0x91, 0xEA, 0xAB, 0xED, 0x47, 0xB5, 0x31, 0xBF, 0x6A, 0xE7, 0xD2, 0xBC, + 0x52, 0x79, 0x9A, 0x2E, 0xC6, 0x44, 0xA5, 0x23, 0x02, 0x30, 0xCD, 0xB9, + 0x4B, 0x12, 0xF8, 0x91, 0x61, 0xBF, 0x5E, 0x99, 0x37, 0x19, 0xB8, 0x43, + 0x9F, 0xC2, 0xCC, 0x45, 0x1B, 0xDB, 0x30, 0x60, 0x3B, 0xE7, 0xBD, 0x06, + 0xBE, 0x2B, 0xD3, 0xAC, 0x6F, 0xB0, 0x3E, 0x7E, 0xB8, 0xE7, 0x86, 0x2A, + 0x60, 0xA7, 0xE2, 0xF5, 0x2C, 0x66, 0x1D, 0x46, 0xD4, 0xFE, 0xAA, 0x16, + 0xE2, 0xDD, 0x12, 0x10, 0xD0, 0x76, 0xF8, 0xEE, 0xE6, 0x3F, 0x36, 0x63, + 0xAD, 0x8D, 0xA8, 0x7C, 0xBF, 0x7E, 0x8E, 0xD8, 0xA2, 0xCC, 0x60, 0x8B, + 0x30, 0xEC, 0xE1, 0xE6, 0x66, 0xFC, 0x08, 0x25, 0x76, 0xCF, 0xE5, 0x4B, + 0x49, 0x06, 0x54, 0x75, 0x26, 0x6A, 0x7B, 0x11, 0x23, 0x11, 0x31, 0x02, + 0x84, 0x50, 0x12, 0x4C, 0x8B, 0x0C, 0xE8, 0x65, 0x71, 0x7D, 0x7F, 0x0B, + 0x06, 0x36, 0x43, 0x24, 0xC3, 0xE2, 0x70, 0x28, 0xC7, 0xCF, 0x95, 0x3F, + 0x0A, 0x05, 0x3A, 0x08, 0xAA, 0xA8, 0x7A, 0x80, 0x14, 0x06, 0x06, 0x20, + 0x46, 0x22, 0x0A, 0x4C, 0x43, 0xE4, 0xE8, 0x90, 0x59, 0x08, 0xD0, 0x7C, + 0x10, 0x66, 0x40, 0x88, 0x6A, 0xBA, 0x2C, 0xC9, 0xCC, 0x86, 0x18, 0x00, + 0x80, 0x70, 0x1D, 0xC6, 0xE1, 0x66, 0xA1, 0xFB, 0x9F, 0xFB, 0x2D, 0xEC, + 0x68, 0xAE, 0xFD, 0xB1, 0x1C, 0x29, 0x98, 0xD9, 0x9A, 0xA4, 0x44, 0xC1, + 0x22, 0x66, 0xD1, 0x2C, 0xB2, 0x26, 0x51, 0x35, 0x24, 0x1A, 0x62, 0x18, + 0x62, 0x08, 0xCC, 0x6B, 0xCA, 0x4B, 0x12, 0xE7, 0x58, 0x77, 0xE0, 0x9A, + 0x29, 0xF8, 0x1A, 0xE2, 0x96, 0x2F, 0xE6, 0x1E, 0x64, 0xF0, 0xC5, 0x6E, + 0xB1, 0x06, 0x9B, 0x02, 0xE7, 0x3F, 0xD6, 0xA4, 0xC1, 0xBA, 0x35, 0xAE, + 0x98, 0xC7, 0x40, 0x00, 0x10, 0x03, 0x99, 0xC1, 0x61, 0x8A, 0x6B, 0xD6, + 0xE7, 0xCB, 0x8A, 0x48, 0x1E, 0x76, 0xBC, 0x1F, 0xC3, 0xBB, 0xE3, 0x2E, + 0x65, 0xFD, 0xE9, 0x87, 0xC3, 0xFD, 0x61, 0xBC, 0x2C, 0xF9, 0xB2, 0xE6, + 0xBF, 0xFD, 0xC3, 0xE3, 0x9C, 0xC4, 0xD4, 0x3E, 0xDE, 0x8D, 0xBF, 0xF8, + 0xEA, 0xE1, 0x3C, 0xAF, 0x66, 0x96, 0x3C, 0x28, 0x3F, 0x06, 0xA6, 0xE4, + 0x41, 0x24, 0x00, 0xF0, 0xFE, 0x7E, 0xFF, 0x93, 0x2F, 0xEE, 0xFD, 0x58, + 0x6D, 0x3F, 0xC5, 0xDF, 0x7E, 0xF3, 0x74, 0xFA, 0xD3, 0x53, 0x4B, 0x07, + 0xAD, 0x8E, 0x36, 0x37, 0xB8, 0x8A, 0x22, 0xB2, 0x91, 0x69, 0x23, 0xA3, + 0xEA, 0x9A, 0x69, 0x9C, 0xD9, 0xAD, 0x79, 0xB5, 0xB6, 0x00, 0xB2, 0x18, + 0x88, 0x7D, 0xCA, 0x2B, 0x23, 0xE4, 0xAB, 0xA3, 0x36, 0x9F, 0x70, 0x61, + 0x81, 0x6B, 0x7D, 0xB4, 0xB1, 0x06, 0x20, 0x00, 0x33, 0x25, 0x93, 0x8F, + 0x0F, 0xBB, 0xFB, 0xBB, 0x9D, 0xA8, 0x79, 0xAA, 0x6F, 0xCE, 0x19, 0x51, + 0x1B, 0x18, 0xBD, 0x7E, 0x9A, 0x06, 0xD1, 0x3C, 0xE2, 0xAF, 0x11, 0xC1, + 0x2D, 0xC0, 0x16, 0x0C, 0x05, 0x15, 0xC8, 0x1A, 0x1D, 0xF7, 0xAA, 0x4A, + 0x8F, 0x62, 0xE0, 0x31, 0x28, 0xF5, 0x5B, 0x9D, 0xD5, 0x09, 0x58, 0x33, + 0x5A, 0x3C, 0x51, 0x86, 0x39, 0x00, 0x82, 0xE4, 0x9C, 0x52, 0x0D, 0xD3, + 0xB9, 0x1E, 0xE1, 0xAB, 0x81, 0xBF, 0x6D, 0xD9, 0xB7, 0xF1, 0x34, 0x04, + 0x69, 0x03, 0x83, 0xA2, 0xCD, 0x97, 0x0F, 0xAB, 0xB3, 0x1D, 0xB5, 0x7A, + 0xFF, 0x1A, 0x16, 0xF4, 0x3F, 0xF4, 0x0F, 0x55, 0x9B, 0x0C, 0xAA, 0xF0, + 0x70, 0x14, 0x6E, 0x46, 0x43, 0xEF, 0x8C, 0xEE, 0xB5, 0xB3, 0xD6, 0xBD, + 0x93, 0xB1, 0xB9, 0x30, 0xF7, 0x00, 0x8A, 0xF2, 0x59, 0xD3, 0xAF, 0x01, + 0x5E, 0xCD, 0xF7, 0x0A, 0x95, 0xCA, 0xC1, 0x3F, 0x3A, 0xBE, 0x28, 0x98, + 0xD6, 0x1E, 0x7A, 0x14, 0xDB, 0x16, 0x04, 0x50, 0x55, 0x91, 0x10, 0x80, + 0xAA, 0x66, 0x6D, 0xC5, 0xE9, 0x0D, 0xE6, 0xAA, 0x8F, 0xBF, 0xE9, 0x0B, + 0xC2, 0xC4, 0x21, 0xF0, 0x10, 0x03, 0x31, 0x22, 0x62, 0x55, 0xC7, 0xA0, + 0xF7, 0x75, 0x6C, 0x00, 0x62, 0x6D, 0x77, 0x3C, 0x3A, 0xD7, 0x88, 0xC8, + 0x8A, 0x8D, 0x58, 0xE5, 0x3D, 0xA0, 0xE7, 0xCB, 0xAB, 0x39, 0x96, 0xC1, + 0xBC, 0x26, 0x00, 0x20, 0xE6, 0xE0, 0xE9, 0x93, 0x81, 0x39, 0x78, 0xF6, + 0x80, 0x19, 0x11, 0xC5, 0x10, 0xD0, 0x03, 0x73, 0x91, 0xDC, 0xB3, 0x40, + 0x8C, 0x81, 0xD8, 0xCC, 0x2E, 0x97, 0x65, 0x59, 0x92, 0x0F, 0x83, 0x5F, + 0x85, 0xC5, 0xBE, 0x5E, 0xB5, 0x7E, 0xED, 0xAA, 0x23, 0xA3, 0x0C, 0xCB, + 0x6D, 0x10, 0x35, 0x10, 0x55, 0xDF, 0x87, 0x94, 0xF3, 0x92, 0x64, 0x1A, + 0xE2, 0x71, 0x3F, 0xAD, 0x29, 0x2F, 0xAB, 0xFB, 0x92, 0x32, 0x82, 0x85, + 0x40, 0x4B, 0xCA, 0x29, 0xE9, 0x65, 0xCD, 0x4E, 0x2A, 0x4C, 0x3E, 0x5A, + 0x8F, 0xFC, 0xAE, 0xEA, 0x71, 0x51, 0x92, 0x9C, 0xA0, 0xAE, 0xC4, 0x4B, + 0x33, 0xD1, 0xAA, 0x8D, 0xE2, 0xC6, 0x0E, 0x18, 0xD8, 0xFD, 0x7E, 0xF8, + 0xEA, 0xDD, 0xFE, 0xB8, 0x8B, 0xBB, 0x29, 0x46, 0xA6, 0x18, 0x3C, 0x69, + 0x01, 0x3E, 0x3D, 0x5E, 0x96, 0x35, 0x3D, 0x9E, 0x16, 0x66, 0xFE, 0xF2, + 0x61, 0xB7, 0x1B, 0xA3, 0x19, 0x88, 0xEA, 0x6E, 0x8A, 0x1F, 0xDF, 0x1D, + 0x54, 0xF5, 0xFD, 0xDD, 0x74, 0x9A, 0xF3, 0xB2, 0x26, 0x02, 0x98, 0xC6, + 0xF0, 0x70, 0x37, 0x95, 0xEC, 0x7D, 0x40, 0x24, 0x3A, 0xEE, 0xC7, 0x21, + 0x9E, 0xBF, 0x7D, 0x3C, 0xC7, 0x39, 0x3D, 0xDC, 0xED, 0x86, 0x18, 0x92, + 0x08, 0x00, 0xC4, 0xC8, 0xEE, 0xD9, 0xC8, 0x62, 0xD4, 0xD0, 0xB4, 0xB0, + 0x93, 0xEF, 0x56, 0xDD, 0xCD, 0x6B, 0xBE, 0x82, 0x62, 0x79, 0xBD, 0xED, + 0x6A, 0x81, 0x26, 0xA2, 0xAB, 0x64, 0xCD, 0xE5, 0x18, 0xDD, 0xDF, 0x04, + 0xA8, 0x86, 0x76, 0x51, 0xDF, 0x1C, 0x36, 0x37, 0xE9, 0x0E, 0x88, 0x30, + 0x04, 0xDA, 0x8F, 0x61, 0xCD, 0xCA, 0xC8, 0x53, 0x60, 0x44, 0x0C, 0xCC, + 0xBE, 0x57, 0xFF, 0x4D, 0xA5, 0xE6, 0x46, 0xFB, 0xF0, 0x2D, 0xB8, 0x21, + 0x8F, 0x26, 0x7E, 0x1B, 0x3D, 0xC0, 0x2B, 0xC0, 0xEA, 0xB1, 0xA0, 0x9D, + 0x78, 0xB6, 0xD7, 0x5C, 0x25, 0x64, 0x26, 0x62, 0x2A, 0x02, 0xAC, 0x70, + 0x4E, 0x70, 0xDD, 0xC6, 0xFD, 0x15, 0x39, 0x4B, 0x8D, 0x7D, 0xBD, 0xF2, + 0x81, 0xF4, 0xFF, 0xD6, 0x10, 0x87, 0xCD, 0x4B, 0x50, 0x36, 0x02, 0x3D, + 0x03, 0x08, 0xDA, 0xEA, 0xB4, 0x59, 0x34, 0x6C, 0xAA, 0xB1, 0xA2, 0x75, + 0x71, 0x1D, 0x7D, 0x6A, 0x00, 0xC4, 0xCD, 0xB7, 0x7A, 0x5C, 0xA6, 0xF2, + 0x54, 0xE3, 0x01, 0x4B, 0x8A, 0x4B, 0xF9, 0x9B, 0x03, 0x16, 0x80, 0xE7, + 0x33, 0xDC, 0x7C, 0xDD, 0x79, 0xBD, 0x39, 0x18, 0x9D, 0x7A, 0x7D, 0xF7, + 0xAE, 0x03, 0x2A, 0xAB, 0x38, 0xB7, 0x8D, 0xFB, 0x8A, 0xFA, 0x50, 0x57, + 0xEC, 0xCA, 0xD7, 0x68, 0x5E, 0x05, 0xA4, 0xF0, 0x48, 0x5B, 0xFF, 0xAB, + 0x89, 0xB4, 0xB3, 0x26, 0x05, 0xC3, 0x42, 0x0D, 0x66, 0xA8, 0x02, 0x66, + 0x9E, 0x10, 0x74, 0x05, 0x9A, 0x3E, 0x3C, 0x66, 0x42, 0x42, 0x66, 0xBE, + 0x3A, 0x67, 0x70, 0x9B, 0xCE, 0x0C, 0x3B, 0xF4, 0x70, 0x7E, 0xBD, 0xD6, + 0x86, 0x80, 0xB0, 0xC5, 0xEE, 0x15, 0xE2, 0xC1, 0x62, 0x2F, 0x22, 0x07, + 0x34, 0x00, 0x66, 0x51, 0x35, 0x30, 0x0B, 0xFE, 0x07, 0x55, 0x13, 0x34, + 0x52, 0x9C, 0x86, 0x48, 0xA5, 0xDA, 0x06, 0x06, 0xF0, 0xB2, 0x3C, 0x2D, + 0x07, 0x18, 0xA7, 0x71, 0xD8, 0x4D, 0xA3, 0x9F, 0x5D, 0xFA, 0x6B, 0x6F, + 0xA2, 0xD8, 0xCD, 0x7C, 0x6E, 0xA8, 0xDC, 0xAC, 0x54, 0x1D, 0x80, 0x72, + 0xFA, 0x00, 0x81, 0xD9, 0x41, 0x9A, 0x88, 0x76, 0xD3, 0x18, 0x43, 0x89, + 0x6C, 0xCE, 0x84, 0x43, 0xE4, 0xC0, 0xB4, 0xA4, 0x6C, 0x49, 0xC7, 0x18, + 0x34, 0xD8, 0x69, 0x4E, 0x52, 0x63, 0x0A, 0xAC, 0x1E, 0x5C, 0x7A, 0xDB, + 0xE8, 0x5B, 0xED, 0x90, 0xEF, 0x63, 0x2E, 0x06, 0x97, 0xD7, 0xED, 0xE9, + 0x85, 0xB3, 0xD5, 0x0C, 0x7B, 0x9B, 0x06, 0xFE, 0xE5, 0xD7, 0xF7, 0x3F, + 0xFF, 0xEA, 0x3E, 0x04, 0x16, 0x55, 0x33, 0x08, 0x81, 0x01, 0x2C, 0x25, + 0x19, 0x23, 0x01, 0x84, 0x9F, 0x8C, 0xF1, 0x87, 0xE7, 0x8B, 0xAA, 0x66, + 0xD1, 0xDD, 0x6E, 0xF0, 0x58, 0xF2, 0x65, 0x4D, 0xCC, 0xF4, 0xE1, 0x61, + 0xFF, 0xE5, 0x7B, 0x5C, 0x96, 0xFC, 0xBB, 0x6F, 0x3E, 0x7F, 0xFF, 0xF9, + 0xF4, 0xEE, 0xB8, 0x13, 0x53, 0x4F, 0x95, 0x67, 0x53, 0x55, 0xFD, 0xF2, + 0xDD, 0x01, 0x11, 0x3F, 0xBF, 0xCC, 0xE7, 0x79, 0x05, 0x30, 0x53, 0x7B, + 0x39, 0xCD, 0x44, 0xF4, 0xE1, 0x7E, 0x1F, 0x88, 0xBF, 0x7D, 0xBA, 0x9C, + 0x2E, 0xE9, 0x92, 0x04, 0x3B, 0xE3, 0x4F, 0x0D, 0x3C, 0x10, 0xDA, 0xB6, + 0x4C, 0xED, 0x37, 0x3C, 0x5C, 0xED, 0xF3, 0xC6, 0x5A, 0x95, 0xBD, 0xC0, + 0x75, 0x85, 0x2D, 0x25, 0x1A, 0xCA, 0x69, 0x9F, 0x13, 0x62, 0x07, 0x46, + 0xD6, 0x94, 0x76, 0x22, 0x04, 0x83, 0x69, 0xE0, 0x87, 0xFD, 0x30, 0x46, + 0xFE, 0xEE, 0xE9, 0x62, 0x08, 0x9F, 0x9E, 0xCE, 0x5F, 0x9E, 0x8F, 0xC7, + 0xC3, 0xCE, 0x8A, 0x5F, 0xEC, 0x47, 0x75, 0xB1, 0x1B, 0x89, 0x05, 0x84, + 0x08, 0xE4, 0xF4, 0x5A, 0xB8, 0xB4, 0xF6, 0xEB, 0x1E, 0x86, 0xDE, 0x3E, + 0xFD, 0x31, 0x67, 0x6B, 0x99, 0x54, 0xC7, 0x00, 0xED, 0xB5, 0xD2, 0x8F, + 0x47, 0xC0, 0x18, 0x00, 0x6A, 0xD5, 0x5F, 0xD5, 0xCB, 0x44, 0x49, 0xDE, + 0x4E, 0xFD, 0x7A, 0x34, 0xE9, 0xE1, 0xAC, 0xFF, 0xC1, 0xCC, 0x00, 0x89, + 0x8A, 0x3E, 0x55, 0x60, 0xA9, 0xC9, 0x96, 0x9B, 0x46, 0xDE, 0x52, 0x87, + 0xAD, 0xA8, 0xB2, 0x15, 0x26, 0xEC, 0xAD, 0x2D, 0x6B, 0x03, 0x70, 0x31, + 0x59, 0x31, 0x10, 0x91, 0x88, 0x89, 0x55, 0xB4, 0x5F, 0x96, 0x26, 0x86, + 0x6F, 0xF3, 0x22, 0xB0, 0xED, 0xB0, 0xE7, 0x33, 0x6C, 0x31, 0xE1, 0x1D, + 0xAF, 0xB5, 0xA1, 0x37, 0x1F, 0x0A, 0x78, 0x14, 0x5E, 0x61, 0x13, 0xAA, + 0xF9, 0x06, 0xB5, 0x97, 0x42, 0x2B, 0x1E, 0xAA, 0xDD, 0x68, 0xA9, 0x39, + 0x2C, 0xAE, 0x14, 0x14, 0x03, 0x03, 0xDD, 0xFA, 0xDA, 0xA6, 0x59, 0xD3, + 0xA0, 0x5D, 0x4F, 0x06, 0x51, 0x15, 0x11, 0x3F, 0x2A, 0x84, 0x0D, 0x88, + 0xA1, 0x69, 0x13, 0x45, 0x9F, 0x80, 0xEB, 0x5E, 0x10, 0xDC, 0x67, 0xE4, + 0xE7, 0x16, 0x08, 0xD8, 0x8A, 0x41, 0xF4, 0x1B, 0x2A, 0xA6, 0x88, 0x10, + 0x98, 0x56, 0x55, 0x11, 0x0D, 0x0D, 0xE4, 0x54, 0xCD, 0x2B, 0x40, 0x4D, + 0xE3, 0xB0, 0xDB, 0x0D, 0x88, 0x14, 0xDD, 0xC1, 0x53, 0xF7, 0xA7, 0x84, + 0xE4, 0x94, 0xA5, 0x2C, 0x8B, 0xF6, 0x0F, 0xAB, 0x60, 0xAF, 0x7E, 0x28, + 0x78, 0x9F, 0x55, 0xD7, 0x35, 0x01, 0xA0, 0xAA, 0x02, 0x82, 0xAA, 0xAD, + 0x49, 0xCA, 0xF6, 0x54, 0x5C, 0x57, 0xB5, 0xCB, 0x9A, 0x53, 0x2E, 0xF1, + 0x24, 0x5A, 0x77, 0x64, 0x1C, 0x82, 0x2E, 0x39, 0x89, 0x33, 0x7F, 0x23, + 0xAF, 0x32, 0xD3, 0xB6, 0xD4, 0x8D, 0x57, 0xCB, 0x90, 0x0D, 0x44, 0x9B, + 0xD8, 0x05, 0x46, 0x54, 0x83, 0x21, 0x10, 0x21, 0xFC, 0xE4, 0xC3, 0xF1, + 0xE7, 0x5F, 0xDF, 0x87, 0x10, 0xCA, 0x01, 0x04, 0x33, 0x00, 0x88, 0x68, + 0xCE, 0xC2, 0x4C, 0x77, 0x43, 0x1C, 0x22, 0x1F, 0xF6, 0xC3, 0x9A, 0x64, + 0xF4, 0xCC, 0x2C, 0xDA, 0xA8, 0x79, 0x5E, 0xD2, 0xBA, 0x66, 0x00, 0xFC, + 0xE2, 0xE1, 0xB8, 0xA6, 0xE4, 0x11, 0x4C, 0xDF, 0x3E, 0x3E, 0xEF, 0xA7, + 0xE1, 0xC3, 0xFD, 0x3E, 0x25, 0xC9, 0xA2, 0x5F, 0xBD, 0x3B, 0xFC, 0xF4, + 0xE3, 0x5D, 0x8C, 0x94, 0xB2, 0xCC, 0x4B, 0x1A, 0x86, 0x10, 0x43, 0x38, + 0x32, 0xBD, 0xBB, 0xDB, 0xDD, 0xED, 0x87, 0xE7, 0xF3, 0xF2, 0x78, 0x5A, + 0x5F, 0xE6, 0xF4, 0x32, 0x27, 0x57, 0x0D, 0xDC, 0x51, 0x99, 0xB5, 0x2E, + 0xD7, 0x2B, 0x03, 0x10, 0x7B, 0xD5, 0xBC, 0x6C, 0xB0, 0x2F, 0xDE, 0xC6, + 0x57, 0x95, 0x04, 0x4B, 0xCC, 0x2D, 0x56, 0x24, 0x81, 0xE2, 0x82, 0xE9, + 0xB4, 0x0F, 0x40, 0x26, 0x0C, 0x8C, 0x29, 0xEB, 0xC0, 0x24, 0x6A, 0x4F, + 0xA7, 0xC5, 0xD4, 0x54, 0x74, 0x49, 0xFA, 0xF4, 0x72, 0x19, 0x86, 0x10, + 0x98, 0x1B, 0xF7, 0xC2, 0x8F, 0x3C, 0xAF, 0xD4, 0x10, 0xAB, 0x3C, 0xE3, + 0xC8, 0xDF, 0x81, 0xB2, 0x6E, 0x0B, 0x08, 0x1D, 0x7B, 0xE3, 0xB5, 0x0A, + 0x80, 0x55, 0x03, 0xED, 0xC9, 0xD7, 0x7F, 0xF1, 0x9D, 0x52, 0xB5, 0x66, + 0x6A, 0x03, 0x02, 0x80, 0x80, 0x81, 0xEA, 0x56, 0x84, 0x0B, 0xAE, 0x2C, + 0x50, 0xEC, 0x53, 0xB2, 0x6B, 0xE3, 0x9B, 0x00, 0x41, 0x40, 0xDB, 0x0C, + 0xBB, 0xEA, 0xDC, 0xAB, 0x86, 0xB9, 0xEB, 0x6E, 0x1E, 0x4B, 0xD1, 0x1D, + 0xDC, 0x6F, 0x14, 0xDE, 0x8D, 0x0E, 0xD5, 0xAB, 0xA8, 0x5C, 0xC9, 0x0C, + 0x68, 0xDD, 0x61, 0x2D, 0xDF, 0xD5, 0x00, 0xD3, 0x97, 0x86, 0x98, 0x54, + 0x44, 0x45, 0x0A, 0x1B, 0x20, 0x32, 0xF1, 0xDB, 0x47, 0xA2, 0x6F, 0x6D, + 0xC2, 0x15, 0xA3, 0x35, 0x89, 0x62, 0x1E, 0x32, 0x52, 0x16, 0xA9, 0xAD, + 0xED, 0xAB, 0x8C, 0x02, 0x57, 0xE3, 0xEA, 0x59, 0x0A, 0x54, 0xDA, 0xC1, + 0xCA, 0xE4, 0x58, 0x8A, 0x74, 0x5D, 0x49, 0xDC, 0xCE, 0xF9, 0xB8, 0xB1, + 0x37, 0x00, 0x20, 0x66, 0x11, 0xFF, 0x1E, 0x0B, 0x79, 0x34, 0x46, 0x49, + 0xFF, 0x68, 0x06, 0x82, 0xA7, 0x94, 0x99, 0x82, 0x12, 0x52, 0xB3, 0xA7, + 0xAA, 0x55, 0x5C, 0xC6, 0x09, 0x00, 0x48, 0x66, 0x80, 0xAD, 0x1A, 0x00, + 0xFA, 0x01, 0x82, 0x6F, 0xB1, 0x88, 0x65, 0xB1, 0x9C, 0x55, 0xD4, 0x3C, + 0xD7, 0x12, 0x87, 0x48, 0xC7, 0xFD, 0x18, 0x42, 0xB1, 0x69, 0x63, 0x0C, + 0x8D, 0xCA, 0xB7, 0xD5, 0x2B, 0x5A, 0x6D, 0x1F, 0xF1, 0xFE, 0x86, 0xC2, + 0xD5, 0x7E, 0xBD, 0xF9, 0xD9, 0x29, 0xCF, 0x01, 0x42, 0xB4, 0x14, 0x4A, + 0x34, 0x05, 0x35, 0x4B, 0x59, 0xD6, 0xEC, 0x85, 0x11, 0xCD, 0x00, 0x54, + 0x41, 0xFC, 0x30, 0x4B, 0x2C, 0x5D, 0xC7, 0x73, 0x12, 0xFA, 0x59, 0xA2, + 0x11, 0x22, 0xF5, 0x27, 0x79, 0x3D, 0x23, 0xB5, 0x9D, 0x28, 0x27, 0x3B, + 0x2E, 0x76, 0x6C, 0x8A, 0x1C, 0x03, 0x65, 0xD1, 0x35, 0x6B, 0x16, 0x65, + 0xA2, 0x87, 0xFD, 0x70, 0xB7, 0x1B, 0xBE, 0xFC, 0x70, 0x0C, 0x21, 0xF8, + 0x6E, 0x90, 0x4B, 0x65, 0x00, 0x55, 0x9B, 0x97, 0x84, 0x88, 0xD3, 0xC8, + 0x44, 0xB8, 0xDF, 0x0D, 0x43, 0xD4, 0xD3, 0x79, 0x21, 0x26, 0x0F, 0x99, + 0x89, 0x81, 0x9F, 0x4F, 0xF3, 0xA7, 0xC7, 0x33, 0x13, 0x85, 0x40, 0xBB, + 0xB1, 0x84, 0x8F, 0x4C, 0x03, 0x7F, 0xF9, 0xEE, 0xE0, 0xC5, 0x73, 0xA6, + 0x31, 0xBA, 0xFB, 0xDA, 0x2B, 0xC9, 0x9D, 0xCE, 0x6B, 0xCA, 0xC2, 0xE4, + 0x0E, 0x69, 0x00, 0xC0, 0x87, 0xE3, 0x44, 0x84, 0x31, 0xD0, 0xFB, 0xBB, + 0xF1, 0xB7, 0xDF, 0x3E, 0x9F, 0x57, 0x19, 0x03, 0xDF, 0xEF, 0x82, 0x01, + 0xCC, 0x49, 0x0A, 0x55, 0x11, 0x3E, 0x9D, 0x1D, 0xCF, 0xCB, 0x2E, 0x94, + 0x4D, 0x2E, 0x92, 0xCD, 0xFA, 0x7D, 0xEA, 0x01, 0xA2, 0xBD, 0xDC, 0x73, + 0x82, 0x57, 0x2A, 0xA1, 0x42, 0xDB, 0x4D, 0xFD, 0xD0, 0x9C, 0x11, 0x11, + 0x56, 0x91, 0x35, 0xCB, 0x9A, 0x65, 0xA8, 0xA7, 0x4B, 0xA7, 0xCB, 0x1A, + 0x1F, 0xCF, 0xEF, 0x1F, 0xF6, 0x56, 0xA3, 0xC0, 0x6E, 0x4E, 0x78, 0xFA, + 0x95, 0xEF, 0xFB, 0xD2, 0x8E, 0x93, 0x1D, 0x40, 0x37, 0x22, 0xAE, 0x6F, + 0x62, 0x3D, 0xA8, 0xDA, 0x5E, 0xEB, 0x6D, 0xB7, 0x32, 0xDC, 0x6A, 0xC1, + 0x75, 0x9F, 0xD2, 0x46, 0x5D, 0xD5, 0x12, 0xF2, 0xF9, 0xA8, 0xDD, 0xB4, + 0xDF, 0xAB, 0x7B, 0xB7, 0xB0, 0xD2, 0xB5, 0xD9, 0xAD, 0xDB, 0x46, 0xE3, + 0x56, 0x93, 0xBD, 0x2B, 0xF5, 0x2A, 0x21, 0x79, 0xFA, 0xFA, 0x8D, 0xFC, + 0xBE, 0x99, 0x3B, 0x00, 0x9A, 0xA1, 0x9F, 0x4B, 0x50, 0xD5, 0x15, 0x9D, + 0xD1, 0x9C, 0x2E, 0x25, 0x8B, 0x31, 0x11, 0x33, 0x02, 0x98, 0xA7, 0x08, + 0x95, 0xC1, 0x21, 0x78, 0xC1, 0x85, 0x7A, 0x30, 0xCA, 0x14, 0x4C, 0x3D, + 0xE7, 0xA9, 0xBA, 0xBD, 0xA0, 0xEA, 0x6B, 0x7A, 0xA5, 0x25, 0xF4, 0x0C, + 0x78, 0xAB, 0x20, 0x17, 0x0C, 0x2D, 0x01, 0x0D, 0x2D, 0x90, 0x00, 0xAB, + 0x73, 0xD9, 0x17, 0xD2, 0xE3, 0x27, 0xFC, 0xFC, 0xA2, 0xAE, 0x24, 0x56, + 0x5D, 0xB3, 0x90, 0xCA, 0x9B, 0x5B, 0xAF, 0x25, 0x11, 0x15, 0xDA, 0xF6, + 0x61, 0x55, 0x24, 0x55, 0x55, 0xA4, 0x94, 0xCF, 0x9B, 0xE7, 0x15, 0x11, + 0xA7, 0x69, 0x60, 0xCF, 0xEA, 0xF1, 0xD4, 0xA2, 0xC0, 0x60, 0x5C, 0xD1, + 0xDF, 0x33, 0xBE, 0x4B, 0xDB, 0xE5, 0x7F, 0xBE, 0x70, 0x35, 0xD0, 0x01, + 0xA0, 0x55, 0xF1, 0xB3, 0xEC, 0xE9, 0xFC, 0xA6, 0x06, 0x18, 0x00, 0x20, + 0x30, 0x7E, 0x78, 0x38, 0xDC, 0xDD, 0xED, 0xA9, 0x09, 0xEB, 0xBA, 0x1F, + 0xAF, 0x07, 0xFD, 0xFA, 0x93, 0x1F, 0x5B, 0xBB, 0x1B, 0xAD, 0xCD, 0x0C, + 0x72, 0x96, 0x94, 0x24, 0x65, 0x71, 0x77, 0xFE, 0x65, 0x4E, 0x59, 0x34, + 0x65, 0x75, 0x8D, 0xD4, 0x37, 0xCC, 0x0C, 0x44, 0x5D, 0x14, 0xA2, 0xAF, + 0x7D, 0x51, 0xF2, 0xCD, 0x00, 0x20, 0x9B, 0x7A, 0xF8, 0x03, 0xBB, 0x7B, + 0x6B, 0xE3, 0xE2, 0x9B, 0x03, 0x23, 0x84, 0x7A, 0xA2, 0x04, 0x60, 0x4C, + 0xC8, 0xC4, 0x3F, 0xFB, 0x78, 0xDC, 0x8D, 0xF1, 0xBB, 0xC7, 0xF3, 0x77, + 0x8F, 0x97, 0xC0, 0xF4, 0xB0, 0x1F, 0x0E, 0x53, 0x7C, 0xB8, 0x9B, 0xEE, + 0x0E, 0x63, 0x1B, 0x73, 0xCE, 0xE2, 0xC0, 0x37, 0xCF, 0x89, 0x99, 0x77, + 0xD3, 0x90, 0xB3, 0x40, 0x39, 0x11, 0x85, 0x21, 0x06, 0xA7, 0x74, 0x46, + 0x78, 0x7C, 0xB9, 0x7C, 0xF3, 0xFD, 0xB3, 0x2A, 0x0C, 0x91, 0x43, 0xA0, + 0x94, 0xC5, 0xD7, 0x6B, 0x45, 0xBC, 0x3B, 0x4C, 0x97, 0x79, 0x4D, 0x39, + 0x0F, 0x31, 0x4C, 0x31, 0xAC, 0x59, 0xD4, 0xCC, 0xE3, 0x9B, 0x99, 0x30, + 0x8B, 0x9E, 0xE7, 0xF5, 0x80, 0x23, 0x80, 0x89, 0xEA, 0x10, 0x79, 0x4D, + 0x34, 0x46, 0xFA, 0xC5, 0x17, 0x77, 0xDF, 0x3D, 0x5D, 0xC6, 0xC8, 0xD3, + 0x10, 0x00, 0xE0, 0x3D, 0xE1, 0x65, 0x4D, 0x81, 0x38, 0x06, 0x5A, 0xD3, + 0xF3, 0x49, 0xE5, 0x5A, 0xA8, 0x14, 0x31, 0x8A, 0x00, 0xA5, 0xAE, 0x8D, + 0x4B, 0x4D, 0xB8, 0x75, 0xA2, 0x95, 0x18, 0x06, 0xB3, 0xE6, 0x3B, 0x39, + 0x4C, 0x21, 0x8B, 0xAE, 0x09, 0xAA, 0x1D, 0x0A, 0x8D, 0xC1, 0x72, 0x76, + 0x87, 0x43, 0xA1, 0xA3, 0xAC, 0x6A, 0x66, 0x43, 0x0C, 0x39, 0x0B, 0x20, + 0x30, 0xB3, 0x67, 0x9B, 0x79, 0x58, 0x43, 0x37, 0x98, 0x2B, 0xF4, 0xB4, + 0x2A, 0x5D, 0xFB, 0x61, 0x74, 0x56, 0x43, 0x51, 0x8E, 0xB6, 0x98, 0xAF, + 0x0E, 0x62, 0xAE, 0x30, 0xA2, 0xB2, 0x3E, 0xBA, 0x2F, 0xB3, 0xCD, 0x88, + 0xF0, 0x3A, 0x98, 0xD1, 0x55, 0x81, 0x62, 0x31, 0x55, 0xFD, 0xA8, 0x6A, + 0x3F, 0xD4, 0xAC, 0xA8, 0x0D, 0xDC, 0x1D, 0x11, 0x8C, 0xB6, 0x0F, 0x01, + 0x6A, 0xAC, 0x8D, 0xD5, 0x3F, 0xBB, 0x9B, 0x09, 0x15, 0xB4, 0xF5, 0x4B, + 0x86, 0xCD, 0x4D, 0x53, 0x7A, 0xBC, 0x26, 0xF8, 0x32, 0x7D, 0xB7, 0xD3, + 0xA9, 0x1C, 0xA7, 0x58, 0x67, 0x1C, 0x82, 0xA7, 0xD6, 0x95, 0xC8, 0xEA, + 0xAE, 0x2C, 0x5A, 0x29, 0x0B, 0x65, 0xDA, 0xF4, 0x22, 0xD7, 0xAC, 0x40, + 0xCD, 0xC8, 0x4A, 0x7A, 0x5A, 0x57, 0xEC, 0xA4, 0x47, 0xAE, 0xD7, 0x70, + 0x56, 0x46, 0x02, 0x1B, 0x63, 0x76, 0x2B, 0xBA, 0x2D, 0xF2, 0xD6, 0x91, + 0x99, 0x9A, 0xB9, 0x1A, 0x55, 0x42, 0x15, 0x09, 0xA1, 0x46, 0x08, 0x6F, + 0xDB, 0x57, 0x5A, 0xC3, 0xAA, 0xEE, 0x17, 0x14, 0xB3, 0x72, 0x34, 0xE8, + 0x28, 0xB3, 0x95, 0x09, 0x40, 0x64, 0xAC, 0x55, 0x1E, 0x53, 0x92, 0x9C, + 0x44, 0xEB, 0xF9, 0xB5, 0x7B, 0x5D, 0x89, 0x48, 0xD5, 0x10, 0xC5, 0xBD, + 0xF3, 0x88, 0x68, 0xA8, 0x4D, 0xFE, 0x99, 0x3B, 0x09, 0xAB, 0xC6, 0x58, + 0xA7, 0x00, 0x00, 0xA0, 0x0A, 0x2A, 0x25, 0x3F, 0x29, 0x06, 0x52, 0x83, + 0x30, 0xC4, 0xF0, 0xD5, 0xC7, 0xFB, 0x62, 0xC8, 0x49, 0xF9, 0x00, 0x00, + 0x20, 0x00, 0x49, 0x44, 0x41, 0x54, 0xFD, 0x7E, 0x44, 0xBC, 0xF2, 0x6E, + 0xF6, 0x44, 0x89, 0xAF, 0xA1, 0xF8, 0xD5, 0xD3, 0x90, 0xBE, 0x2D, 0xE8, + 0xCD, 0xB7, 0x10, 0x01, 0x91, 0x0C, 0xF2, 0x9A, 0x73, 0x4A, 0x92, 0xB3, + 0xA6, 0xAC, 0x73, 0x4A, 0xAA, 0x66, 0xEE, 0xDE, 0x6E, 0xCE, 0xCD, 0xC2, + 0x75, 0xE5, 0x7F, 0xD8, 0x31, 0x70, 0x83, 0xDA, 0xBA, 0x9D, 0x8A, 0x35, + 0xCB, 0xC7, 0x6A, 0x64, 0xAB, 0x1F, 0xE5, 0x50, 0xD1, 0x52, 0x01, 0x10, + 0x0E, 0x53, 0xFC, 0x70, 0xB7, 0x7B, 0x7F, 0xBF, 0x9B, 0xD7, 0x3C, 0x0D, + 0xFC, 0xD3, 0x0F, 0x07, 0x33, 0xBB, 0xDB, 0x8F, 0xEF, 0xEE, 0xF7, 0x43, + 0x64, 0x04, 0x70, 0xAF, 0x70, 0x4A, 0x92, 0x72, 0x39, 0x8E, 0x00, 0xF0, + 0x55, 0xD6, 0x2C, 0x72, 0x59, 0x64, 0x88, 0xBC, 0xDF, 0x8D, 0xE0, 0x09, + 0x55, 0x09, 0x5E, 0xCE, 0xCB, 0x9F, 0x3E, 0xBD, 0x98, 0xC1, 0x71, 0x37, + 0xDC, 0x1D, 0x46, 0x04, 0x78, 0x3E, 0x2F, 0x43, 0x0C, 0x44, 0x88, 0x24, + 0xB8, 0x66, 0x27, 0x38, 0x51, 0x13, 0xD1, 0x94, 0x4A, 0x28, 0x97, 0xA7, + 0x8B, 0x7A, 0x45, 0x18, 0x00, 0x18, 0x63, 0x58, 0xD6, 0x3C, 0xAF, 0x19, + 0x00, 0x54, 0x2D, 0x46, 0xFA, 0xFA, 0xDD, 0x5E, 0xCC, 0xEE, 0x76, 0xE3, + 0x38, 0x04, 0x35, 0xFB, 0xF6, 0x87, 0x97, 0x18, 0x78, 0xCD, 0x3A, 0x27, + 0xA9, 0xE7, 0x62, 0x55, 0x4E, 0x42, 0x71, 0x3B, 0x05, 0x42, 0x83, 0x32, + 0x79, 0xC4, 0x92, 0x2E, 0xEB, 0xB2, 0xDD, 0x4A, 0x2A, 0x78, 0x01, 0x04, + 0x55, 0x33, 0xB0, 0x31, 0xD0, 0x87, 0xE3, 0xF4, 0xE9, 0x79, 0x36, 0x16, + 0x0F, 0xF0, 0x2A, 0x47, 0xE7, 0x1E, 0x6F, 0x44, 0xF0, 0x7E, 0x37, 0x00, + 0xD8, 0xD3, 0x79, 0xCD, 0x6A, 0x94, 0xF5, 0xB2, 0xE4, 0x18, 0x39, 0xE5, + 0x12, 0xEC, 0xE3, 0x16, 0x56, 0xCE, 0xF9, 0xCD, 0xB3, 0xCB, 0x1E, 0xCB, + 0xD0, 0xC3, 0x5C, 0x41, 0x99, 0x59, 0xB7, 0xE4, 0x84, 0x1A, 0x81, 0x85, + 0xC5, 0x58, 0xBB, 0x89, 0x8D, 0xDA, 0x78, 0x12, 0x00, 0x4D, 0x19, 0xA8, + 0xB8, 0xF7, 0xA0, 0x80, 0x5A, 0xC3, 0xC7, 0x46, 0x99, 0x3D, 0x6B, 0x01, + 0x01, 0xE8, 0xAD, 0x33, 0xE5, 0x8D, 0x87, 0x8A, 0xEB, 0xBA, 0xBD, 0x63, + 0xCD, 0xD2, 0x2E, 0xC4, 0x54, 0x49, 0xDA, 0x00, 0xC9, 0x4D, 0x05, 0xCF, + 0x7F, 0x52, 0x44, 0xFE, 0x31, 0xEC, 0xB8, 0x42, 0xB4, 0x2B, 0xF7, 0x66, + 0x87, 0x98, 0x45, 0xBF, 0x44, 0x0F, 0x7C, 0xC5, 0x66, 0xDC, 0xA1, 0x96, + 0x9A, 0x39, 0x45, 0xD1, 0xF6, 0x8C, 0x45, 0x77, 0x24, 0x29, 0x02, 0x75, + 0x3E, 0xA9, 0x37, 0x7A, 0x2F, 0x60, 0xF4, 0x2A, 0xB3, 0x18, 0x0A, 0x1E, + 0x17, 0xCE, 0xEE, 0xDF, 0xF7, 0xBF, 0x79, 0x39, 0xD7, 0x3E, 0x2B, 0xC0, + 0xCC, 0xC8, 0x8F, 0x3A, 0xB0, 0xD2, 0x9A, 0x6D, 0x23, 0x6D, 0x13, 0xAD, + 0xE0, 0xB5, 0x1D, 0x32, 0xB4, 0xC6, 0x3D, 0xB6, 0xC6, 0x6D, 0xC9, 0x05, + 0x40, 0xA1, 0xD4, 0x34, 0xF1, 0x1C, 0x34, 0x55, 0x25, 0xCA, 0xE3, 0x34, + 0xC4, 0x18, 0xBC, 0x3C, 0x92, 0x87, 0x98, 0xA9, 0x42, 0x8C, 0x2C, 0x22, + 0x49, 0xB4, 0x78, 0x70, 0x00, 0x8A, 0xA7, 0xB0, 0x13, 0x6D, 0x5E, 0x71, + 0x15, 0x6B, 0x59, 0x9A, 0x21, 0xB0, 0x99, 0x65, 0xB5, 0x70, 0x7F, 0xB7, + 0x3B, 0x1E, 0xA6, 0x37, 0x14, 0xE5, 0x8E, 0x62, 0x7A, 0x38, 0xBB, 0x91, + 0x3F, 0xAF, 0x5E, 0x06, 0x4F, 0xAF, 0xF3, 0x6C, 0x87, 0xCD, 0xC9, 0xE7, + 0xF4, 0x43, 0xE8, 0x05, 0xF8, 0xD7, 0x24, 0x88, 0xB8, 0x1B, 0x23, 0x13, + 0x5E, 0x52, 0x16, 0x31, 0x3F, 0x43, 0x04, 0x44, 0xF3, 0x83, 0xB6, 0xEA, + 0xAE, 0x86, 0x52, 0xA3, 0xE2, 0x4A, 0x56, 0x6F, 0xD2, 0xB5, 0xD1, 0x8B, + 0x47, 0x8D, 0x15, 0xF5, 0xBB, 0x73, 0x7F, 0x82, 0x21, 0xE0, 0x79, 0x49, + 0x63, 0xE4, 0xFD, 0x14, 0x10, 0x60, 0x3F, 0xC6, 0x35, 0x49, 0x56, 0x4B, + 0x59, 0x11, 0x20, 0x04, 0x5E, 0x96, 0xE4, 0xC7, 0x17, 0x6B, 0xCA, 0x6B, + 0x12, 0x66, 0x02, 0x33, 0x51, 0x63, 0x00, 0x33, 0x9B, 0xC6, 0x38, 0xC4, + 0xE0, 0x48, 0x27, 0xA2, 0xEB, 0x9A, 0x1F, 0x4F, 0xF3, 0xB7, 0x9F, 0xCF, + 0x31, 0xD0, 0xDD, 0x6E, 0x8C, 0x81, 0x73, 0x29, 0x1A, 0x0A, 0x29, 0xCB, + 0x7E, 0x1A, 0x02, 0xB3, 0xAA, 0x0E, 0x91, 0xDD, 0xE7, 0xE8, 0xD7, 0x14, + 0x78, 0x85, 0x6B, 0x55, 0x53, 0x85, 0x35, 0x0B, 0x31, 0xE1, 0x79, 0x39, + 0xE1, 0x8A, 0x88, 0x8F, 0x2F, 0xF3, 0x7E, 0x8A, 0x63, 0x0C, 0x04, 0x38, + 0x8C, 0x3C, 0xC4, 0x70, 0xD8, 0x8F, 0x00, 0xF0, 0xE9, 0xF1, 0xE4, 0xAA, + 0xFE, 0x0F, 0x2F, 0x33, 0x41, 0xC9, 0x90, 0x2E, 0x47, 0xED, 0x08, 0x1E, + 0x88, 0xE9, 0x55, 0x73, 0x73, 0xA9, 0x9D, 0x58, 0x82, 0xFB, 0xF7, 0x23, + 0x2F, 0xC9, 0xC5, 0x1A, 0xA0, 0x47, 0x95, 0x9A, 0x05, 0xA6, 0xDD, 0x3E, + 0x8E, 0x31, 0x1C, 0x77, 0xC3, 0xE9, 0xB2, 0x10, 0xC2, 0xFD, 0x7E, 0x70, + 0xE0, 0xF3, 0x78, 0x3D, 0x5F, 0xF6, 0xFB, 0xFD, 0x38, 0x45, 0x7E, 0x39, + 0xAF, 0x66, 0x40, 0x04, 0xAA, 0xEA, 0x4A, 0xD9, 0xE5, 0xB2, 0x1E, 0x8F, + 0x53, 0x2B, 0x98, 0xF5, 0x63, 0x74, 0xD2, 0x7F, 0x42, 0x44, 0xA1, 0x38, + 0x28, 0xAA, 0x1C, 0x6F, 0xAC, 0x4D, 0x9E, 0xEF, 0x0E, 0xBE, 0xC9, 0xFD, + 0x17, 0x7D, 0x29, 0x3D, 0x2C, 0x81, 0x39, 0x14, 0x6A, 0x35, 0xE8, 0x63, + 0x45, 0x5E, 0x63, 0x19, 0xA0, 0xB6, 0xEC, 0x58, 0x37, 0xDA, 0x9B, 0xBA, + 0xF4, 0x7A, 0x9C, 0xD5, 0xEB, 0xD4, 0xE9, 0x1A, 0xBD, 0xBE, 0x06, 0x00, + 0x9B, 0x2E, 0xE0, 0x5A, 0x15, 0xB6, 0x52, 0x5D, 0x68, 0xC5, 0xA8, 0x35, + 0x73, 0xA3, 0x4C, 0x3B, 0x06, 0xA9, 0x12, 0xE4, 0xDA, 0x46, 0xD9, 0x74, + 0x43, 0xF7, 0xD9, 0xB5, 0xBF, 0xD6, 0xB4, 0xF0, 0x3A, 0x8A, 0x5A, 0x1D, + 0xC8, 0x00, 0x88, 0xAA, 0xB2, 0x0D, 0x66, 0x66, 0x62, 0x46, 0x1B, 0x33, + 0xF7, 0xED, 0xBF, 0xF1, 0xB4, 0x59, 0x40, 0xC5, 0x65, 0x28, 0x39, 0xAD, + 0x3E, 0x48, 0x8F, 0x13, 0x68, 0x96, 0x63, 0x99, 0x0D, 0xA0, 0x56, 0xEC, + 0x0E, 0x4C, 0x00, 0x28, 0x2A, 0xEE, 0xBA, 0x12, 0x54, 0xAB, 0xB6, 0xEC, + 0x75, 0xEF, 0x60, 0x56, 0xCA, 0x33, 0xDF, 0x2C, 0xB5, 0xEB, 0x34, 0x2D, + 0xD4, 0x59, 0x24, 0xDB, 0x30, 0xC4, 0x10, 0x88, 0x09, 0x10, 0x3C, 0xC7, + 0xC3, 0x13, 0xB3, 0x6A, 0x3D, 0x1F, 0x34, 0x05, 0x42, 0xCB, 0x39, 0x9B, + 0x81, 0xB9, 0x12, 0xDC, 0x80, 0xB5, 0x84, 0x31, 0x97, 0x0D, 0x72, 0xE7, + 0x9B, 0x9B, 0xAB, 0x81, 0x49, 0xCD, 0x72, 0x36, 0x51, 0x0B, 0xC7, 0xC3, + 0xA8, 0xDD, 0x8A, 0xFF, 0xD8, 0xD3, 0x4B, 0x9E, 0xF6, 0xF2, 0x0D, 0xA1, + 0x34, 0x41, 0xE8, 0x3F, 0x7B, 0xA8, 0xD0, 0xCD, 0x8E, 0x32, 0xF3, 0x61, + 0x3F, 0x12, 0xE2, 0x92, 0xF2, 0xBC, 0xA4, 0xA0, 0xBC, 0x27, 0xCC, 0x52, + 0x06, 0xED, 0xF0, 0xB7, 0x66, 0xB7, 0xAB, 0x6B, 0xEC, 0x0C, 0x38, 0x99, + 0xE0, 0xCD, 0x08, 0xAF, 0x7B, 0xB7, 0xAD, 0xE3, 0x82, 0x83, 0xC5, 0xA2, + 0x02, 0x80, 0x94, 0xF5, 0xF1, 0xE4, 0x39, 0xEA, 0xB6, 0x26, 0x0D, 0x8C, + 0x7E, 0x32, 0x3A, 0x2F, 0x89, 0x08, 0xB3, 0xC8, 0x40, 0x21, 0x67, 0x51, + 0x31, 0x55, 0x1D, 0x63, 0xC8, 0xA2, 0xCB, 0xBA, 0xBE, 0xBF, 0x3F, 0x88, + 0x2A, 0x11, 0x86, 0x40, 0xD5, 0x9C, 0x81, 0x71, 0x08, 0xC3, 0xC2, 0xFB, + 0x31, 0x1E, 0xA6, 0x98, 0x55, 0x2F, 0xCB, 0x2A, 0xCA, 0xC7, 0xDD, 0x68, + 0xB1, 0x88, 0xB2, 0x58, 0x42, 0x31, 0xE1, 0x34, 0x2F, 0xEB, 0x9A, 0xE7, + 0x55, 0xD4, 0x8C, 0x09, 0xD1, 0xC0, 0x85, 0x8F, 0x73, 0xE9, 0xE3, 0xCB, + 0x12, 0x43, 0x39, 0x74, 0x17, 0x31, 0x65, 0x1B, 0x06, 0x9E, 0x06, 0x2F, + 0x39, 0x83, 0x58, 0x0E, 0xB6, 0xF0, 0xFB, 0xA7, 0xCB, 0xE3, 0x29, 0x21, + 0x96, 0x88, 0x1F, 0xAA, 0x25, 0x04, 0xC6, 0x40, 0xA2, 0x36, 0x46, 0x5E, + 0xB3, 0x9C, 0xE7, 0x62, 0x5E, 0xBD, 0xBF, 0x9F, 0xE6, 0x35, 0xE7, 0xAC, + 0x63, 0xA4, 0x35, 0x4B, 0x73, 0xE0, 0x02, 0xC2, 0x71, 0x17, 0xFF, 0xC9, + 0x3F, 0xFA, 0x62, 0x1A, 0xE2, 0xBC, 0xA6, 0x4F, 0x8F, 0xF8, 0xEE, 0x6E, + 0xB7, 0x1F, 0xE3, 0x92, 0xB2, 0x88, 0x26, 0xD1, 0xDF, 0x7D, 0xF7, 0x6C, + 0xA6, 0x87, 0x89, 0xCF, 0x97, 0xF4, 0xF4, 0xB2, 0x80, 0x17, 0xB4, 0x32, + 0x18, 0x23, 0x7F, 0xF5, 0xEE, 0x10, 0x98, 0xC6, 0x31, 0x86, 0x10, 0xBC, + 0x6E, 0xE7, 0xEB, 0xC5, 0xEF, 0x0D, 0x96, 0x9E, 0x33, 0xFB, 0xC4, 0xEC, + 0x4A, 0x1E, 0x9E, 0x09, 0x07, 0xD5, 0xB9, 0x89, 0xD6, 0x45, 0x60, 0xF8, + 0xFF, 0x4C, 0xE4, 0xFF, 0xFD, 0xFF, 0xFE, 0x86, 0x90, 0x38, 0xF0, 0xFF, + 0xFC, 0xCF, 0xFF, 0x59, 0x0C, 0x41, 0x3C, 0x16, 0xAC, 0x5C, 0xD6, 0x51, + 0x37, 0xFB, 0xE6, 0x29, 0xC5, 0xB8, 0x37, 0xFB, 0xB1, 0x91, 0x68, 0xC9, + 0x76, 0x24, 0xAA, 0x5E, 0x5F, 0x6C, 0xCB, 0xD2, 0x1C, 0x13, 0xE5, 0x5B, + 0x1D, 0xD8, 0x16, 0x4F, 0xBC, 0x7A, 0x0C, 0x27, 0x5B, 0x29, 0x13, 0x5A, + 0xD4, 0x1A, 0x55, 0x43, 0x03, 0xB3, 0xAD, 0xA2, 0x96, 0x93, 0xC7, 0x36, + 0x97, 0xCA, 0xDE, 0xED, 0x20, 0xD2, 0xFF, 0xD4, 0x47, 0x87, 0xF9, 0xB3, + 0xB1, 0x52, 0x95, 0xC1, 0x15, 0x5D, 0xCC, 0x4A, 0x4D, 0x03, 0x44, 0xD9, + 0x56, 0xB5, 0xFF, 0xA1, 0x65, 0x47, 0x02, 0x80, 0xBB, 0x9B, 0x7B, 0x5F, + 0x29, 0xA0, 0x87, 0x4A, 0x58, 0x1B, 0x61, 0xD1, 0xA4, 0x5A, 0xD5, 0xD3, + 0xD2, 0xD4, 0xC6, 0xCE, 0x4C, 0xC4, 0xC4, 0xCC, 0x08, 0xC0, 0x2A, 0x90, + 0x72, 0xD2, 0x62, 0x2C, 0xDD, 0x18, 0x6A, 0x57, 0x28, 0xD6, 0x93, 0x41, + 0x9B, 0xA6, 0x59, 0xC9, 0xB8, 0x8C, 0x61, 0x18, 0xC7, 0xE8, 0x41, 0x61, + 0x29, 0x1B, 0x36, 0x30, 0x31, 0x08, 0x81, 0x09, 0x90, 0x88, 0x8C, 0xA0, + 0x94, 0xAF, 0x54, 0x8F, 0x47, 0xAB, 0xFA, 0x5E, 0x39, 0x7D, 0xAF, 0x9E, + 0x13, 0x33, 0xF3, 0xFC, 0x2A, 0x6D, 0x4B, 0x0D, 0x44, 0xC8, 0x8A, 0x41, + 0x45, 0x95, 0x84, 0xF8, 0x75, 0x45, 0xB2, 0x5B, 0x7A, 0xAD, 0x6B, 0xB1, + 0xE5, 0xBB, 0xBF, 0x41, 0x4E, 0x88, 0x66, 0xE6, 0x61, 0xBC, 0xCC, 0xE6, + 0xB1, 0x3C, 0x7D, 0x01, 0x06, 0x00, 0x60, 0xA2, 0xC3, 0x7E, 0xDC, 0xDB, + 0x90, 0xB2, 0x2C, 0x6B, 0xBE, 0xCC, 0x69, 0x4D, 0x59, 0xCC, 0xB2, 0xA8, + 0x4B, 0x0A, 0x0F, 0x49, 0xDD, 0xF6, 0xAC, 0x91, 0x19, 0xF4, 0xD6, 0xC4, + 0xC6, 0x39, 0xBD, 0xEA, 0x5E, 0x81, 0x14, 0xA0, 0xE4, 0x12, 0x95, 0xCD, + 0x5E, 0x12, 0xA4, 0x3C, 0x67, 0xD5, 0xFD, 0x10, 0x62, 0x88, 0xBB, 0x29, + 0xBE, 0xBB, 0xDB, 0x21, 0xA0, 0x8F, 0x61, 0x59, 0xB3, 0x88, 0x8E, 0x43, + 0xF0, 0x08, 0x8C, 0x94, 0xF3, 0xC3, 0x71, 0x1F, 0x02, 0x9F, 0xE7, 0x55, + 0xC5, 0xC6, 0xB1, 0x16, 0x04, 0x4F, 0xB2, 0xA6, 0x6C, 0x00, 0xF7, 0xFB, + 0x51, 0xCC, 0x1E, 0x4F, 0x0B, 0x23, 0x4D, 0x43, 0x64, 0x46, 0x11, 0x34, + 0xC4, 0x10, 0x48, 0xC1, 0x96, 0x39, 0xCF, 0xCB, 0x9A, 0xC4, 0xCE, 0x97, + 0x75, 0xCD, 0xE2, 0xAA, 0x93, 0x97, 0x04, 0x10, 0x05, 0xB7, 0x25, 0xCD, + 0x20, 0x04, 0x9A, 0x06, 0x0E, 0x44, 0xA2, 0x16, 0x23, 0x07, 0xA2, 0x61, + 0x08, 0x2E, 0x00, 0x9C, 0x76, 0xCE, 0x73, 0x7A, 0xB9, 0x24, 0xAC, 0x12, + 0x82, 0x08, 0x22, 0xF3, 0x61, 0x0A, 0x87, 0x69, 0xB8, 0x3F, 0x0C, 0x31, + 0x84, 0xC7, 0x97, 0xF9, 0xF1, 0x34, 0x4B, 0x24, 0x33, 0x18, 0x23, 0xDF, + 0xED, 0x86, 0x2F, 0x1E, 0x76, 0x63, 0x0C, 0x6B, 0x96, 0x1F, 0x9E, 0x2F, + 0x39, 0x2B, 0x96, 0x42, 0x00, 0xF0, 0x93, 0x0F, 0x25, 0xCD, 0x28, 0x06, + 0xFE, 0xC9, 0x17, 0xF7, 0xBE, 0x92, 0x07, 0x1D, 0x55, 0x8D, 0x09, 0x76, + 0x63, 0xFC, 0xF4, 0x74, 0x5E, 0xCA, 0x35, 0x25, 0xBE, 0x68, 0xA6, 0x6A, + 0x81, 0xE9, 0xFE, 0x38, 0x71, 0xE0, 0x1D, 0x95, 0x18, 0xC3, 0x9E, 0x70, + 0x7B, 0x43, 0xA6, 0x27, 0x86, 0xB6, 0x71, 0x0D, 0xC5, 0xDC, 0xD0, 0xC0, + 0x16, 0x49, 0xD0, 0xB1, 0x23, 0x20, 0x78, 0xF2, 0x44, 0x8B, 0x5D, 0x1E, + 0xC6, 0xF8, 0xCD, 0x37, 0x3F, 0xA8, 0xC8, 0xAF, 0x7F, 0xFF, 0xFD, 0x2A, + 0xF8, 0xAF, 0xFF, 0xB7, 0x7F, 0xA5, 0xF3, 0x6A, 0x7D, 0x9A, 0x1E, 0xB4, + 0xF6, 0xDB, 0x89, 0x25, 0xF5, 0x0A, 0xD1, 0x8D, 0x82, 0x60, 0xE6, 0x45, + 0x9F, 0x0A, 0x36, 0xF9, 0x5D, 0x13, 0xDB, 0xCD, 0x34, 0x1D, 0xE9, 0xDE, + 0x90, 0x31, 0xB8, 0xFD, 0xE7, 0x9C, 0xE4, 0xEE, 0xB7, 0x92, 0xE8, 0x66, + 0x48, 0x7A, 0x45, 0xA2, 0x66, 0xD8, 0xB9, 0x56, 0x5E, 0xF3, 0x45, 0x2F, + 0xCB, 0x37, 0xE8, 0x79, 0xA5, 0x07, 0xB4, 0x4F, 0xE8, 0xDA, 0xB4, 0xEC, + 0x95, 0xD0, 0xFE, 0xEB, 0xED, 0xB7, 0xED, 0xDF, 0xA2, 0x71, 0x3A, 0x05, + 0xD5, 0xF5, 0x6A, 0xA0, 0xD8, 0xE1, 0xA3, 0x56, 0xE3, 0xD0, 0xD9, 0x27, + 0x84, 0x40, 0x84, 0x8C, 0xA4, 0xA6, 0x04, 0x8C, 0x08, 0x48, 0x18, 0x63, + 0x90, 0xD5, 0xA0, 0xE2, 0xE8, 0x16, 0xEB, 0x0C, 0x35, 0xDC, 0xB6, 0x0E, + 0x8C, 0xBA, 0x12, 0x6F, 0xAD, 0xCD, 0xFA, 0x14, 0xAC, 0x34, 0xF7, 0x36, + 0x98, 0xE7, 0x38, 0x06, 0x0E, 0x14, 0x42, 0x20, 0x40, 0x35, 0x65, 0xA4, + 0x32, 0x87, 0x92, 0x35, 0x51, 0x7C, 0x4A, 0x56, 0x8A, 0xF9, 0xD4, 0xD2, + 0x45, 0x00, 0xAA, 0x62, 0xA5, 0x12, 0x30, 0x10, 0x90, 0x82, 0xAB, 0x66, + 0x18, 0x9E, 0x5E, 0x2E, 0x77, 0x87, 0x69, 0x9A, 0xDE, 0x06, 0xA6, 0x1F, + 0xDB, 0x92, 0x26, 0x67, 0x6E, 0xF0, 0xF8, 0xE6, 0x87, 0x10, 0x18, 0x11, + 0xFC, 0x9E, 0x99, 0x5E, 0x34, 0xF9, 0xCC, 0xDD, 0x9B, 0x7E, 0xD8, 0x89, + 0xDF, 0xCA, 0xB1, 0xA4, 0x9C, 0xB3, 0xA6, 0x24, 0x6A, 0x46, 0x28, 0x9E, + 0x71, 0xED, 0xFD, 0x15, 0x83, 0xBE, 0x0C, 0x60, 0x1B, 0x89, 0x55, 0x53, + 0xFF, 0xF5, 0x29, 0xF5, 0xF6, 0x57, 0x57, 0x0F, 0x15, 0x92, 0xA9, 0x13, + 0xC5, 0xFD, 0x7E, 0x74, 0xB1, 0x10, 0x03, 0x89, 0xDA, 0x9C, 0xF2, 0xBA, + 0x66, 0x44, 0x10, 0xB3, 0x58, 0xCA, 0xF2, 0x62, 0x60, 0xBA, 0xCC, 0xEB, + 0xBA, 0xA6, 0x8B, 0xDA, 0x79, 0xC6, 0xAC, 0xEA, 0xC7, 0x27, 0x4E, 0x23, + 0x2F, 0xF3, 0x32, 0xAF, 0x62, 0x0A, 0xC7, 0x63, 0x9C, 0xC6, 0x30, 0x2F, + 0x39, 0x65, 0x19, 0x62, 0x40, 0xC4, 0x65, 0xCD, 0x97, 0x79, 0x5D, 0x92, + 0x9C, 0x1C, 0xC5, 0x0C, 0xCC, 0x40, 0x08, 0xC6, 0x18, 0xC0, 0xEC, 0xBC, + 0xE6, 0x35, 0xAB, 0x1A, 0x20, 0x00, 0x33, 0xBD, 0x3F, 0xC6, 0xDD, 0x18, + 0xE6, 0x94, 0x55, 0x15, 0x98, 0x72, 0x96, 0x61, 0x08, 0xF3, 0x9C, 0x45, + 0xF5, 0xF3, 0xF3, 0x2C, 0xA2, 0x81, 0xC9, 0xED, 0x17, 0x87, 0xA4, 0x18, + 0x08, 0x11, 0xCE, 0x4B, 0xBA, 0x2C, 0xE9, 0xDD, 0xDD, 0xC4, 0x04, 0x53, + 0x64, 0x3F, 0x90, 0xBE, 0xDB, 0x8F, 0x22, 0x2A, 0x82, 0xB3, 0xA5, 0xCB, + 0x9C, 0xA6, 0xC8, 0x3C, 0x86, 0x87, 0xE3, 0x34, 0xC4, 0x90, 0x92, 0xEC, + 0x77, 0x83, 0xB9, 0xA8, 0xC8, 0xEA, 0x67, 0xD3, 0x29, 0xA5, 0x9C, 0x95, + 0x99, 0x88, 0xF9, 0xFD, 0xFD, 0x8E, 0x08, 0x5E, 0xCE, 0x8B, 0x3C, 0x5E, + 0x3C, 0x4A, 0xD1, 0xCC, 0x98, 0x60, 0x3F, 0x45, 0xD7, 0xE1, 0x4B, 0xD1, + 0x85, 0x6B, 0x8B, 0xE9, 0x35, 0x84, 0xF5, 0x0C, 0xD9, 0x50, 0x4C, 0xA4, + 0x84, 0x34, 0xB6, 0x37, 0xB7, 0x76, 0xBC, 0xFE, 0x52, 0xAD, 0x2C, 0x66, + 0x66, 0x21, 0xF2, 0x6F, 0x7E, 0xF3, 0xFB, 0x65, 0x5E, 0x01, 0x20, 0xC4, + 0xE1, 0x3F, 0xFD, 0xED, 0xDF, 0x3F, 0xDC, 0x1F, 0xFF, 0xC5, 0x5F, 0xFD, + 0x85, 0x57, 0xF7, 0x21, 0xDA, 0x82, 0xD8, 0x5D, 0x5C, 0x03, 0x34, 0xBB, + 0x06, 0xDF, 0x68, 0xBF, 0xB1, 0x59, 0xD1, 0xC2, 0x0A, 0x1F, 0x23, 0x61, + 0x83, 0x86, 0x9E, 0x60, 0xDE, 0x60, 0x01, 0x6F, 0xD5, 0xA0, 0x15, 0xD6, + 0xAD, 0xD3, 0xEF, 0x3D, 0x65, 0x8A, 0x88, 0x6A, 0x46, 0x40, 0xAF, 0x51, + 0xE6, 0xA6, 0x8B, 0x1B, 0xF6, 0x81, 0x57, 0xB0, 0x5B, 0x3E, 0x84, 0x0E, + 0xF3, 0x3A, 0xB8, 0x7C, 0x05, 0x64, 0xE5, 0x5F, 0xAD, 0xBF, 0x40, 0xA9, + 0xDB, 0x82, 0x8D, 0x55, 0xCA, 0x5F, 0xF4, 0xAA, 0x05, 0x05, 0x57, 0x85, + 0x37, 0x25, 0x91, 0x89, 0x62, 0x08, 0xED, 0xCF, 0x49, 0x84, 0x4B, 0x59, + 0x7D, 0xCA, 0x22, 0xCD, 0x97, 0x0F, 0x8D, 0xBB, 0x01, 0xB1, 0xFF, 0xF5, + 0xC6, 0x3D, 0xDA, 0x26, 0x8E, 0x80, 0x48, 0x1E, 0xD3, 0x8F, 0x88, 0x71, + 0x08, 0x66, 0x16, 0x98, 0x43, 0xA8, 0xD7, 0x8B, 0x10, 0xB9, 0x2D, 0x5F, + 0xCA, 0x0A, 0x79, 0xB6, 0xA6, 0x8B, 0xA7, 0x0D, 0x78, 0x7B, 0xB1, 0x04, + 0x4D, 0xA7, 0x51, 0x50, 0x2F, 0xAC, 0x28, 0x6A, 0xE1, 0x32, 0xA7, 0xDD, + 0x34, 0xFC, 0xD8, 0xC9, 0xFA, 0xCD, 0x06, 0x6C, 0x42, 0xF5, 0xBF, 0xFB, + 0x69, 0xBA, 0x9B, 0x27, 0x24, 0xA9, 0x4A, 0x2B, 0x6B, 0xEB, 0xAD, 0x4D, + 0x13, 0xC5, 0x18, 0x96, 0x35, 0xD1, 0x65, 0x79, 0xCE, 0x73, 0x3B, 0x48, + 0xF3, 0xA0, 0x5E, 0xDF, 0x8A, 0xBA, 0xBB, 0xC5, 0x2C, 0x50, 0xBB, 0x22, + 0x05, 0x00, 0x17, 0xD3, 0xAF, 0x8E, 0x17, 0x5C, 0x51, 0x2F, 0x85, 0x21, + 0x0B, 0xC5, 0xAC, 0x59, 0x44, 0x35, 0x86, 0x30, 0xCF, 0x29, 0x1E, 0x99, + 0x90, 0x02, 0xE1, 0x02, 0xB0, 0x2C, 0x19, 0x00, 0xE3, 0x9E, 0xBD, 0xD8, + 0xD9, 0xA7, 0xA7, 0x93, 0xAA, 0x11, 0x53, 0x20, 0x7C, 0x3A, 0x2D, 0x4F, + 0xA7, 0xE5, 0xB8, 0x1B, 0x86, 0xC8, 0x81, 0xF9, 0xB2, 0xA4, 0x4F, 0xCF, + 0xCB, 0x14, 0xF9, 0x8B, 0x87, 0x5D, 0x8C, 0xFC, 0xE9, 0xE9, 0xE2, 0x97, + 0xE6, 0xDD, 0x23, 0xCE, 0x6B, 0x9A, 0x86, 0xF8, 0xF1, 0xFD, 0x21, 0x25, + 0x3D, 0xEE, 0xD7, 0x6F, 0x7F, 0x38, 0xBD, 0x5C, 0x12, 0x11, 0x06, 0x2E, + 0x00, 0x04, 0x08, 0x81, 0x49, 0xC4, 0xB2, 0x2A, 0x13, 0x8A, 0x99, 0x5F, + 0xD7, 0xC6, 0x4C, 0x59, 0x75, 0x39, 0xCD, 0xF7, 0x30, 0x5D, 0x96, 0xB5, + 0x5C, 0x00, 0xEA, 0x87, 0x32, 0x5B, 0xF9, 0x5E, 0x04, 0x80, 0x94, 0x75, + 0x49, 0x0A, 0x00, 0x29, 0xCB, 0xBB, 0xE3, 0xF4, 0xC5, 0xFB, 0xC3, 0xD3, + 0x69, 0x51, 0xB5, 0x87, 0xE3, 0x94, 0x52, 0xFE, 0xFE, 0xF1, 0xEC, 0x0A, + 0xE3, 0x65, 0xCD, 0xF7, 0x87, 0x71, 0x8C, 0x41, 0xCD, 0xC6, 0x21, 0x88, + 0xEA, 0xF9, 0x69, 0x1D, 0x86, 0xB0, 0xA6, 0x2C, 0xA5, 0x08, 0xBD, 0x57, + 0x4C, 0x32, 0x11, 0xCB, 0x59, 0x72, 0x56, 0x50, 0x18, 0x87, 0xB0, 0x1B, + 0x71, 0x49, 0xF9, 0x34, 0x27, 0x26, 0x5C, 0x96, 0xA4, 0x35, 0xC6, 0x91, + 0x6A, 0x02, 0xCA, 0x6B, 0xAE, 0xEB, 0x3F, 0xBC, 0xA6, 0x39, 0x93, 0x66, + 0x2F, 0x5C, 0x97, 0x36, 0x6E, 0x13, 0xD2, 0x2C, 0x92, 0x85, 0xD8, 0x88, + 0x49, 0x55, 0x19, 0xF0, 0x3F, 0xFC, 0xC7, 0x5F, 0x49, 0xCE, 0xC7, 0xC3, + 0xF4, 0xD5, 0xFB, 0xC3, 0x30, 0xC6, 0xBF, 0xF9, 0x4F, 0xBF, 0x35, 0x80, + 0x7F, 0xF1, 0xCF, 0xFE, 0x9C, 0x91, 0x5C, 0xC7, 0xB4, 0x3E, 0x22, 0xBC, + 0xBA, 0x82, 0x7F, 0xCC, 0x3E, 0x40, 0x2C, 0x06, 0xA4, 0x75, 0x27, 0x51, + 0xD4, 0x8A, 0x87, 0xD6, 0x49, 0xBD, 0x96, 0x82, 0x57, 0x00, 0xE4, 0xDE, + 0xAA, 0x7A, 0xF4, 0xD4, 0xD9, 0x04, 0xAE, 0x6B, 0x30, 0xA0, 0x9A, 0x54, + 0xD3, 0x56, 0xB7, 0xAF, 0xF7, 0x42, 0xFD, 0x06, 0x5E, 0x1B, 0x88, 0xBC, + 0xEE, 0xB1, 0xAC, 0x73, 0x67, 0xF3, 0xB6, 0xF7, 0x3B, 0x20, 0xF3, 0x8B, + 0x3B, 0xEB, 0xE7, 0xED, 0xB4, 0xD9, 0x8A, 0x9E, 0x5B, 0xE2, 0x31, 0xDD, + 0x96, 0xB4, 0xED, 0xEB, 0x9E, 0x56, 0xD3, 0x95, 0x1D, 0x2B, 0x11, 0x30, + 0x6B, 0x4A, 0xA2, 0x02, 0x00, 0x9E, 0x26, 0xE5, 0x05, 0xFF, 0x20, 0x83, + 0xB6, 0x43, 0x08, 0x75, 0x6D, 0x4C, 0xB1, 0xE6, 0x97, 0xDE, 0xE8, 0xB0, + 0xAF, 0x57, 0xBE, 0x3A, 0x11, 0x36, 0x33, 0xCE, 0xBD, 0x13, 0x88, 0x28, + 0x62, 0x66, 0x4A, 0xA4, 0x1C, 0x88, 0x89, 0x11, 0xA9, 0x9D, 0xE1, 0x5A, + 0x43, 0x76, 0xC3, 0x52, 0x70, 0xBB, 0x5B, 0x04, 0x57, 0xC7, 0x10, 0x51, + 0xEA, 0xED, 0x09, 0x0E, 0xD4, 0x81, 0x08, 0xBD, 0x1A, 0x86, 0x5D, 0x97, + 0x40, 0xFA, 0x31, 0xE2, 0xF0, 0xA7, 0x8F, 0x33, 0x84, 0x6B, 0xF2, 0xBD, + 0x21, 0x88, 0x0E, 0x50, 0x2D, 0x65, 0x41, 0x40, 0xE6, 0xB2, 0x85, 0x1E, + 0x46, 0x63, 0x06, 0xCC, 0xB8, 0xDF, 0x0D, 0x84, 0x38, 0x2F, 0x29, 0x65, + 0x5D, 0x92, 0xAC, 0x39, 0x8B, 0x00, 0x22, 0x0E, 0x91, 0xDB, 0xB5, 0x49, + 0x35, 0x7C, 0xE4, 0x4A, 0xD8, 0xFA, 0x6E, 0x35, 0x8D, 0xAC, 0xF5, 0xE6, + 0x62, 0xA9, 0x85, 0xD7, 0xFA, 0x68, 0x00, 0x40, 0x0C, 0x3E, 0xBF, 0x2C, + 0x44, 0xEB, 0xFD, 0x7E, 0x18, 0x22, 0x23, 0xE2, 0x10, 0x43, 0x0C, 0x7C, + 0xBA, 0xAC, 0x22, 0xFA, 0x7C, 0x5A, 0x42, 0x20, 0x55, 0xBD, 0x2C, 0x39, + 0x30, 0xDD, 0x1D, 0x26, 0x4F, 0x9C, 0xAC, 0x96, 0x08, 0x8A, 0xEA, 0x9A, + 0x85, 0x11, 0xDD, 0xFE, 0xFD, 0xF6, 0xF3, 0x69, 0x4D, 0xE2, 0xD7, 0x0C, + 0x1F, 0x76, 0xE3, 0x71, 0x3F, 0xC6, 0xC8, 0x00, 0x46, 0x48, 0xF7, 0xC7, + 0xE9, 0xEE, 0x30, 0xFD, 0xFA, 0xF7, 0x9F, 0x1C, 0x14, 0x00, 0x60, 0x1A, + 0x82, 0x7A, 0x49, 0x00, 0x80, 0x40, 0xCC, 0x4C, 0x8F, 0x2F, 0x33, 0x22, + 0x1C, 0xA6, 0x21, 0x06, 0x3A, 0x5D, 0x52, 0x60, 0xBC, 0x84, 0xA4, 0x66, + 0x6B, 0x12, 0x3F, 0xAC, 0x44, 0xAC, 0xE7, 0xE0, 0x80, 0x00, 0xB6, 0x26, + 0x8B, 0x01, 0x77, 0x03, 0x8B, 0x5A, 0x16, 0xCB, 0xA2, 0xFB, 0x71, 0x38, + 0xEE, 0x47, 0xCF, 0xD9, 0xFB, 0xE6, 0xD3, 0x73, 0x16, 0xBD, 0xDB, 0x8F, + 0xE7, 0x25, 0x1D, 0xA6, 0x21, 0x67, 0xFD, 0xD5, 0x1F, 0x7E, 0x00, 0x83, + 0x69, 0x60, 0x44, 0x18, 0x62, 0x88, 0x6B, 0x32, 0x00, 0x53, 0x5B, 0xB3, + 0x1C, 0xF7, 0x23, 0x13, 0xE6, 0x2C, 0x22, 0x5C, 0x63, 0x71, 0xE0, 0xB8, + 0x1B, 0x76, 0x63, 0x7C, 0x39, 0x2F, 0xAA, 0x16, 0x03, 0xBD, 0x3B, 0x4E, + 0xD3, 0x18, 0x45, 0x94, 0x08, 0x55, 0x4B, 0xCC, 0x44, 0x4F, 0x1B, 0x37, + 0xFF, 0x5A, 0x2D, 0x66, 0xE0, 0x1F, 0x88, 0x48, 0xCE, 0x1E, 0xE3, 0xA9, + 0x5E, 0xD3, 0xB5, 0xD7, 0xEC, 0xAA, 0x33, 0xD8, 0xE6, 0x35, 0x4F, 0x63, + 0xAC, 0x46, 0x27, 0xEC, 0x77, 0xC3, 0xBF, 0xFA, 0x9F, 0xFE, 0xFC, 0x3F, + 0xFF, 0xDD, 0x1F, 0x7F, 0xFA, 0xF1, 0xFE, 0x79, 0xCE, 0x21, 0x4E, 0xDF, + 0x7C, 0xFB, 0xF8, 0x7F, 0x7D, 0xFE, 0x77, 0x7F, 0xF5, 0x97, 0xBF, 0xF8, + 0xEA, 0x8B, 0xF7, 0x00, 0x90, 0x92, 0xA2, 0xC9, 0xCD, 0xC9, 0x43, 0x03, + 0x82, 0x1B, 0x52, 0xF4, 0x13, 0x24, 0x67, 0x6F, 0xAD, 0xB7, 0x93, 0xA8, + 0x2A, 0xA1, 0x1F, 0x80, 0x81, 0xE1, 0xD5, 0xB1, 0xF8, 0x8F, 0x11, 0xB3, + 0x55, 0x0F, 0x6C, 0x93, 0xAC, 0x55, 0xEF, 0x00, 0x33, 0x75, 0xA7, 0x90, + 0x02, 0x60, 0x3B, 0x0F, 0x30, 0xE8, 0x03, 0xA7, 0xEB, 0x08, 0xC1, 0xFD, + 0xEB, 0xBD, 0x67, 0xC6, 0x7F, 0x68, 0x8E, 0xFF, 0x86, 0xF8, 0x9B, 0xAF, + 0xA4, 0x56, 0x0A, 0xBB, 0xE6, 0xA9, 0x4E, 0x5D, 0xA9, 0x3C, 0xE6, 0x97, + 0x58, 0x20, 0x22, 0xD4, 0x72, 0x3E, 0xAF, 0x6D, 0xD0, 0x1A, 0x58, 0x5E, + 0xC2, 0xD7, 0xDC, 0x91, 0x8F, 0x88, 0x66, 0x29, 0x67, 0xBC, 0x7A, 0x02, + 0x9B, 0x81, 0x94, 0x4B, 0x12, 0x51, 0xAC, 0x5C, 0x4F, 0xD8, 0x92, 0xEA, + 0xA8, 0x96, 0xB4, 0x29, 0x23, 0x27, 0x02, 0xB5, 0xEA, 0xFC, 0x74, 0x77, + 0x8A, 0xAB, 0x5D, 0x36, 0xCF, 0x2B, 0x11, 0x0D, 0x43, 0x2B, 0x33, 0x61, + 0xE5, 0x9A, 0x62, 0x44, 0xBF, 0x1A, 0xB9, 0x60, 0x94, 0x97, 0x12, 0x50, + 0x00, 0x2C, 0x17, 0xAA, 0x5D, 0x55, 0xFD, 0x2F, 0x8C, 0x5D, 0xB2, 0xB8, + 0xA0, 0xDA, 0x68, 0x44, 0x84, 0x66, 0xFC, 0xBF, 0xFF, 0x1F, 0xFF, 0xE7, + 0x30, 0xB0, 0x87, 0xAC, 0xDF, 0xEC, 0x65, 0x07, 0x0D, 0x1B, 0x70, 0xB4, + 0xE7, 0x66, 0xA7, 0x5F, 0x7F, 0x72, 0xB5, 0xCA, 0x85, 0x15, 0x51, 0x44, + 0xFD, 0x94, 0xAD, 0xD8, 0x16, 0x56, 0x1C, 0xFC, 0x7E, 0x6B, 0xEF, 0x38, + 0x04, 0x42, 0xCA, 0xF5, 0x94, 0xE0, 0xDD, 0x71, 0x0A, 0x4C, 0x6B, 0x12, + 0x00, 0x34, 0x30, 0x31, 0x54, 0xAF, 0xDC, 0x52, 0x47, 0x60, 0xE5, 0x2E, + 0x4B, 0x2C, 0xC1, 0xB4, 0x56, 0x5C, 0x03, 0xD6, 0xE1, 0xD7, 0x96, 0x6E, + 0xE8, 0xD1, 0x09, 0x6A, 0x9E, 0x43, 0x1A, 0x03, 0x79, 0x64, 0xAC, 0x88, + 0x64, 0xB5, 0xAC, 0xB6, 0xD4, 0xDB, 0x36, 0x2F, 0x4B, 0x4E, 0x59, 0x63, + 0xE4, 0xF3, 0x9C, 0x1E, 0x4F, 0xCB, 0x79, 0xC9, 0x81, 0x28, 0x30, 0x89, + 0x68, 0x0C, 0x9C, 0x44, 0xDC, 0xEB, 0x7F, 0x59, 0x52, 0xCA, 0x1A, 0x02, + 0x1F, 0xA6, 0xF8, 0xC5, 0xC3, 0x7E, 0xBF, 0x1B, 0x90, 0x70, 0x9E, 0x93, + 0x88, 0xFA, 0xE5, 0x4F, 0x31, 0x86, 0xC3, 0x34, 0x1C, 0xA6, 0xC8, 0x4C, + 0xD3, 0x10, 0x01, 0x6C, 0x0C, 0x61, 0x18, 0x82, 0x59, 0x11, 0x72, 0x58, + 0x6F, 0xB7, 0xCB, 0x59, 0xD7, 0x2C, 0xA9, 0x9C, 0x72, 0xE0, 0xE9, 0xB2, + 0x2E, 0x29, 0xAB, 0x9A, 0x17, 0xBA, 0xAC, 0x76, 0x90, 0x1B, 0x3A, 0x06, + 0x06, 0x81, 0x29, 0x04, 0x1A, 0x23, 0x7F, 0x78, 0x38, 0x8C, 0x63, 0xC8, + 0x59, 0x2F, 0x4B, 0x3A, 0x5D, 0x56, 0xD7, 0x55, 0x01, 0x31, 0xA5, 0xFC, + 0xED, 0xE3, 0x39, 0x8B, 0x81, 0x59, 0xCA, 0x22, 0x62, 0xD3, 0x18, 0xC6, + 0x21, 0xAC, 0xAB, 0x9C, 0xE7, 0xA4, 0x66, 0xE7, 0x39, 0x8D, 0x91, 0xD9, + 0x73, 0xD5, 0xCC, 0x76, 0x53, 0x64, 0x26, 0x55, 0xF5, 0x6B, 0xBB, 0xEE, + 0xF6, 0xC3, 0x57, 0x1F, 0x8E, 0x1F, 0x3F, 0xDC, 0xB9, 0x6B, 0x4C, 0xA4, + 0xA4, 0xB6, 0x94, 0x93, 0xB5, 0x57, 0x4E, 0x52, 0xDF, 0x63, 0x11, 0x59, + 0xD7, 0xE4, 0xB7, 0x8E, 0xFA, 0xB7, 0x52, 0x96, 0x9C, 0x05, 0x10, 0x03, + 0x33, 0xB4, 0x52, 0x4E, 0x06, 0x6A, 0xB2, 0xAE, 0xB2, 0xAE, 0x49, 0xD5, + 0xD6, 0x94, 0xFD, 0x64, 0x23, 0x04, 0x7E, 0x79, 0x3E, 0xFD, 0xEE, 0x77, + 0x7F, 0x0C, 0x31, 0xFE, 0xE7, 0x5F, 0xFF, 0xFE, 0xC3, 0xFB, 0xFB, 0xFF, + 0xF8, 0xEB, 0x6F, 0xD4, 0x8C, 0x99, 0x53, 0x96, 0x5F, 0xFD, 0xF6, 0x8F, + 0x97, 0xCB, 0x72, 0xDC, 0x4F, 0x93, 0x67, 0xBC, 0xD6, 0xC2, 0xF6, 0x8D, + 0x1A, 0x7B, 0x00, 0x2A, 0x14, 0x52, 0xAB, 0x91, 0x42, 0xE1, 0xEA, 0x7A, + 0xB7, 0x4E, 0xD5, 0xCE, 0xB0, 0xC2, 0x53, 0x3F, 0x91, 0x62, 0x4A, 0xF6, + 0xB2, 0xBC, 0xB2, 0xD1, 0x66, 0x17, 0x60, 0x73, 0x5D, 0x42, 0xB9, 0x5B, + 0xB3, 0x96, 0x75, 0x40, 0x24, 0xA4, 0x76, 0x5D, 0xF9, 0x16, 0x91, 0xEB, + 0x49, 0x7D, 0x85, 0x79, 0x4B, 0x86, 0x5F, 0xAD, 0x9A, 0x56, 0x07, 0x50, + 0xC3, 0xAF, 0xAE, 0x92, 0x10, 0x1A, 0xFF, 0x38, 0x12, 0x35, 0x0F, 0xE1, + 0x36, 0x66, 0x00, 0x73, 0xB2, 0x30, 0x33, 0xC3, 0xE2, 0x42, 0xAA, 0x81, + 0xC2, 0x0D, 0xB6, 0xB4, 0xDC, 0x9C, 0x52, 0x1E, 0x70, 0x47, 0x57, 0xAD, + 0x14, 0x5F, 0x5B, 0xDA, 0x56, 0x2F, 0x70, 0x40, 0x84, 0x9C, 0xC5, 0xA5, + 0xB8, 0x6A, 0x0B, 0x72, 0x53, 0x44, 0x04, 0x24, 0x66, 0xE2, 0x1A, 0x0F, + 0x48, 0x44, 0x8C, 0x88, 0x7E, 0x96, 0x55, 0x1A, 0x21, 0x40, 0x08, 0x1C, + 0x98, 0xD9, 0xD4, 0xC0, 0x20, 0x7B, 0x45, 0x42, 0x44, 0x22, 0x1C, 0x86, + 0x18, 0xEA, 0x55, 0x92, 0x0D, 0x23, 0xB4, 0xB8, 0xA0, 0x6A, 0x49, 0xB8, + 0x57, 0x76, 0xA5, 0x2F, 0xBD, 0x15, 0xFD, 0x6E, 0xAB, 0x7E, 0x8C, 0x88, + 0x61, 0x08, 0x81, 0x3C, 0xE8, 0x81, 0xB4, 0x5F, 0x9D, 0x7E, 0x11, 0xFB, + 0x50, 0xE0, 0x37, 0x51, 0xAC, 0x7F, 0xAC, 0x93, 0x02, 0x0D, 0x47, 0x6B, + 0xD5, 0x8A, 0x10, 0x02, 0xD5, 0xC2, 0x07, 0xE5, 0x3E, 0x1B, 0x1F, 0xA7, + 0x9A, 0xAD, 0x6B, 0x62, 0xE6, 0xC3, 0x7E, 0x08, 0x01, 0x1F, 0x5F, 0x16, + 0x97, 0xD8, 0xA7, 0x39, 0x37, 0x63, 0xDE, 0xC1, 0x9E, 0xA8, 0x5C, 0xC5, + 0xA6, 0x60, 0x8C, 0xE8, 0x59, 0x35, 0xC3, 0x18, 0x88, 0xD0, 0x83, 0x21, + 0x3C, 0xC8, 0x96, 0x08, 0xB3, 0xD8, 0x9A, 0xCB, 0x25, 0xB7, 0x06, 0x40, + 0x04, 0x8C, 0xB4, 0x26, 0x05, 0xC4, 0xAC, 0xFA, 0xFD, 0xD3, 0xC5, 0x15, + 0x10, 0x87, 0x2F, 0x42, 0xCC, 0xAA, 0x91, 0xF9, 0xF1, 0x65, 0xF1, 0x2B, + 0x4E, 0xD3, 0xCB, 0x92, 0xC4, 0x44, 0x14, 0x10, 0xB2, 0x5A, 0x0C, 0x7C, + 0xB7, 0x1F, 0x96, 0x94, 0xCD, 0x60, 0x08, 0x8C, 0x80, 0x6B, 0x89, 0x95, + 0x05, 0x33, 0x38, 0x2F, 0xEB, 0xD9, 0xC3, 0x38, 0x10, 0xA6, 0x31, 0x12, + 0x62, 0x60, 0x56, 0x12, 0x0F, 0xF7, 0x57, 0xB5, 0x79, 0x4D, 0x62, 0x36, + 0x30, 0x06, 0xA2, 0x21, 0xB2, 0x78, 0x6A, 0x05, 0x19, 0x98, 0x89, 0xE8, + 0x30, 0x04, 0xEF, 0x48, 0xD5, 0xB2, 0xE8, 0x92, 0xB2, 0x47, 0x87, 0xF8, + 0x42, 0x53, 0x2D, 0x7E, 0x05, 0x60, 0xBB, 0x61, 0x20, 0x84, 0x25, 0xE7, + 0x7D, 0x88, 0x0F, 0x87, 0x89, 0x98, 0x10, 0xC9, 0x43, 0x46, 0x8E, 0xBB, + 0x21, 0x04, 0x1A, 0x42, 0xC8, 0x22, 0x97, 0x25, 0x7F, 0xB8, 0x67, 0x33, + 0x23, 0x42, 0x11, 0x45, 0xC0, 0x40, 0xE4, 0x81, 0x1D, 0x06, 0x36, 0xC4, + 0xF0, 0xF9, 0xF9, 0xF2, 0x74, 0x9A, 0xEF, 0xF6, 0x93, 0xB3, 0x4C, 0x0C, + 0xC1, 0xDF, 0x01, 0x00, 0xBF, 0x83, 0xD9, 0x4B, 0xCE, 0x79, 0x64, 0xF6, + 0x9A, 0x64, 0x1C, 0x02, 0x73, 0xC9, 0xB8, 0x6C, 0x87, 0xEB, 0x8D, 0x52, + 0xCC, 0x2C, 0xE7, 0xBC, 0x2C, 0x39, 0x67, 0x41, 0x44, 0x11, 0x22, 0xC4, + 0xAC, 0x96, 0x52, 0x36, 0x33, 0x8F, 0x5F, 0x09, 0xA1, 0xE4, 0x39, 0xB9, + 0x69, 0x23, 0xA2, 0x39, 0x17, 0xFF, 0x40, 0x4A, 0x42, 0x84, 0x31, 0x0C, + 0xBF, 0xFF, 0xC3, 0x37, 0x6B, 0x86, 0x7F, 0xF3, 0xD7, 0x7F, 0xF7, 0xF1, + 0xC3, 0xC3, 0x92, 0xF4, 0xF3, 0xD3, 0x09, 0x89, 0x5E, 0x5E, 0x5E, 0x7E, + 0xF9, 0x8B, 0x9F, 0x7D, 0x7C, 0xFF, 0xF0, 0x87, 0x6F, 0x7F, 0xF8, 0xD3, + 0x37, 0xDF, 0x7F, 0xF9, 0xF1, 0xFE, 0x2F, 0xFF, 0xE2, 0xE7, 0x77, 0xC7, + 0x83, 0xE7, 0xBE, 0xF4, 0xD1, 0xFB, 0x8D, 0xFC, 0xB0, 0x44, 0x8A, 0x15, + 0x08, 0x73, 0x6C, 0x6A, 0x6A, 0x54, 0xCA, 0x59, 0xD5, 0x42, 0xE4, 0xC0, + 0x8C, 0x82, 0x54, 0x83, 0xEC, 0x0B, 0x2B, 0x5B, 0x45, 0xAB, 0xC6, 0x0B, + 0xC5, 0x90, 0xBA, 0x65, 0x29, 0x6F, 0xD4, 0x21, 0xCE, 0xD5, 0x11, 0x2C, + 0xBE, 0xA3, 0x46, 0xF6, 0x45, 0x73, 0x70, 0x14, 0xA4, 0xEA, 0x54, 0x69, + 0x9C, 0xD2, 0x31, 0x08, 0xB5, 0x1F, 0xE0, 0x95, 0xE3, 0x0C, 0x2A, 0x8A, + 0x15, 0xBF, 0xA0, 0xF5, 0x1F, 0xDE, 0xB0, 0xDF, 0x2D, 0x0F, 0x56, 0x16, + 0xAE, 0x05, 0x2D, 0x3B, 0xCD, 0x02, 0x4C, 0xEB, 0x25, 0x2E, 0xC5, 0x65, + 0xE9, 0x03, 0x20, 0x66, 0xCF, 0x53, 0x51, 0xC0, 0xC0, 0xEC, 0xD7, 0x7A, + 0x4B, 0xC5, 0x17, 0x66, 0x1E, 0x8A, 0xCF, 0x0B, 0xB0, 0x66, 0x3B, 0xD1, + 0x56, 0x08, 0xCB, 0x90, 0x01, 0x4D, 0x09, 0xB0, 0x79, 0x00, 0xCC, 0x4A, + 0x54, 0x66, 0x4A, 0x89, 0xC7, 0x01, 0xFC, 0x16, 0x18, 0xE6, 0x66, 0x30, + 0xB9, 0x58, 0x72, 0xA1, 0xEE, 0xCA, 0xA7, 0xD5, 0x24, 0xA7, 0x3A, 0x53, + 0xF4, 0x3A, 0x0B, 0x4D, 0xC9, 0xAC, 0xC3, 0xAE, 0xB0, 0x1B, 0x02, 0x79, + 0xBC, 0x92, 0xAE, 0xEA, 0x55, 0xC0, 0xCD, 0xC0, 0x9D, 0x7C, 0x76, 0x2D, + 0xBE, 0xCC, 0xD4, 0x89, 0xC6, 0xEC, 0x4A, 0x32, 0xD3, 0xF5, 0x35, 0x79, + 0xED, 0x5F, 0xBC, 0xB6, 0x3D, 0xFD, 0x63, 0x22, 0x72, 0x50, 0xF7, 0xC2, + 0x19, 0x22, 0xA5, 0x8B, 0xCB, 0x65, 0x15, 0xB1, 0xD3, 0xE5, 0xB2, 0xA6, + 0x6C, 0x80, 0x59, 0x15, 0x14, 0x96, 0xB4, 0x22, 0x82, 0x5A, 0xB9, 0xDB, + 0x2E, 0x12, 0x0D, 0x81, 0x00, 0xD1, 0x55, 0xB6, 0xDD, 0x14, 0xEF, 0xF7, + 0xE3, 0x6E, 0x8A, 0x08, 0x70, 0x7F, 0xB7, 0x53, 0xAF, 0xE5, 0x0F, 0xB0, + 0xAE, 0x32, 0xAF, 0xE9, 0xFB, 0xA7, 0xF3, 0xBC, 0xE4, 0x35, 0x77, 0xA7, + 0xFB, 0xF5, 0x7C, 0x7A, 0x49, 0x3A, 0xAF, 0x79, 0x37, 0x84, 0x35, 0x4B, + 0x0C, 0x34, 0xC6, 0x30, 0x44, 0x56, 0xB3, 0xCB, 0x9C, 0x96, 0x2C, 0xE3, + 0x10, 0x98, 0xF0, 0xE5, 0xB2, 0xCE, 0xAB, 0x7A, 0x1C, 0x36, 0x02, 0x64, + 0xD1, 0xD3, 0xB2, 0x1E, 0xA6, 0xE8, 0x45, 0xD3, 0x00, 0x40, 0x55, 0x3C, + 0x92, 0x20, 0x8B, 0x8A, 0xD9, 0x69, 0x4E, 0x39, 0xEB, 0x57, 0xEF, 0x0F, + 0xF3, 0x9A, 0xC7, 0x01, 0x98, 0xC9, 0xC0, 0xBE, 0xFB, 0x74, 0x12, 0x55, + 0x42, 0xF4, 0x1A, 0x1E, 0x81, 0x79, 0x4E, 0x39, 0x08, 0x21, 0x96, 0xD8, + 0x24, 0x2F, 0x70, 0x10, 0x03, 0x0D, 0x4C, 0x2A, 0x7A, 0xDC, 0x0D, 0xC7, + 0xFD, 0xF8, 0xFD, 0xE3, 0xD9, 0x0C, 0xB8, 0x17, 0x38, 0xE0, 0x58, 0x0F, + 0x84, 0xF8, 0xEE, 0x38, 0x8E, 0x43, 0x78, 0x7C, 0x99, 0xA3, 0xE7, 0x45, + 0x11, 0x22, 0x22, 0x33, 0x0D, 0x43, 0x98, 0xA6, 0x61, 0x27, 0xE2, 0xBA, + 0xCF, 0x65, 0x5E, 0x73, 0x96, 0x69, 0x1A, 0x52, 0xCA, 0x22, 0x1A, 0x63, + 0xF0, 0x1A, 0x4D, 0x0B, 0xD3, 0x71, 0x3F, 0x8E, 0x31, 0x22, 0x40, 0x56, + 0x4D, 0x39, 0xC7, 0x18, 0x22, 0x91, 0xAA, 0x0D, 0x43, 0x30, 0xB0, 0x9C, + 0x35, 0xC6, 0xE0, 0xF8, 0x15, 0xA3, 0x6F, 0x25, 0xF8, 0xBD, 0x76, 0xBD, + 0x92, 0x52, 0xEB, 0xE1, 0x61, 0xE5, 0x08, 0x5D, 0xD7, 0xBC, 0x2C, 0x49, + 0x3C, 0x1B, 0xB1, 0x16, 0x7F, 0xF7, 0x8C, 0xDF, 0x2C, 0xCA, 0x80, 0xA4, + 0x2D, 0x61, 0x11, 0x44, 0x8C, 0x89, 0x32, 0x88, 0x97, 0x61, 0x59, 0x2D, + 0x4F, 0xD3, 0xF0, 0xD7, 0xFF, 0xFE, 0xBF, 0xFC, 0x9B, 0x7F, 0xF7, 0x2B, + 0x95, 0xFC, 0xF9, 0xE9, 0xE5, 0x1F, 0xFF, 0xE2, 0xCB, 0x6F, 0x1F, 0x2F, + 0x77, 0xC7, 0xBD, 0xE4, 0x84, 0x48, 0x4F, 0x4F, 0xCF, 0xEF, 0xEE, 0x8F, + 0x87, 0xDD, 0xA8, 0x39, 0x7F, 0xF3, 0xCD, 0xE7, 0xF9, 0x32, 0x7F, 0xF5, + 0xE5, 0x87, 0xAF, 0xBE, 0xFC, 0x70, 0x7F, 0x77, 0x20, 0x22, 0x11, 0x05, + 0x28, 0x97, 0x15, 0x62, 0xBD, 0x29, 0xBC, 0xEA, 0xFC, 0x2D, 0x9C, 0xB6, + 0x70, 0xA9, 0x8F, 0x2C, 0xAB, 0x42, 0x06, 0x35, 0x23, 0xC0, 0x88, 0x01, + 0x4A, 0xF6, 0x40, 0xC1, 0xBD, 0x1B, 0x41, 0xDD, 0x54, 0x1B, 0xA8, 0xF1, + 0xAC, 0x1B, 0xC2, 0xF9, 0x17, 0x14, 0xCC, 0x4A, 0x84, 0x94, 0x7F, 0x40, + 0xB0, 0x45, 0x10, 0xF4, 0xF1, 0x9C, 0x3D, 0x2A, 0x81, 0x95, 0xCE, 0x5A, + 0x65, 0x91, 0xEB, 0x1E, 0xAF, 0x40, 0x07, 0x11, 0xCB, 0xC5, 0xF7, 0x1B, + 0x5E, 0x39, 0xDE, 0x5D, 0xD7, 0x69, 0xAA, 0x1F, 0xBC, 0x46, 0xB1, 0x2B, + 0x08, 0xAB, 0x2F, 0x43, 0xB5, 0x04, 0x6B, 0x7B, 0x44, 0x4C, 0x1E, 0x8F, + 0x6A, 0x66, 0x08, 0x30, 0x0E, 0x83, 0xA8, 0xE6, 0x9C, 0x03, 0x23, 0x53, + 0x09, 0xC7, 0xC7, 0x9A, 0xA7, 0x85, 0x08, 0x5C, 0xAE, 0xE4, 0x43, 0x53, + 0xF3, 0x7B, 0xC2, 0x01, 0xA1, 0x95, 0xB6, 0x8F, 0x91, 0x01, 0x01, 0xD0, + 0x88, 0x30, 0xC4, 0x20, 0xA2, 0x29, 0xE7, 0x10, 0x02, 0x11, 0xA8, 0x34, + 0xC5, 0xB0, 0x5C, 0x15, 0xAA, 0x9D, 0xD7, 0xAB, 0xAD, 0x19, 0xB8, 0x2F, + 0xD2, 0x0F, 0xC8, 0xC8, 0x5A, 0xE2, 0x8A, 0x5E, 0xCF, 0x25, 0xAC, 0x29, + 0x13, 0x33, 0x98, 0x18, 0x40, 0x0C, 0xC6, 0xF5, 0x2A, 0xC6, 0x8A, 0x62, + 0xE6, 0x52, 0x1D, 0x00, 0x44, 0xCC, 0x2C, 0x57, 0xC7, 0xA1, 0x21, 0x51, + 0x0C, 0x01, 0xAE, 0x31, 0xAB, 0x35, 0xDD, 0xEF, 0x0A, 0x16, 0x2F, 0x80, + 0xC3, 0x27, 0x30, 0x53, 0x8C, 0x1E, 0x60, 0x51, 0x72, 0xD9, 0x98, 0x39, + 0x30, 0x8B, 0x64, 0x8F, 0x98, 0x55, 0xB3, 0x7D, 0x18, 0x76, 0x63, 0x74, + 0xE7, 0xC6, 0x0F, 0x8F, 0xE7, 0x24, 0xA2, 0x6A, 0x29, 0xC9, 0x38, 0x06, + 0x26, 0x72, 0xE5, 0xE2, 0xFD, 0xC3, 0xBE, 0xAA, 0xE9, 0x08, 0x60, 0x97, + 0xCB, 0x1A, 0x89, 0x99, 0x68, 0x8C, 0x9C, 0x72, 0xFE, 0xE1, 0x79, 0x9E, + 0x93, 0xF2, 0xF5, 0x29, 0xBB, 0xEF, 0x8D, 0x93, 0xAF, 0x17, 0x41, 0x44, + 0xC0, 0x2C, 0x7E, 0x3F, 0x88, 0x30, 0xD3, 0x5D, 0xE4, 0x35, 0x6B, 0xCA, + 0x25, 0x3B, 0x03, 0xB1, 0x08, 0x75, 0x42, 0x04, 0xC3, 0xEF, 0x9F, 0xCE, + 0x53, 0x0C, 0x00, 0xB0, 0x8A, 0x78, 0x42, 0x28, 0x81, 0x4B, 0x78, 0x19, + 0xA6, 0xE1, 0x70, 0x1C, 0x98, 0x69, 0x8C, 0xC1, 0x35, 0x84, 0xCB, 0xBC, + 0x9E, 0xE6, 0xD5, 0x45, 0xF9, 0x79, 0x4D, 0x84, 0x5E, 0xF3, 0x03, 0xE2, + 0x40, 0x4B, 0x12, 0x44, 0x1C, 0x23, 0x65, 0xD1, 0x77, 0xC7, 0x69, 0x1A, + 0xC2, 0xE7, 0x97, 0x59, 0xCC, 0x2D, 0x6B, 0x30, 0xB3, 0x18, 0xC8, 0xB3, + 0x35, 0x4B, 0xB9, 0x3B, 0x35, 0x04, 0x18, 0x03, 0x0F, 0x81, 0xCF, 0x73, + 0x5A, 0xD6, 0x7C, 0xB7, 0x1F, 0x08, 0x51, 0x6A, 0x64, 0x03, 0x11, 0x8F, + 0x63, 0xF4, 0xF8, 0x1F, 0x51, 0x71, 0xB5, 0x68, 0xB7, 0x1B, 0xF6, 0xBB, + 0xE1, 0x74, 0xB2, 0x18, 0x78, 0x18, 0x02, 0x18, 0x9C, 0xE7, 0xF5, 0x34, + 0x2F, 0x39, 0xDB, 0x1A, 0xF3, 0x61, 0x3F, 0x5D, 0xE6, 0xF5, 0xB2, 0xAC, + 0x88, 0x28, 0x59, 0x60, 0xC5, 0xE3, 0x7E, 0xF4, 0x94, 0x06, 0x55, 0x13, + 0x55, 0xE6, 0xA2, 0x3B, 0xAB, 0x6A, 0xCE, 0x42, 0x14, 0xFB, 0x95, 0x74, + 0x13, 0x58, 0x04, 0x10, 0x21, 0x67, 0x4D, 0x29, 0x7B, 0xE6, 0x19, 0x00, + 0xA8, 0x6A, 0xF2, 0xF3, 0x50, 0xC4, 0xF3, 0xBC, 0xC4, 0x18, 0x48, 0xC0, + 0x5D, 0x6C, 0x6C, 0xE8, 0x7E, 0xAA, 0x94, 0x25, 0xAD, 0x39, 0xAB, 0x9B, + 0xF6, 0x06, 0x48, 0x7F, 0xFF, 0xC7, 0xEF, 0xFE, 0xEF, 0xFF, 0xE7, 0xDF, + 0x32, 0x0D, 0x4F, 0x2F, 0x2F, 0x5F, 0x7F, 0xF5, 0xFE, 0xDD, 0xC3, 0xF1, + 0x37, 0x7F, 0xFC, 0x74, 0x38, 0xEC, 0x41, 0x25, 0x06, 0x3C, 0xEC, 0x06, + 0x53, 0xFD, 0xE2, 0xFD, 0x7D, 0x5E, 0xD7, 0x65, 0x1A, 0x44, 0xF5, 0x9B, + 0x6F, 0x3F, 0x7F, 0xFB, 0xFD, 0xE3, 0xF1, 0xB8, 0xFB, 0xE5, 0x2F, 0x7E, + 0xFA, 0xFE, 0xE1, 0xDE, 0x0B, 0x54, 0x41, 0xDD, 0xAF, 0xA6, 0x3C, 0x99, + 0xBD, 0xC6, 0x25, 0x88, 0x31, 0x28, 0x08, 0x22, 0x32, 0x21, 0xBA, 0x83, + 0x58, 0xCD, 0x4A, 0x91, 0x0E, 0xD8, 0xC0, 0xE6, 0x9A, 0x72, 0x4A, 0xDC, + 0xC6, 0x2B, 0xFF, 0x3D, 0x22, 0x1A, 0x01, 0x6A, 0xFB, 0xAA, 0x91, 0x47, + 0xB5, 0x59, 0x3D, 0x5D, 0xAD, 0xE6, 0xE9, 0xD6, 0x9A, 0x33, 0xAF, 0xBA, + 0x42, 0xA7, 0x37, 0x03, 0xEC, 0x35, 0xB5, 0x7E, 0x14, 0x9D, 0xCA, 0x79, + 0x7D, 0xA9, 0x5F, 0x3F, 0x52, 0xBB, 0x6D, 0xCA, 0xD9, 0xBD, 0x37, 0xD3, + 0x6A, 0x9B, 0x0D, 0x8E, 0xD5, 0xD3, 0xA8, 0xDC, 0x6D, 0x15, 0x39, 0x78, + 0xFD, 0x30, 0x62, 0x22, 0x26, 0x44, 0x18, 0x30, 0x2C, 0x0B, 0x22, 0x89, + 0x2A, 0x96, 0xE2, 0x48, 0x56, 0x4A, 0x78, 0xC5, 0x2E, 0xC1, 0xA3, 0x95, + 0x17, 0xD7, 0x1A, 0xEB, 0xDB, 0xD8, 0x87, 0x19, 0xDD, 0x29, 0xE6, 0xB7, + 0xE2, 0x04, 0x00, 0x04, 0x90, 0x2C, 0x02, 0x8A, 0x25, 0xC9, 0x89, 0xA0, + 0x5A, 0xCD, 0xFD, 0x94, 0x0B, 0x4A, 0x97, 0x1B, 0x39, 0x01, 0x6B, 0x1E, + 0xBB, 0x07, 0x70, 0x7B, 0xA1, 0xC0, 0xA2, 0x91, 0x65, 0xCF, 0x1B, 0xF0, + 0x02, 0x4F, 0x55, 0xB7, 0x12, 0x31, 0x22, 0x2A, 0x09, 0x13, 0x06, 0x49, + 0x64, 0x5D, 0x73, 0x4A, 0xB9, 0x64, 0x95, 0x0F, 0x21, 0x56, 0x76, 0xBD, + 0xC9, 0x8A, 0xC0, 0xAE, 0x5E, 0x6D, 0x2F, 0xC0, 0x7B, 0x59, 0xA4, 0xAA, + 0xAE, 0x88, 0xB9, 0x58, 0xF2, 0x8C, 0x9D, 0x69, 0x8C, 0x31, 0x70, 0xCA, + 0xE5, 0xBA, 0x4C, 0x72, 0xFF, 0x06, 0xA1, 0xA8, 0x7E, 0xF5, 0xE1, 0x0E, + 0xB1, 0x5C, 0x9E, 0xE8, 0x90, 0xBA, 0xAC, 0x69, 0x37, 0x0D, 0x7E, 0xB5, + 0x75, 0xED, 0x08, 0xC7, 0x71, 0xF0, 0xAE, 0x39, 0x84, 0x8F, 0xEF, 0x0E, + 0xFF, 0x03, 0xC0, 0xEF, 0xBE, 0x7D, 0x5E, 0x92, 0xF8, 0xB1, 0x60, 0xE0, + 0xE2, 0x96, 0x13, 0xBF, 0xAB, 0xDC, 0xCC, 0x0C, 0x22, 0x93, 0xDF, 0x44, + 0xE7, 0x39, 0xEA, 0xAE, 0x30, 0x67, 0x91, 0xE7, 0x4B, 0x2A, 0x3A, 0x51, + 0x15, 0xA8, 0x84, 0x58, 0x2A, 0x53, 0x13, 0x6A, 0x56, 0x53, 0xCB, 0xC5, + 0x07, 0x6A, 0x84, 0x98, 0x92, 0xBE, 0xD8, 0x42, 0x88, 0xBB, 0x29, 0x0C, + 0x43, 0x50, 0x95, 0xCB, 0x65, 0x59, 0xB2, 0x44, 0x26, 0x00, 0x58, 0x45, + 0x09, 0x91, 0x09, 0x87, 0xC8, 0xFB, 0x71, 0xD8, 0xEF, 0xE2, 0xBC, 0xE6, + 0xE7, 0xF3, 0xAA, 0xAA, 0xC7, 0xDD, 0x10, 0x03, 0xCF, 0x6B, 0x56, 0xD5, + 0x35, 0xE5, 0xF3, 0x92, 0x44, 0x94, 0x18, 0x2D, 0x03, 0x00, 0x10, 0x13, + 0xA2, 0x31, 0x53, 0xE0, 0x00, 0x06, 0xBB, 0x31, 0xCC, 0x4B, 0x32, 0x33, + 0x44, 0x3A, 0x5D, 0xD6, 0xC3, 0x6E, 0xF0, 0x80, 0x0F, 0x2D, 0xF5, 0xB9, + 0x8A, 0x1F, 0xDD, 0x0C, 0x44, 0x6C, 0xBF, 0x8B, 0x66, 0x96, 0xB3, 0x1E, + 0x0E, 0x93, 0x16, 0x7C, 0xB2, 0x21, 0xF2, 0x18, 0x03, 0x98, 0x78, 0xA9, + 0xA4, 0xC0, 0xB4, 0x9F, 0x06, 0x00, 0x18, 0x62, 0xF0, 0x68, 0xC9, 0x65, + 0xCD, 0x39, 0x8B, 0x19, 0xDC, 0x1D, 0x77, 0x66, 0x7A, 0x3E, 0x2F, 0x59, + 0xF4, 0xB2, 0xA4, 0x94, 0xF2, 0xD7, 0x1F, 0xEF, 0xA1, 0x5A, 0x67, 0xBE, + 0xC3, 0x29, 0x65, 0x0F, 0x18, 0x46, 0xC3, 0x5C, 0xBD, 0x7B, 0x8D, 0x79, + 0x08, 0x49, 0x4D, 0x93, 0x28, 0xA0, 0x04, 0x26, 0x37, 0x18, 0x6A, 0x69, + 0x0A, 0x23, 0x04, 0x43, 0xF0, 0x9B, 0xA2, 0x55, 0xED, 0x70, 0x18, 0xFF, + 0xFA, 0xAF, 0xFF, 0x46, 0x52, 0x4E, 0x26, 0xA2, 0xF2, 0xB3, 0xAF, 0x3F, + 0x20, 0xDA, 0x65, 0x5E, 0xEE, 0xEE, 0xEF, 0xC7, 0x61, 0x37, 0x0D, 0x61, + 0x1A, 0x07, 0x04, 0x41, 0x10, 0xAF, 0x6C, 0x35, 0xAF, 0x19, 0x10, 0x41, + 0xE0, 0xD3, 0x0F, 0xCF, 0x4F, 0x4F, 0xA7, 0xFF, 0xE5, 0x5F, 0xFE, 0xD3, + 0xBB, 0xE3, 0x31, 0xE7, 0x8C, 0x08, 0x9E, 0xD2, 0x56, 0xAD, 0xC3, 0xCA, + 0xAB, 0xD7, 0xD2, 0xDB, 0xB1, 0x85, 0x09, 0x03, 0x85, 0x92, 0x46, 0x5F, + 0x45, 0xBE, 0x07, 0xA4, 0x02, 0x76, 0xEE, 0x76, 0x28, 0x59, 0xD1, 0x85, + 0x67, 0x3A, 0x4C, 0xB9, 0x82, 0x18, 0x76, 0xD3, 0x1F, 0xA0, 0x5E, 0xB4, + 0xD7, 0x8E, 0xF6, 0x0A, 0x98, 0xE2, 0x66, 0xB8, 0x22, 0x20, 0x02, 0x2A, + 0x1A, 0x60, 0xF1, 0x38, 0xB5, 0x76, 0x6E, 0xB4, 0xB0, 0xD7, 0x6E, 0x9C, + 0x0A, 0x73, 0x6E, 0x59, 0xC1, 0x66, 0x39, 0x03, 0x6C, 0x75, 0xDD, 0xBB, + 0x46, 0xEC, 0x3A, 0xCB, 0xA7, 0x5B, 0x07, 0x8F, 0x7B, 0x29, 0xF6, 0x6C, + 0x08, 0x61, 0xF0, 0xEB, 0x85, 0x10, 0x11, 0x81, 0x18, 0x87, 0x21, 0x10, + 0xA1, 0x7B, 0x95, 0x62, 0x64, 0x04, 0x58, 0x56, 0x6D, 0x3A, 0xB8, 0xBB, + 0x23, 0xE8, 0x55, 0xA8, 0x8D, 0x8F, 0x99, 0x88, 0x10, 0xA1, 0x7A, 0xC0, + 0xC0, 0xA5, 0x85, 0xD6, 0x04, 0x35, 0x33, 0xCD, 0x52, 0xEC, 0x64, 0xF5, + 0x50, 0x7E, 0x93, 0x36, 0xA8, 0x36, 0x47, 0x00, 0x68, 0xC1, 0xA3, 0x6D, + 0xE3, 0x00, 0xAC, 0xE6, 0xA8, 0x77, 0x11, 0x24, 0xCC, 0x61, 0x08, 0x7E, + 0x70, 0x89, 0xCE, 0xEA, 0x39, 0x4B, 0xCA, 0x12, 0x03, 0x23, 0x92, 0x8A, + 0x99, 0xA9, 0xA8, 0xE5, 0x2C, 0xAA, 0x8A, 0x84, 0x21, 0xD0, 0x38, 0xC6, + 0x18, 0xD9, 0x15, 0xA1, 0xAD, 0xBF, 0xEB, 0x55, 0xEE, 0x77, 0xE5, 0x66, + 0xD7, 0x1D, 0x25, 0xD7, 0x35, 0xA9, 0x99, 0x1B, 0x83, 0x50, 0x15, 0x1F, + 0x2E, 0x57, 0xD7, 0x11, 0x22, 0x84, 0x40, 0xCC, 0x94, 0x45, 0x55, 0x8C, + 0x88, 0xA6, 0x29, 0x56, 0xCF, 0x20, 0x22, 0xE2, 0x6E, 0x37, 0xF6, 0x52, + 0xCB, 0x1F, 0x22, 0x24, 0x2A, 0x27, 0x59, 0x81, 0xF9, 0xCB, 0x0F, 0xB8, + 0x9F, 0x86, 0x25, 0xE5, 0x1F, 0x9E, 0x2F, 0xDF, 0x7E, 0x3E, 0xAF, 0x59, + 0xA6, 0x21, 0xEC, 0x86, 0xF0, 0x32, 0x27, 0xBF, 0xBD, 0x6D, 0x8A, 0xEC, + 0x94, 0xE0, 0x46, 0xAE, 0xAA, 0xAD, 0x59, 0x5F, 0x2E, 0x8B, 0xB7, 0x20, + 0xAA, 0xE0, 0x57, 0x67, 0x16, 0x92, 0xF4, 0xCB, 0x7A, 0xDA, 0x1D, 0x9D, + 0xE5, 0xA4, 0xD4, 0xCC, 0xC4, 0xC5, 0x6A, 0xB6, 0x25, 0xE5, 0x65, 0x0D, + 0x81, 0xED, 0xB8, 0x1F, 0xC1, 0x40, 0xD7, 0x4C, 0x84, 0x49, 0x0C, 0x00, + 0x99, 0xF0, 0x30, 0xC5, 0x0F, 0xF7, 0x7B, 0x2F, 0xD9, 0x38, 0x0D, 0x51, + 0xC5, 0x2E, 0x4B, 0x42, 0x84, 0xE7, 0xF3, 0x0C, 0x80, 0xA2, 0x10, 0x39, + 0xA4, 0x24, 0x29, 0x79, 0x74, 0x08, 0x7B, 0x6C, 0x84, 0x07, 0xDF, 0x13, + 0xC2, 0xFB, 0xE3, 0xEE, 0xC3, 0xC3, 0x7E, 0x4D, 0x32, 0x0C, 0x4C, 0x44, + 0xDF, 0x7F, 0x7E, 0x11, 0xD5, 0x2C, 0x9A, 0x92, 0xC4, 0x58, 0xDC, 0xC3, + 0x8D, 0x76, 0x99, 0x69, 0x5E, 0xD6, 0x79, 0x49, 0xF7, 0xC7, 0x9D, 0x64, + 0x5F, 0x7F, 0x03, 0xB0, 0x61, 0x88, 0x5F, 0x8C, 0x83, 0xBF, 0x96, 0xB3, + 0x8C, 0x63, 0xA0, 0x7A, 0x46, 0x96, 0x73, 0x06, 0xB0, 0x2C, 0x32, 0xC4, + 0x70, 0x77, 0x9C, 0x98, 0xE9, 0xE5, 0xB4, 0xBC, 0x9C, 0x97, 0x18, 0x78, + 0x08, 0xCC, 0x84, 0xD6, 0xD5, 0x41, 0xF4, 0x12, 0x26, 0x2F, 0xE7, 0x79, + 0x4D, 0xE2, 0x27, 0xBF, 0xDE, 0x26, 0x22, 0xC4, 0x10, 0x54, 0xD5, 0x80, + 0x52, 0xCE, 0x59, 0x8C, 0x99, 0x45, 0xD4, 0x53, 0xD0, 0xCE, 0x75, 0x6D, + 0x63, 0xE0, 0x21, 0xFA, 0x05, 0x87, 0x08, 0x02, 0xCC, 0xFC, 0xC7, 0x3F, + 0x7D, 0xF7, 0x9B, 0xDF, 0xFE, 0xF1, 0xAB, 0xF7, 0xF7, 0xFF, 0xFF, 0xDF, + 0xFD, 0xE1, 0xCF, 0x7F, 0xF9, 0xF5, 0x71, 0x37, 0x7D, 0xF7, 0xE9, 0x05, + 0x89, 0x43, 0xE0, 0x87, 0xFB, 0xE3, 0xDD, 0x61, 0x42, 0x30, 0x42, 0x3C, + 0x9F, 0x66, 0x2D, 0xF5, 0x8F, 0x0B, 0xB7, 0xC6, 0x18, 0xB3, 0xC8, 0xAF, + 0x7E, 0xFD, 0xBB, 0xFF, 0xF1, 0x9F, 0xFE, 0xE3, 0xCA, 0xC9, 0x56, 0x63, + 0x90, 0xAC, 0x53, 0xC8, 0x3A, 0x8B, 0x01, 0xBD, 0xCC, 0x3C, 0x11, 0x51, + 0x43, 0x31, 0xD7, 0x1C, 0x9C, 0x3F, 0xFC, 0x14, 0x9F, 0x90, 0x7A, 0x0F, + 0x4D, 0x71, 0x13, 0xAB, 0x5F, 0x3D, 0x70, 0x93, 0xE9, 0x59, 0xE8, 0x1D, + 0x8A, 0x51, 0xDB, 0x13, 0xFC, 0xF6, 0x6B, 0x65, 0xE2, 0x96, 0x4F, 0x80, + 0xC4, 0xED, 0x6E, 0x5D, 0x28, 0x46, 0xE6, 0xAD, 0xC7, 0xEB, 0xEA, 0xDC, + 0x13, 0x36, 0x14, 0xF3, 0xD3, 0x52, 0x30, 0xB3, 0x7A, 0x1B, 0xAD, 0xBF, + 0x6D, 0x57, 0xB7, 0xEC, 0xDE, 0xAA, 0x95, 0xAF, 0x1A, 0x27, 0x40, 0x2C, + 0xA5, 0x2B, 0x7B, 0xCC, 0xB4, 0x7A, 0x87, 0x98, 0xFA, 0x7D, 0xB7, 0x35, + 0x21, 0xDF, 0x1F, 0x57, 0x29, 0x42, 0xF5, 0xF4, 0x5B, 0xF7, 0x54, 0x10, + 0x04, 0xC4, 0x37, 0x00, 0xB4, 0x9E, 0xCF, 0x94, 0x10, 0x0A, 0xC5, 0x16, + 0x1D, 0x52, 0x1E, 0x22, 0xAA, 0xB6, 0x3B, 0xD6, 0xC9, 0x9A, 0x01, 0xFA, + 0xAB, 0x35, 0xE2, 0x8A, 0xDA, 0x84, 0xDB, 0x88, 0x09, 0x31, 0x7C, 0xFC, + 0x70, 0x87, 0x08, 0xEB, 0x9A, 0x2F, 0xF3, 0x5A, 0xE5, 0x18, 0x21, 0x60, + 0x4A, 0x69, 0x59, 0xD2, 0x65, 0x4D, 0x08, 0x38, 0x8D, 0xB1, 0xA9, 0x70, + 0x6E, 0x7A, 0x10, 0x5D, 0xD5, 0xC6, 0x7B, 0x73, 0xD5, 0x7A, 0x55, 0xB6, + 0x47, 0x34, 0x66, 0x0C, 0x91, 0xE7, 0x39, 0x65, 0xD1, 0xC7, 0x97, 0x8B, + 0x9A, 0x21, 0x20, 0x13, 0xEE, 0xC6, 0x38, 0x4D, 0x03, 0x13, 0x7A, 0x85, + 0x6F, 0x00, 0x8B, 0x81, 0x62, 0x18, 0xDA, 0xAC, 0xDA, 0xFD, 0x11, 0xAD, + 0xDF, 0x5E, 0x82, 0x59, 0xBD, 0xEC, 0xA0, 0x2C, 0x74, 0x08, 0xC7, 0x03, + 0x8E, 0x39, 0x8C, 0x91, 0xF7, 0x63, 0xFC, 0xE6, 0xF3, 0x29, 0x8B, 0x7E, + 0xF9, 0x6E, 0x4F, 0x4F, 0x97, 0xF3, 0x92, 0x93, 0x1F, 0x25, 0x5B, 0x69, + 0xF0, 0xB2, 0xE4, 0x97, 0x39, 0xA9, 0x9A, 0xC7, 0x6E, 0x72, 0x6B, 0x1C, + 0xAB, 0x33, 0x1F, 0x4B, 0xAA, 0x84, 0x1F, 0x1E, 0x88, 0x0B, 0xDE, 0x72, + 0x04, 0x01, 0x0A, 0x10, 0xD8, 0x53, 0x47, 0xC9, 0xC3, 0x6E, 0x10, 0x3C, + 0x49, 0x01, 0x01, 0xF4, 0x30, 0x05, 0x46, 0x98, 0x86, 0x30, 0xC4, 0x30, + 0x4D, 0x71, 0x59, 0xF3, 0xE9, 0xB2, 0x64, 0x11, 0x22, 0x3C, 0xCF, 0x49, + 0x54, 0x87, 0x18, 0x3C, 0xCA, 0xDF, 0x6B, 0x01, 0xCD, 0x4B, 0x5E, 0x53, + 0x1E, 0x87, 0x90, 0xB2, 0x0E, 0x91, 0x5D, 0x27, 0x72, 0x99, 0x34, 0x46, + 0x1E, 0xC7, 0x18, 0x98, 0x87, 0x2F, 0x1F, 0x56, 0xD7, 0x4A, 0xCA, 0xE8, + 0xAE, 0x96, 0x5D, 0x44, 0x5E, 0xCE, 0xCB, 0xF3, 0x69, 0xB9, 0x2C, 0xD9, + 0x4B, 0x3C, 0xC4, 0xC0, 0xFB, 0x69, 0x18, 0x47, 0x8C, 0x31, 0x20, 0x92, + 0x9A, 0x86, 0x00, 0x35, 0x58, 0x1F, 0x96, 0x79, 0x75, 0xD7, 0xD2, 0x71, + 0x37, 0xC5, 0x81, 0x89, 0x28, 0xE7, 0x7C, 0x99, 0xD3, 0xB2, 0xE6, 0xAC, + 0x32, 0xC6, 0x80, 0x88, 0xF3, 0x92, 0xFC, 0x14, 0x72, 0x1C, 0x82, 0x19, + 0x88, 0x9A, 0xA8, 0x2D, 0xAB, 0x88, 0x9A, 0xCF, 0x1D, 0xCB, 0x21, 0x5D, + 0x71, 0x23, 0x2C, 0x6B, 0x26, 0x84, 0x21, 0x84, 0x25, 0xE5, 0x24, 0x12, + 0x98, 0x44, 0xF5, 0x3C, 0x67, 0x26, 0x1C, 0x23, 0xA7, 0x1C, 0x62, 0x70, + 0x59, 0x28, 0xD3, 0x34, 0xFC, 0xE1, 0x0F, 0x7F, 0xCA, 0x49, 0x3E, 0x3D, + 0x9F, 0x8E, 0x87, 0x09, 0x11, 0x9F, 0xCE, 0xF3, 0x9F, 0xBE, 0x7F, 0xDC, + 0xED, 0xA6, 0xC3, 0x6E, 0x22, 0x66, 0x62, 0x9E, 0x22, 0xA7, 0x94, 0x55, + 0x35, 0x46, 0x4E, 0x97, 0x25, 0x84, 0xC0, 0xC4, 0xBE, 0xD0, 0x88, 0xF8, + 0xEB, 0xDF, 0xFC, 0xE9, 0x27, 0x5F, 0x7F, 0xFC, 0xE2, 0xE3, 0x07, 0x3F, + 0xD6, 0x80, 0x4E, 0xF9, 0x29, 0x6C, 0x59, 0xB6, 0xCB, 0x29, 0x84, 0x02, + 0x73, 0x8B, 0x38, 0x75, 0x65, 0x01, 0x4A, 0xCC, 0xBF, 0x9A, 0x1A, 0x81, + 0x9B, 0x26, 0xB6, 0x1D, 0x5E, 0x6E, 0xF9, 0x46, 0xE2, 0xAC, 0x04, 0x57, + 0x68, 0xD5, 0x63, 0x03, 0xFE, 0xD8, 0xAF, 0x4E, 0x52, 0x25, 0xDA, 0xA3, + 0xD9, 0xBF, 0x88, 0x56, 0xCA, 0xB5, 0x13, 0x54, 0x06, 0xED, 0x4C, 0xC8, + 0x4D, 0x44, 0xBD, 0xC9, 0x5F, 0x85, 0x8D, 0x01, 0xA4, 0xFB, 0xF8, 0xE6, + 0x05, 0xEC, 0x73, 0x8F, 0xAF, 0x91, 0x11, 0xBB, 0x07, 0xC0, 0x72, 0xCE, + 0x4C, 0xCC, 0x25, 0x2A, 0x4A, 0x3D, 0x1C, 0xA3, 0x59, 0x69, 0xBE, 0x1A, + 0x8C, 0x68, 0x58, 0x2E, 0x60, 0xAC, 0x42, 0xFD, 0x8A, 0xBB, 0x01, 0xD1, + 0xCC, 0x23, 0x2A, 0x10, 0x19, 0x98, 0xB7, 0xC8, 0x61, 0x37, 0x39, 0x89, + 0xA9, 0x89, 0x9A, 0x2D, 0x0E, 0x0C, 0xB6, 0x29, 0xDF, 0x3E, 0x7E, 0xF3, + 0x56, 0x47, 0xDB, 0xCE, 0x75, 0x54, 0x4E, 0x52, 0xCA, 0xB7, 0xC2, 0x65, + 0x5E, 0x87, 0xC0, 0xCB, 0x9A, 0x3E, 0x3F, 0x5F, 0xFC, 0xE2, 0x48, 0xD7, + 0x1E, 0x93, 0x88, 0x88, 0x82, 0xC1, 0x34, 0x06, 0x3F, 0x9E, 0xD8, 0x4D, + 0x43, 0x8C, 0xE5, 0x16, 0x81, 0x37, 0xBA, 0x7B, 0x65, 0xCC, 0x43, 0x35, + 0x24, 0xEB, 0x36, 0x94, 0x6D, 0x55, 0x35, 0x0F, 0x1A, 0x4C, 0xA2, 0x84, + 0x94, 0x72, 0xF6, 0xE8, 0x50, 0x00, 0x24, 0xA6, 0x10, 0xC8, 0xCC, 0x52, + 0xCA, 0x5B, 0x42, 0xE9, 0x8F, 0x84, 0x08, 0xDD, 0xF4, 0x6B, 0x66, 0x5E, + 0x96, 0x2E, 0xAD, 0x19, 0x10, 0x3C, 0xE5, 0x22, 0x86, 0xE0, 0xF2, 0xE6, + 0xDD, 0x71, 0xF7, 0xF9, 0xE5, 0xB2, 0x1B, 0xE3, 0x71, 0x3F, 0x7C, 0x7A, + 0x3A, 0xFF, 0xF0, 0xBC, 0x10, 0x61, 0x56, 0x45, 0x65, 0x00, 0xBB, 0xAC, + 0x19, 0xAC, 0xC4, 0xA9, 0xD5, 0x92, 0x38, 0x1B, 0x48, 0xD7, 0xDE, 0x41, + 0x51, 0xD7, 0xE4, 0x76, 0xC6, 0x95, 0xC7, 0x17, 0x3D, 0x46, 0x4C, 0xED, + 0xF1, 0x34, 0xA7, 0x2C, 0x4F, 0xE7, 0xE5, 0xEB, 0xF7, 0xC7, 0xFB, 0xE3, + 0xEE, 0xB2, 0xAC, 0x00, 0x91, 0x10, 0xA7, 0x18, 0xC6, 0x21, 0xB8, 0xCB, + 0x3C, 0x30, 0x05, 0x66, 0x35, 0xB8, 0xAC, 0x79, 0x37, 0x84, 0xF3, 0x92, + 0x4F, 0xF3, 0x7A, 0xB7, 0x1B, 0x03, 0xB3, 0xA8, 0x39, 0xB6, 0x9C, 0xE6, + 0x75, 0xCD, 0xB2, 0x1B, 0xE3, 0xC7, 0x87, 0xBD, 0x99, 0xFD, 0xF1, 0xFB, + 0x67, 0x97, 0x57, 0x7E, 0xB6, 0xE6, 0x11, 0x09, 0xE3, 0xB8, 0xE5, 0x48, + 0xB4, 0x15, 0xF0, 0x05, 0x9F, 0x97, 0x9C, 0xB3, 0x4E, 0x63, 0x5C, 0xD6, + 0x34, 0xC6, 0x00, 0x88, 0xBA, 0xA6, 0xC0, 0x14, 0x63, 0x31, 0xCF, 0x19, + 0x6B, 0x0C, 0xB7, 0x6F, 0xD0, 0x18, 0x9D, 0xC9, 0x87, 0x48, 0x00, 0xF0, + 0xF4, 0x7C, 0x46, 0xC4, 0xCB, 0x9C, 0x9E, 0xCF, 0x0B, 0x31, 0x0D, 0x51, + 0xC6, 0xC0, 0x00, 0x30, 0xCF, 0xAB, 0x07, 0xF7, 0x1A, 0x60, 0xCE, 0xD9, + 0xD4, 0x88, 0x9B, 0x12, 0xED, 0xF8, 0x85, 0x84, 0xB8, 0x8A, 0x02, 0x80, + 0x5F, 0xFE, 0x40, 0x84, 0x48, 0xC1, 0x15, 0x69, 0x03, 0x1C, 0x07, 0x1B, + 0x82, 0x07, 0xC1, 0x09, 0xB3, 0x9F, 0x66, 0x20, 0x33, 0xBD, 0xBB, 0xDF, + 0xAF, 0x29, 0x5D, 0x96, 0x35, 0x04, 0x7A, 0xFF, 0x70, 0xB7, 0x9F, 0xA6, + 0x0F, 0xEF, 0xEE, 0x63, 0x8C, 0xD3, 0x6E, 0x1C, 0x86, 0xB8, 0x9B, 0x06, + 0x22, 0x10, 0xD1, 0xDD, 0x34, 0x10, 0xE3, 0x30, 0x0E, 0xA7, 0xD3, 0x05, + 0x01, 0x2D, 0x86, 0x94, 0x73, 0x0C, 0x71, 0x59, 0xD3, 0xE5, 0xB2, 0x94, + 0xB2, 0xC8, 0x9D, 0x8B, 0x0B, 0x11, 0x81, 0x0C, 0x3C, 0xE5, 0xDA, 0x40, + 0xC5, 0xAA, 0xC7, 0x93, 0x90, 0xB7, 0x4C, 0x9A, 0x9A, 0x07, 0xE3, 0xA1, + 0x09, 0x4D, 0x35, 0xC0, 0x5E, 0x9B, 0x80, 0x76, 0xEA, 0xD5, 0x99, 0x1D, + 0xFF, 0xB0, 0xBE, 0xD3, 0xB3, 0xC3, 0xA6, 0x49, 0xC1, 0x2D, 0xFC, 0x21, + 0x80, 0x55, 0x42, 0x03, 0xC7, 0xBA, 0x6B, 0x2D, 0xAC, 0x62, 0xE8, 0x55, + 0x8C, 0x67, 0x8D, 0x12, 0x69, 0x6F, 0x14, 0xF3, 0xCB, 0xB6, 0x1C, 0xA2, + 0xDB, 0xB1, 0x95, 0xD6, 0xBB, 0x94, 0xBE, 0x0E, 0xCE, 0x4A, 0x88, 0xB0, + 0x99, 0xB9, 0x55, 0x23, 0x62, 0x88, 0xD2, 0x22, 0xDA, 0x54, 0xF5, 0xE6, + 0x9E, 0x76, 0x31, 0xAF, 0x00, 0xB9, 0x9D, 0x08, 0x97, 0x1E, 0x15, 0x88, + 0xA8, 0xD8, 0xCF, 0x84, 0x00, 0xE0, 0x17, 0xC1, 0x79, 0x54, 0x85, 0x98, + 0x20, 0x20, 0x0E, 0x7E, 0xB9, 0xC1, 0xE6, 0xB9, 0x73, 0xCC, 0x69, 0x90, + 0x57, 0xD7, 0xBD, 0x14, 0xE7, 0x68, 0x33, 0xDD, 0x10, 0xD3, 0x75, 0x33, + 0x02, 0x3F, 0xE7, 0x51, 0xD5, 0xF0, 0xED, 0xA7, 0x67, 0x77, 0x75, 0x3F, + 0x9D, 0x16, 0xAB, 0xC7, 0x4C, 0x6E, 0xDF, 0x22, 0xE2, 0xC0, 0x8C, 0x08, + 0xA2, 0xBA, 0x9F, 0xC6, 0xB1, 0x5E, 0x3D, 0xD9, 0x1D, 0xBD, 0x77, 0x9D, + 0x5E, 0x03, 0xF3, 0x26, 0x2E, 0xB6, 0x24, 0x2C, 0xD0, 0x52, 0xD6, 0x46, + 0x9C, 0x6D, 0xCE, 0x97, 0x25, 0x67, 0xF7, 0x1F, 0x41, 0x16, 0x7D, 0x4A, + 0xB3, 0xA3, 0xA7, 0xFB, 0x89, 0x43, 0xF0, 0xFC, 0x19, 0x77, 0x43, 0x7A, + 0xEE, 0xEE, 0x95, 0xD7, 0xA0, 0xDF, 0x0C, 0x27, 0xBE, 0x10, 0xC0, 0xCC, + 0x72, 0x96, 0xE7, 0x97, 0xCB, 0xB2, 0x9E, 0xA6, 0x71, 0x18, 0x86, 0x60, + 0x6A, 0xA7, 0xCB, 0x6A, 0x06, 0xC7, 0xDD, 0xF0, 0x72, 0x59, 0xBE, 0x7F, + 0x9A, 0x5F, 0x2E, 0xAB, 0xA8, 0x79, 0x1C, 0x59, 0xCC, 0x4A, 0x88, 0x6B, + 0x2E, 0x70, 0xDB, 0x66, 0x85, 0x35, 0x08, 0xE9, 0x7A, 0x8A, 0x20, 0xDB, + 0x81, 0x98, 0x75, 0xAE, 0x61, 0xBC, 0x2C, 0x79, 0x5E, 0x65, 0x8C, 0x6C, + 0x66, 0xCB, 0x9A, 0xE7, 0x35, 0x79, 0x38, 0xC8, 0x34, 0xC6, 0x9C, 0xC5, + 0xEF, 0xFD, 0x66, 0x2F, 0x81, 0x1F, 0xF8, 0xB0, 0x1F, 0x7D, 0xD7, 0xF6, + 0x63, 0x34, 0x80, 0x79, 0x4D, 0x97, 0x35, 0x47, 0x26, 0x55, 0x20, 0xB2, + 0xFD, 0x2E, 0x9E, 0x97, 0xB4, 0xA6, 0xCC, 0x44, 0x31, 0xF2, 0xBC, 0xA4, + 0x69, 0x08, 0x87, 0x9D, 0x7B, 0x30, 0x7C, 0x0D, 0xCB, 0xDD, 0xDD, 0xBD, + 0xA0, 0x76, 0x3B, 0x37, 0xE7, 0xEC, 0xCB, 0xEB, 0x81, 0xC4, 0x38, 0xC4, + 0xC3, 0x6E, 0x40, 0x80, 0x10, 0x18, 0x09, 0x89, 0xAF, 0x8E, 0xFF, 0xDB, + 0x62, 0xBA, 0xCD, 0x1E, 0x07, 0x56, 0x91, 0xC7, 0xA7, 0xF3, 0x79, 0x5E, + 0x45, 0xF5, 0xE5, 0x9C, 0x10, 0x31, 0x25, 0x41, 0x80, 0xE3, 0x34, 0x04, + 0xA6, 0x94, 0x32, 0x18, 0x5C, 0xE6, 0xD5, 0x31, 0xD7, 0xFD, 0x6E, 0x46, + 0xE0, 0x71, 0x70, 0x25, 0xE2, 0xCC, 0x00, 0x0C, 0xD6, 0x2C, 0xD1, 0x0D, + 0x52, 0xAF, 0x63, 0x0E, 0xA5, 0xB6, 0x72, 0x2E, 0xD7, 0xB5, 0x02, 0xF8, + 0x0D, 0x29, 0x88, 0xCC, 0x94, 0xD3, 0xFA, 0x5F, 0xFE, 0xF6, 0xB7, 0xC4, + 0xFC, 0xF3, 0x3F, 0xFB, 0xE2, 0xE1, 0xEE, 0xF0, 0xF1, 0xFD, 0x91, 0x38, + 0x7C, 0xFD, 0xE5, 0x87, 0x87, 0x87, 0x43, 0x88, 0xE1, 0x72, 0x99, 0xC1, + 0xEF, 0x91, 0xD8, 0x8F, 0xCB, 0x9A, 0x52, 0x36, 0x0F, 0x64, 0xFD, 0xFC, + 0xF4, 0xB4, 0xDB, 0xEF, 0x86, 0x71, 0xF8, 0xF4, 0xE9, 0x31, 0x8B, 0x7D, + 0x7E, 0x7C, 0xF9, 0xE5, 0x2F, 0x8A, 0xDB, 0xE5, 0x95, 0xF3, 0xDB, 0x6A, + 0x00, 0x44, 0x27, 0x7D, 0xFE, 0x2B, 0x67, 0x6F, 0xD2, 0x63, 0x49, 0x92, + 0xA4, 0x89, 0x89, 0x88, 0xAA, 0x9A, 0xD9, 0x5B, 0x7D, 0x89, 0x25, 0x23, + 0x97, 0xC8, 0xAA, 0xEC, 0xDA, 0xBA, 0xBA, 0xD1, 0x8D, 0x1E, 0x0E, 0x38, + 0xC3, 0x03, 0x81, 0x41, 0x1F, 0xF9, 0x23, 0x88, 0x39, 0x10, 0x73, 0xE2, + 0xFC, 0x3D, 0x5E, 0x78, 0x22, 0x88, 0x26, 0x06, 0x43, 0x0E, 0x7A, 0xAB, + 0xAA, 0xAC, 0xCC, 0xCA, 0xCA, 0x25, 0x22, 0x63, 0x0F, 0x5F, 0xDE, 0x6E, + 0x66, 0xBA, 0x88, 0xF0, 0x20, 0xAA, 0xF6, 0xCC, 0x9F, 0x47, 0x15, 0x01, + 0xBE, 0x2A, 0x44, 0xBA, 0x3F, 0xB7, 0x55, 0x55, 0x54, 0xF4, 0x93, 0xED, + 0x93, 0xE2, 0x82, 0x11, 0x39, 0x96, 0x31, 0x97, 0xAC, 0x20, 0x11, 0xF1, + 0xD6, 0x14, 0x86, 0xE6, 0x6C, 0x6A, 0x0D, 0xD2, 0x70, 0x77, 0xB1, 0xFD, + 0xE9, 0xCF, 0x58, 0x78, 0x4E, 0x64, 0x35, 0x5F, 0x74, 0x20, 0x2F, 0xCC, + 0x24, 0x8C, 0x47, 0x9D, 0x40, 0x77, 0xD9, 0x8D, 0x00, 0xB2, 0x8F, 0x78, + 0xA4, 0xCE, 0x78, 0x78, 0x9F, 0x41, 0x14, 0x0B, 0x6E, 0x3A, 0xD5, 0x62, + 0x98, 0xC9, 0x64, 0x90, 0xEE, 0xCE, 0xFE, 0xF0, 0x88, 0x08, 0xA5, 0x6B, + 0x3D, 0x62, 0x8A, 0xA2, 0x00, 0x11, 0x73, 0x46, 0x0A, 0xB0, 0x48, 0x0C, + 0x29, 0xC4, 0x98, 0x8E, 0x94, 0x01, 0xA8, 0xE5, 0xFE, 0x88, 0x68, 0xEE, + 0xB9, 0x92, 0x58, 0x29, 0xFC, 0x0D, 0x0A, 0x0B, 0x13, 0x33, 0x03, 0xAB, + 0x5B, 0x8B, 0x11, 0x40, 0x90, 0x44, 0x12, 0x03, 0xD1, 0x10, 0xA2, 0x84, + 0x82, 0x78, 0x8E, 0x53, 0x36, 0x18, 0xB9, 0x77, 0xB3, 0xDF, 0x55, 0x90, + 0x94, 0x18, 0x4A, 0xCF, 0x1C, 0x54, 0x9F, 0xDD, 0xB5, 0x3E, 0xED, 0x8F, + 0x10, 0x0F, 0x01, 0x34, 0xC2, 0xA5, 0x9C, 0x7F, 0x95, 0x33, 0xCE, 0xDA, + 0xCA, 0xA9, 0x6E, 0xC1, 0x72, 0xEE, 0x1D, 0x50, 0x3A, 0xD6, 0xA3, 0xA3, + 0x5D, 0xEE, 0x8E, 0x5E, 0x43, 0x44, 0x29, 0xCD, 0xDF, 0xAA, 0xCA, 0x6A, + 0xC2, 0x07, 0x91, 0xB2, 0xB9, 0xA8, 0x59, 0x2F, 0x21, 0x26, 0x1F, 0xD2, + 0xBE, 0x0B, 0xCE, 0xE4, 0x96, 0x4E, 0xD3, 0xC6, 0xA9, 0x3F, 0x5B, 0x8B, + 0xB3, 0x0C, 0x19, 0x24, 0x41, 0xFC, 0x80, 0x75, 0x39, 0x16, 0x11, 0x63, + 0x0C, 0x19, 0xDA, 0x6E, 0x0F, 0x9B, 0x5D, 0x17, 0x36, 0x0C, 0x22, 0x3E, + 0xB1, 0x08, 0x74, 0xDE, 0x1C, 0xBA, 0xE0, 0x43, 0xAC, 0x9C, 0x71, 0x56, + 0xD5, 0x54, 0x6C, 0xFB, 0x58, 0xC6, 0x29, 0x6F, 0x2F, 0xE3, 0x09, 0x1E, + 0x3D, 0x3F, 0x64, 0xB2, 0xAB, 0x11, 0x62, 0x27, 0x3C, 0x76, 0x8D, 0x8B, + 0x0C, 0x84, 0xE2, 0x23, 0x80, 0x80, 0x21, 0x3C, 0x74, 0xC1, 0x59, 0x53, + 0x3B, 0xCB, 0x9C, 0x87, 0xA6, 0xAE, 0x9D, 0x0E, 0x09, 0x11, 0x59, 0x4B, + 0x67, 0x8B, 0xA9, 0xB3, 0xC6, 0x87, 0xD8, 0xFA, 0xA8, 0xFA, 0x82, 0x27, + 0x72, 0x31, 0x9F, 0x88, 0x48, 0x76, 0x3C, 0x11, 0x3A, 0x43, 0x29, 0x72, + 0x5D, 0xB9, 0xB3, 0x05, 0xCE, 0x26, 0xB5, 0x88, 0x30, 0x83, 0x31, 0x26, + 0x84, 0xD8, 0xF0, 0x40, 0x75, 0x8A, 0x00, 0x00, 0x20, 0x00, 0x49, 0x44, + 0x41, 0x54, 0x7B, 0xDF, 0xD4, 0xCE, 0x14, 0xCA, 0x1A, 0x50, 0xBA, 0x74, + 0xE6, 0xDE, 0xC7, 0xED, 0xBE, 0xAB, 0x9C, 0x3D, 0x9B, 0x4F, 0x00, 0xD1, + 0xFB, 0x90, 0x58, 0x0C, 0xA1, 0x73, 0x56, 0x7D, 0xB7, 0x27, 0x3B, 0xD0, + 0x30, 0x47, 0xA8, 0xF9, 0x07, 0x44, 0x4D, 0xED, 0x42, 0x4C, 0xB1, 0xE7, + 0xDA, 0x19, 0x40, 0x30, 0x89, 0x34, 0xE8, 0x31, 0x6C, 0x30, 0x5A, 0xDB, + 0x80, 0x5A, 0x5D, 0xA8, 0xA9, 0x92, 0x02, 0x0C, 0x62, 0x0A, 0x56, 0xB0, + 0xD6, 0x48, 0xF6, 0x54, 0xA1, 0xC2, 0x1A, 0x63, 0xA8, 0xAE, 0xAC, 0xA6, + 0xF8, 0x77, 0x3E, 0x36, 0x95, 0xB5, 0xD6, 0xA8, 0xD6, 0xB0, 0xD6, 0xC6, + 0xD8, 0xA7, 0x18, 0x7F, 0xFD, 0x8B, 0x9F, 0x4C, 0x26, 0xD5, 0x72, 0x3E, + 0x4D, 0x2C, 0xCB, 0xC5, 0xDC, 0x5A, 0xE3, 0x9C, 0xF1, 0xDE, 0xC7, 0x10, + 0xC8, 0x18, 0x67, 0xED, 0x61, 0xDF, 0xEE, 0xF7, 0xAD, 0x20, 0xD6, 0x75, + 0xD5, 0xC7, 0xD0, 0xF6, 0x7D, 0xDB, 0xF5, 0xD6, 0xDA, 0x5D, 0xDB, 0x27, + 0x96, 0xEB, 0xDB, 0x2D, 0xB3, 0xF6, 0xB9, 0x85, 0xC1, 0x1B, 0x5D, 0x16, + 0xA9, 0x2E, 0xD3, 0x1C, 0x72, 0x1C, 0xD6, 0x9B, 0xBE, 0x75, 0x36, 0x5B, + 0x04, 0x86, 0x4C, 0x08, 0x25, 0x46, 0x00, 0x88, 0x54, 0x08, 0x1D, 0x75, + 0xD4, 0x28, 0xA7, 0xF3, 0xDE, 0x71, 0x57, 0xC1, 0xFF, 0xDF, 0x8F, 0x1C, + 0xAB, 0x44, 0x8F, 0x9F, 0xF2, 0x0D, 0x96, 0x0A, 0x02, 0x18, 0x9E, 0x73, + 0x58, 0x59, 0xC3, 0xDE, 0x93, 0xD2, 0xC8, 0x8C, 0xC4, 0xF2, 0xA4, 0x04, + 0xF7, 0x70, 0x9F, 0x0C, 0xE5, 0x97, 0x05, 0x25, 0x15, 0x91, 0x2E, 0xE5, + 0x5D, 0x00, 0xA3, 0xFD, 0x39, 0x1B, 0xDA, 0x20, 0x49, 0x95, 0x3B, 0x8B, + 0x48, 0x0C, 0x31, 0xA6, 0x04, 0xDA, 0x24, 0x21, 0x33, 0x4A, 0x65, 0xF2, + 0x5B, 0x16, 0x1E, 0xE7, 0xC7, 0xA9, 0x94, 0x12, 0x11, 0x31, 0x31, 0x28, + 0xA1, 0x8F, 0x0C, 0x20, 0x41, 0x1F, 0x3E, 0x71, 0x69, 0x08, 0x3C, 0xD2, + 0x1B, 0x22, 0x52, 0x98, 0x3A, 0xB2, 0xF5, 0x86, 0x38, 0x2A, 0x51, 0xCA, + 0x15, 0xB6, 0x80, 0xAC, 0x24, 0x50, 0xB9, 0xAF, 0x5B, 0x7E, 0x7B, 0x40, + 0xEB, 0x43, 0x1A, 0x65, 0xFC, 0xA3, 0x00, 0x7A, 0x1F, 0xA5, 0x2C, 0x54, + 0x16, 0x38, 0x74, 0x21, 0x25, 0xC6, 0x09, 0x86, 0x10, 0x45, 0x34, 0x36, + 0x93, 0x43, 0x8A, 0x58, 0x0C, 0xF8, 0x13, 0x14, 0xA6, 0xFA, 0xAE, 0xA4, + 0xFC, 0xE6, 0x81, 0x23, 0x42, 0xCD, 0x1D, 0x57, 0x31, 0xD1, 0xD6, 0x4D, + 0xCC, 0x61, 0x73, 0xF0, 0x52, 0x50, 0x26, 0x11, 0xC6, 0xC4, 0x9E, 0xB0, + 0x76, 0x56, 0x47, 0x38, 0xC4, 0x24, 0x02, 0xAA, 0xD7, 0x26, 0x4D, 0x5D, + 0x55, 0x16, 0x00, 0x4E, 0x04, 0xE8, 0xFE, 0xE2, 0xB4, 0xC6, 0x5C, 0x9C, + 0xCD, 0x27, 0x4D, 0xFD, 0xF6, 0x6A, 0x7D, 0xB5, 0x3A, 0x44, 0xE6, 0xC8, + 0x62, 0x89, 0x8C, 0xC1, 0x69, 0x53, 0x69, 0x56, 0x4A, 0x1F, 0x52, 0x4C, + 0x3C, 0x72, 0x75, 0x21, 0xA2, 0x0C, 0xB2, 0x7F, 0x57, 0x57, 0x0E, 0x57, + 0xD6, 0x6F, 0x04, 0x11, 0x6A, 0x4B, 0x21, 0x89, 0x21, 0x28, 0xE1, 0x2C, + 0x11, 0x80, 0x3E, 0x32, 0x82, 0x54, 0x40, 0x95, 0xB3, 0xB6, 0xD0, 0x45, + 0xA8, 0xE7, 0x5E, 0xEB, 0x81, 0x10, 0xD1, 0x98, 0xDC, 0xF2, 0xDA, 0x59, + 0xD3, 0xF5, 0x21, 0xC4, 0x34, 0xAD, 0xAD, 0x0F, 0x1C, 0x22, 0xF7, 0x21, + 0xB6, 0x7D, 0xE8, 0x7C, 0x4C, 0x2C, 0x0F, 0xCF, 0xA6, 0xCE, 0x1A, 0xEB, + 0x0C, 0x33, 0x1B, 0xC2, 0xD2, 0x01, 0xEF, 0x88, 0xB9, 0xD4, 0x67, 0x34, + 0xB8, 0xA5, 0x14, 0x09, 0xF6, 0x7D, 0x4C, 0x89, 0x7B, 0x0E, 0xCE, 0x98, + 0xBA, 0x76, 0x4E, 0xCB, 0xE2, 0x41, 0xB2, 0x85, 0x7D, 0xBF, 0xDA, 0x11, + 0x00, 0x00, 0xAC, 0xB5, 0xFA, 0x0D, 0x11, 0x4D, 0x26, 0x95, 0x4E, 0x56, + 0xDB, 0x05, 0x40, 0x40, 0xD0, 0x04, 0x57, 0x8E, 0x88, 0xCA, 0x4D, 0x1C, + 0x23, 0xC7, 0xC4, 0xCE, 0x1A, 0x61, 0xD6, 0xFA, 0x36, 0x2E, 0x9D, 0xAB, + 0x09, 0x73, 0x46, 0xBB, 0xB3, 0x66, 0x0C, 0x9F, 0x95, 0x44, 0x47, 0x84, + 0x26, 0x8D, 0x43, 0x84, 0xBA, 0x72, 0x9D, 0x8F, 0xAA, 0x24, 0x00, 0x05, + 0x89, 0xCE, 0xCF, 0x16, 0x31, 0xA6, 0xBA, 0x72, 0xCC, 0x3C, 0x9F, 0xCF, + 0xE6, 0xF3, 0xC9, 0xB3, 0xE7, 0xAF, 0x74, 0x15, 0x5B, 0xC2, 0xBA, 0xAE, + 0x44, 0x7C, 0x88, 0x0C, 0x48, 0x21, 0xA6, 0x10, 0x0F, 0x5D, 0xE7, 0x91, + 0xEC, 0x66, 0xB3, 0xEB, 0x43, 0x48, 0x89, 0x4D, 0x66, 0xAC, 0x2D, 0x00, + 0xA7, 0xE4, 0x46, 0x1D, 0x69, 0x79, 0x64, 0xE0, 0x0B, 0x2E, 0xCB, 0x49, + 0x7F, 0x2E, 0x16, 0x5F, 0xF6, 0xA7, 0xE4, 0xE0, 0x99, 0x00, 0x90, 0x88, + 0xF2, 0x62, 0x65, 0x46, 0x75, 0x66, 0x26, 0x83, 0xD9, 0x03, 0x84, 0x1F, + 0x26, 0xFB, 0xBE, 0x2F, 0x87, 0xC3, 0x37, 0xA7, 0x20, 0x4E, 0xEE, 0x68, + 0x9A, 0x91, 0x25, 0x90, 0x0D, 0xBD, 0xE1, 0xF0, 0x61, 0x65, 0x0D, 0xB7, + 0x28, 0xC9, 0x78, 0x92, 0x99, 0x28, 0x54, 0xCD, 0xE9, 0xD1, 0x04, 0xBA, + 0xD7, 0x72, 0x1A, 0xDF, 0x30, 0x4B, 0xAC, 0x46, 0x19, 0x34, 0xED, 0x0B, + 0x8A, 0x8D, 0x9C, 0xF5, 0x63, 0x91, 0xF7, 0xE3, 0x63, 0x0B, 0x88, 0x80, + 0x72, 0x1E, 0x30, 0xA7, 0x98, 0x92, 0x70, 0x89, 0x7D, 0x71, 0xF6, 0xD1, + 0xEB, 0x10, 0x0F, 0x86, 0xCC, 0x40, 0x76, 0x8D, 0x08, 0x59, 0xF9, 0xC8, + 0xF8, 0xE1, 0xB3, 0x80, 0x01, 0x40, 0x8A, 0x40, 0x26, 0xC3, 0x52, 0x55, + 0x23, 0x47, 0xAD, 0x96, 0x75, 0xF7, 0xD1, 0xA0, 0xE6, 0x01, 0x3C, 0xE9, + 0xFB, 0x0B, 0x47, 0x06, 0x43, 0xC6, 0x1A, 0x43, 0x48, 0x5A, 0x9C, 0x21, + 0x00, 0x16, 0x71, 0xC8, 0x80, 0xCE, 0x9E, 0x20, 0x45, 0x19, 0xD6, 0x1A, + 0x00, 0x0C, 0x21, 0x22, 0x21, 0x91, 0x05, 0x38, 0x9A, 0xA3, 0xAC, 0x76, + 0x9C, 0x21, 0xAD, 0xB6, 0x39, 0xD9, 0x31, 0xA0, 0x30, 0xB7, 0xE8, 0x6B, + 0x69, 0x75, 0x28, 0x94, 0x5D, 0xA6, 0xF7, 0xD1, 0xFB, 0x18, 0x62, 0xDA, + 0x1C, 0xBA, 0x7D, 0xEB, 0xDB, 0x2E, 0x6A, 0xEA, 0x03, 0x96, 0x4D, 0x53, + 0x63, 0x25, 0x88, 0xA0, 0x69, 0x76, 0xD6, 0x18, 0xF5, 0x85, 0xEB, 0x7E, + 0x32, 0xC6, 0x14, 0x45, 0x7F, 0x9C, 0xE0, 0xBE, 0xA2, 0x55, 0x01, 0x26, + 0x4D, 0xF5, 0xF4, 0x93, 0x07, 0x67, 0xCB, 0xE9, 0xDB, 0xAB, 0xED, 0xD5, + 0xA6, 0xDD, 0xE7, 0x2E, 0x76, 0xBE, 0xE4, 0xCA, 0x01, 0x97, 0x62, 0xF2, + 0x32, 0xD3, 0x23, 0xC9, 0x1A, 0xFD, 0xA2, 0xFB, 0x83, 0x14, 0xD7, 0x22, + 0x20, 0xCC, 0x6A, 0x0B, 0x00, 0xAD, 0x0F, 0x83, 0xBA, 0x53, 0xF1, 0xD3, + 0x74, 0x72, 0x63, 0x68, 0xB5, 0x6D, 0xD7, 0xFB, 0x76, 0x31, 0xA9, 0x97, + 0xB3, 0x7A, 0x36, 0x69, 0x90, 0x30, 0xC5, 0x94, 0x54, 0xF1, 0x29, 0x57, + 0x6B, 0x62, 0x6D, 0x6D, 0xA8, 0xC4, 0xD6, 0xCE, 0xF2, 0xAE, 0xED, 0x99, + 0x4B, 0x4D, 0xBB, 0x31, 0x21, 0x72, 0x4C, 0x3C, 0x9D, 0xD4, 0x06, 0xD1, + 0x38, 0x6D, 0x74, 0x46, 0x31, 0x26, 0xEF, 0x63, 0x4C, 0xA2, 0xE9, 0xB2, + 0x22, 0x6C, 0xAD, 0x49, 0x29, 0xF9, 0x90, 0x82, 0x8F, 0x37, 0xDB, 0xB6, + 0xA9, 0xAC, 0xFA, 0xE6, 0x8D, 0xCD, 0xEF, 0x68, 0x2D, 0x0D, 0xB9, 0x32, + 0xC3, 0xB8, 0x9D, 0xAE, 0xAB, 0x32, 0x74, 0xBA, 0x73, 0xAA, 0x91, 0x08, + 0x00, 0xF3, 0x49, 0x0D, 0x93, 0x8C, 0xDE, 0x13, 0x73, 0x5D, 0xD9, 0x22, + 0xFA, 0x94, 0x12, 0x87, 0x24, 0x84, 0x60, 0x1C, 0x18, 0x44, 0x4E, 0xC2, + 0x9C, 0x8C, 0xA1, 0x04, 0x32, 0x70, 0x16, 0x09, 0x80, 0x35, 0x46, 0x69, + 0x3F, 0x7B, 0x1F, 0x43, 0x4C, 0x21, 0x26, 0x16, 0xD8, 0xB7, 0x5E, 0xA1, + 0x25, 0x11, 0x58, 0x6B, 0xD6, 0x9B, 0xCD, 0xD9, 0x7C, 0xF2, 0xD3, 0x2F, + 0x3E, 0x57, 0x02, 0xA2, 0xD9, 0x6C, 0xF2, 0xF6, 0xDD, 0x55, 0x4C, 0xC9, + 0x18, 0x2D, 0x9F, 0x60, 0x86, 0x40, 0x31, 0xC5, 0x98, 0x42, 0x8C, 0x29, + 0xC9, 0x6A, 0xB3, 0x25, 0x34, 0x68, 0xA8, 0xF3, 0x29, 0xC6, 0x84, 0x00, + 0xFB, 0x5D, 0xDB, 0x76, 0x61, 0x70, 0xE0, 0x40, 0x31, 0x43, 0x8E, 0x99, + 0x52, 0xB9, 0xBF, 0xC5, 0xA0, 0x21, 0x44, 0x19, 0x27, 0xA1, 0x4C, 0x9E, + 0x88, 0xA0, 0x32, 0xD3, 0x38, 0x15, 0x60, 0x01, 0x90, 0xEC, 0xE7, 0x2E, + 0xE0, 0x72, 0x48, 0x73, 0x81, 0xBB, 0x3A, 0x2B, 0x57, 0x06, 0xDD, 0x33, + 0x24, 0x47, 0xF2, 0x73, 0xA2, 0xC5, 0x46, 0xA9, 0xB2, 0xC7, 0xE5, 0x7B, + 0x47, 0xFA, 0xF4, 0x9F, 0x71, 0x14, 0x73, 0xA4, 0xC2, 0x78, 0x84, 0xDA, + 0xF2, 0x46, 0xAB, 0x97, 0x54, 0x31, 0x24, 0x02, 0xC9, 0xF4, 0xDC, 0x23, + 0xD0, 0x97, 0x55, 0xF9, 0x9D, 0x0C, 0x76, 0xBE, 0x47, 0xC2, 0x31, 0x46, + 0x24, 0x7A, 0x17, 0x11, 0x1E, 0x53, 0x71, 0xC9, 0x50, 0xE9, 0x85, 0x20, + 0x20, 0x99, 0x25, 0x51, 0x32, 0x3D, 0xE6, 0xB1, 0xA1, 0x4D, 0xC1, 0x31, + 0x77, 0x14, 0xEA, 0xA8, 0x5D, 0x00, 0x00, 0x21, 0xDD, 0xD9, 0x12, 0x0A, + 0x46, 0x00, 0x25, 0x64, 0x1B, 0x7C, 0xEB, 0x9A, 0xC8, 0x91, 0xBF, 0xD1, + 0x2C, 0x99, 0x0C, 0x2F, 0x41, 0x4A, 0x5E, 0x41, 0x12, 0x2E, 0x65, 0x9C, + 0x38, 0xD6, 0x0B, 0x08, 0x00, 0x84, 0xA0, 0x3C, 0xF4, 0xB5, 0xA6, 0xB2, + 0x21, 0xB2, 0x80, 0xA4, 0x6C, 0x84, 0x22, 0x40, 0x14, 0x26, 0x1A, 0xD2, + 0x46, 0x8E, 0xC5, 0x77, 0x19, 0xCD, 0x95, 0x7D, 0x23, 0xB7, 0xC5, 0x24, + 0x8C, 0x31, 0xB5, 0x9D, 0xDF, 0x1E, 0xBA, 0xB6, 0x8B, 0x02, 0x70, 0xE8, + 0xBC, 0x0F, 0x49, 0x53, 0x2E, 0x92, 0xF0, 0xA4, 0xB2, 0xCE, 0x19, 0x25, + 0x8F, 0x15, 0x90, 0xA6, 0xB2, 0x8B, 0x69, 0x6D, 0x9D, 0x69, 0x6A, 0x67, + 0x88, 0x54, 0x73, 0x9B, 0xE2, 0xE2, 0x39, 0x19, 0x9D, 0xFB, 0xB2, 0x32, + 0xDE, 0x5B, 0x96, 0xB3, 0xA6, 0xA9, 0xEC, 0xC3, 0xF3, 0xA9, 0x8F, 0xBC, + 0x6F, 0xFD, 0xED, 0xB6, 0x3D, 0xF4, 0x51, 0x57, 0x94, 0x7E, 0x18, 0x80, + 0x48, 0xBB, 0x94, 0xE3, 0x20, 0xDB, 0x83, 0x08, 0x96, 0x4B, 0x1D, 0x65, + 0xCC, 0x19, 0x24, 0xC2, 0x10, 0x53, 0xE5, 0x88, 0x59, 0x9C, 0xA1, 0x90, + 0x12, 0x96, 0x02, 0x16, 0x03, 0xC4, 0x0C, 0x6D, 0x88, 0x88, 0xD8, 0xFB, + 0x83, 0x46, 0xF7, 0xAC, 0x21, 0x67, 0x0D, 0x02, 0x86, 0x94, 0x52, 0x60, + 0x4B, 0xE4, 0x9C, 0x45, 0x00, 0x4B, 0x58, 0x39, 0xB3, 0xDA, 0x29, 0x08, + 0x93, 0xD6, 0x07, 0x15, 0xCA, 0x10, 0x79, 0xDF, 0x79, 0x4B, 0xD4, 0xF5, + 0xA1, 0x72, 0xC6, 0x1A, 0x64, 0x16, 0x63, 0x20, 0xB1, 0x26, 0xD5, 0x2A, + 0xC1, 0xA6, 0x15, 0x11, 0x1F, 0x62, 0x8C, 0x69, 0x77, 0xE8, 0x29, 0xEF, + 0x60, 0x32, 0x2E, 0x9B, 0xD5, 0xF8, 0xC0, 0x48, 0x49, 0xC1, 0xC9, 0x00, + 0x0E, 0xAF, 0x9C, 0x87, 0x42, 0xF3, 0xE9, 0x2A, 0x37, 0x6D, 0x6A, 0x3D, + 0xBD, 0x76, 0x06, 0x89, 0x44, 0xA4, 0xED, 0x7C, 0xD7, 0x07, 0x75, 0x75, + 0x19, 0x43, 0xD6, 0x88, 0x49, 0x18, 0xA2, 0x72, 0x21, 0x20, 0xE7, 0xD3, + 0x73, 0xF5, 0xA8, 0x56, 0x7F, 0xE8, 0x6D, 0xB4, 0x46, 0xEA, 0xD0, 0xFB, + 0x10, 0xB2, 0x83, 0x0C, 0x11, 0x8D, 0x41, 0x22, 0x20, 0x42, 0x02, 0x5C, + 0x2E, 0x26, 0x0F, 0xFE, 0xE6, 0x57, 0x93, 0xC9, 0xA4, 0xEB, 0xFC, 0xED, + 0xDB, 0xAB, 0xAB, 0x9B, 0x75, 0x8A, 0xA9, 0xA9, 0xEA, 0x7D, 0xD7, 0x69, + 0xA9, 0x40, 0xE5, 0x1C, 0x20, 0xEE, 0xF6, 0x2D, 0x12, 0xF9, 0x3E, 0x74, + 0xDE, 0x4F, 0x9A, 0x46, 0x12, 0x9F, 0x9F, 0x2D, 0x6E, 0xD7, 0x1B, 0x6D, + 0x63, 0xF1, 0xE2, 0xD5, 0xFB, 0x43, 0xDB, 0xD5, 0x55, 0x75, 0xDC, 0xD8, + 0x4A, 0xAE, 0xC5, 0x51, 0x28, 0x40, 0x11, 0x95, 0xAE, 0xCF, 0x3B, 0x8B, + 0x36, 0x8F, 0x82, 0x31, 0x4E, 0x08, 0x32, 0x29, 0x31, 0x0F, 0x59, 0x60, + 0xC3, 0x45, 0xFE, 0x3F, 0x34, 0xD4, 0xBD, 0x63, 0x3E, 0x70, 0x00, 0x0F, + 0x83, 0x2F, 0x0A, 0x77, 0x0A, 0xD6, 0xC8, 0x67, 0x8C, 0x4D, 0x84, 0x72, + 0xF2, 0x1D, 0xB8, 0x37, 0x92, 0xD2, 0xE1, 0x5D, 0x32, 0x62, 0x39, 0x2E, + 0xE1, 0x62, 0xFD, 0x1D, 0xA1, 0xDC, 0x50, 0xE6, 0x36, 0x76, 0x39, 0x8D, + 0x65, 0xFD, 0x68, 0x43, 0x8F, 0x15, 0x99, 0xE4, 0xDA, 0xC7, 0xF2, 0x80, + 0x05, 0x3A, 0x1D, 0xDB, 0x00, 0x83, 0x00, 0x1F, 0x73, 0xE1, 0x74, 0xCC, + 0x01, 0x72, 0xB5, 0xB3, 0x8C, 0xDA, 0x30, 0x1D, 0x6F, 0x57, 0xCA, 0x06, + 0xF0, 0xAE, 0x17, 0x27, 0xBB, 0x77, 0xA4, 0x38, 0x01, 0x54, 0xD9, 0x89, + 0x26, 0x9A, 0x31, 0x03, 0xA2, 0x0E, 0x17, 0x21, 0x69, 0x4D, 0x67, 0x2E, + 0xC9, 0x14, 0x61, 0x66, 0x5B, 0xAE, 0x70, 0x04, 0x21, 0x59, 0x34, 0x45, + 0x24, 0x6A, 0x53, 0x00, 0x48, 0x89, 0xD9, 0x0A, 0xA1, 0x02, 0x5A, 0x74, + 0xD6, 0x8A, 0x00, 0x0B, 0xF7, 0x7D, 0x74, 0x4E, 0xEB, 0x60, 0xEF, 0xD8, + 0x95, 0x0A, 0xC7, 0x24, 0x93, 0xDF, 0x43, 0x4C, 0xDC, 0x1D, 0x7C, 0x08, + 0x49, 0x4B, 0x08, 0x2B, 0x67, 0x2A, 0x67, 0xCF, 0xE6, 0xB5, 0x21, 0xA3, + 0xC4, 0x8B, 0x44, 0x64, 0x88, 0x00, 0xA1, 0xEB, 0xBD, 0xAE, 0x61, 0xAD, + 0xF5, 0xB3, 0xC6, 0x80, 0x28, 0xBE, 0x13, 0x64, 0x48, 0x09, 0x35, 0x23, + 0x57, 0x07, 0x73, 0x9C, 0x39, 0x75, 0x32, 0xC7, 0xE3, 0x5F, 0x05, 0xD1, + 0x18, 0xB3, 0x98, 0x37, 0x20, 0xF0, 0xF0, 0x7C, 0xF6, 0xE8, 0x62, 0xB6, + 0xDA, 0xB6, 0x3E, 0xF0, 0xA4, 0xC9, 0x29, 0xA3, 0xD7, 0xDB, 0xC3, 0x66, + 0xDF, 0x33, 0x83, 0x21, 0x24, 0x1A, 0x12, 0x17, 0x8F, 0x03, 0x53, 0xC2, + 0xD7, 0x65, 0xAA, 0x18, 0xDA, 0x2E, 0x46, 0x61, 0x67, 0xC8, 0x19, 0xA5, + 0xBA, 0x02, 0x4D, 0x08, 0x32, 0x44, 0x96, 0x90, 0x08, 0x62, 0x04, 0x11, + 0x41, 0xC2, 0xDB, 0x5D, 0x7B, 0xE8, 0x3C, 0x22, 0xCE, 0x26, 0xD5, 0xAC, + 0x71, 0x9D, 0x8F, 0xBD, 0x8F, 0x8B, 0x69, 0x2D, 0xAD, 0x3F, 0x5F, 0x4C, + 0xAA, 0xCA, 0x2A, 0x4E, 0xC4, 0x42, 0x8A, 0xA0, 0xE5, 0xB5, 0x49, 0xD8, + 0x10, 0x3D, 0x38, 0x9F, 0x22, 0x40, 0xDB, 0x79, 0xE7, 0xEC, 0xCC, 0x50, + 0x8C, 0x09, 0x04, 0x42, 0x4C, 0xD6, 0x90, 0xB5, 0xD6, 0x5A, 0xDA, 0xEF, + 0xFB, 0x7D, 0xE7, 0x63, 0x64, 0x22, 0x6C, 0x1A, 0x0B, 0x58, 0xD5, 0xCE, + 0x19, 0x32, 0xDA, 0x9E, 0x30, 0x69, 0x7B, 0x54, 0xFC, 0x00, 0x16, 0x93, + 0xE2, 0x5B, 0xD5, 0xF6, 0x51, 0xE3, 0x01, 0xD4, 0x63, 0x26, 0x93, 0x8A, + 0x08, 0x0F, 0x6D, 0x1F, 0x63, 0xAA, 0x9C, 0x35, 0x5A, 0xC2, 0x19, 0x53, + 0x4C, 0x29, 0xB2, 0x0C, 0xA6, 0xB7, 0xB3, 0x26, 0x2B, 0x8D, 0x82, 0x75, + 0xF4, 0xB2, 0xCC, 0x62, 0x99, 0x04, 0x44, 0xCB, 0xEC, 0xFB, 0x90, 0x54, + 0x8B, 0xA9, 0x21, 0x5C, 0x2C, 0x19, 0x10, 0x4E, 0x93, 0xCA, 0x05, 0xB4, + 0xDB, 0x6D, 0xBB, 0x3B, 0xF4, 0x7D, 0xD7, 0xFB, 0x90, 0x42, 0x48, 0x21, + 0xC4, 0xBE, 0xEF, 0x3B, 0x1F, 0x7C, 0x88, 0x9C, 0xB8, 0x25, 0xBF, 0x6F, + 0xBB, 0x10, 0xD2, 0xE5, 0xC5, 0x19, 0x19, 0x43, 0x64, 0xD6, 0x9B, 0xBD, + 0x88, 0x34, 0x4D, 0xAD, 0x31, 0x74, 0x32, 0xF4, 0xE8, 0xE1, 0x99, 0xB3, + 0x2E, 0x0D, 0xB4, 0xCC, 0x28, 0xCA, 0x97, 0x9C, 0xD7, 0x30, 0x8C, 0xAC, + 0xB5, 0x91, 0x6C, 0x9C, 0x08, 0xBF, 0x4E, 0x01, 0x64, 0x14, 0x46, 0x52, + 0x92, 0x45, 0x3F, 0xB8, 0xF2, 0xD5, 0xE2, 0xC9, 0x16, 0xEC, 0x5D, 0xE5, + 0xF5, 0xC1, 0xCD, 0x75, 0xB0, 0xE5, 0xB2, 0x0C, 0xA9, 0xFE, 0x81, 0x8C, + 0x21, 0x86, 0x7E, 0xA4, 0x20, 0xA2, 0x1D, 0x1D, 0x47, 0xB4, 0xD8, 0x70, + 0xFF, 0x6A, 0xE5, 0x57, 0x1C, 0x54, 0xED, 0x90, 0xD2, 0x35, 0x5A, 0xCA, + 0x47, 0xE3, 0x11, 0x4A, 0xCF, 0x97, 0x9C, 0xAB, 0x85, 0x32, 0x34, 0x45, + 0x19, 0x2C, 0xEE, 0x93, 0xEB, 0x0F, 0xA2, 0x82, 0x72, 0xDC, 0xE6, 0x41, + 0x2D, 0xCB, 0xE1, 0x85, 0x86, 0xF2, 0xFB, 0xD1, 0xD2, 0x1B, 0x3C, 0x2D, + 0x05, 0x0C, 0x82, 0x80, 0x10, 0x00, 0x09, 0x30, 0x89, 0x02, 0x60, 0x00, + 0x18, 0x52, 0xDE, 0x8E, 0x19, 0x1E, 0x23, 0x23, 0x1D, 0x33, 0x5F, 0x76, + 0xB9, 0x82, 0xE4, 0x01, 0x32, 0x06, 0x9D, 0xB5, 0xC6, 0x12, 0x14, 0x79, + 0x4B, 0xC2, 0x29, 0x25, 0xCB, 0xCA, 0x97, 0x3F, 0x52, 0xCD, 0x38, 0x54, + 0xBE, 0x12, 0x02, 0x80, 0x8F, 0xE9, 0xD0, 0x07, 0x24, 0xAC, 0x6C, 0x2E, + 0x47, 0xF0, 0x31, 0x4A, 0xB6, 0xFE, 0xF2, 0x40, 0x0C, 0x33, 0xC7, 0x2C, + 0x9A, 0x52, 0x0B, 0x02, 0x31, 0xA5, 0xC8, 0x1C, 0x42, 0x3A, 0x74, 0xE1, + 0xD0, 0xF9, 0x98, 0x52, 0xED, 0x6C, 0x64, 0x61, 0xE6, 0x59, 0x5D, 0xCD, + 0x67, 0x75, 0x5D, 0xD9, 0x4A, 0x4C, 0x4C, 0xC9, 0x1A, 0x63, 0x8D, 0xF1, + 0x21, 0x22, 0x54, 0x95, 0x63, 0x75, 0x06, 0x1B, 0x43, 0x08, 0xC8, 0x2C, + 0xD6, 0x92, 0x73, 0x94, 0x93, 0x83, 0x4B, 0x58, 0xE2, 0x24, 0xAC, 0x73, + 0xA2, 0xF2, 0x87, 0x0F, 0x96, 0x92, 0xE2, 0x52, 0x5D, 0xC1, 0x93, 0xA6, + 0x9A, 0x4D, 0xEB, 0x12, 0xBB, 0x80, 0xDE, 0x87, 0x8B, 0xE5, 0xE4, 0xD0, + 0x87, 0x97, 0xEF, 0x37, 0x9B, 0xBD, 0x57, 0x2D, 0x86, 0x47, 0x9D, 0x08, + 0x88, 0x47, 0xC9, 0x50, 0x79, 0xD0, 0xBC, 0x6F, 0x7B, 0x7C, 0x77, 0xAD, + 0x8B, 0x04, 0x10, 0x20, 0x02, 0x43, 0xA8, 0xCB, 0x29, 0x81, 0x20, 0x83, + 0x35, 0xD4, 0x85, 0x04, 0x20, 0x5D, 0x88, 0xBD, 0xCF, 0xC4, 0x41, 0x5D, + 0x88, 0x21, 0x24, 0x63, 0x68, 0x31, 0xAD, 0x2B, 0x6B, 0x26, 0xB5, 0xED, + 0x7C, 0x8C, 0x89, 0x0C, 0xA2, 0x18, 0x14, 0x91, 0x89, 0xB5, 0x86, 0xD0, + 0x1A, 0xAA, 0x9C, 0xBD, 0xDD, 0x04, 0x1F, 0xFA, 0xDA, 0x99, 0xAA, 0x32, + 0x48, 0x60, 0x88, 0x7C, 0x48, 0x22, 0x90, 0x12, 0x8A, 0xF2, 0xFC, 0x1A, + 0x9C, 0xD4, 0xD5, 0xA4, 0x71, 0x33, 0xCA, 0x16, 0xFA, 0xB0, 0x1B, 0xAB, + 0x1B, 0x60, 0x2C, 0x22, 0x70, 0x6C, 0x47, 0x98, 0x8F, 0xC9, 0x83, 0x56, + 0x92, 0x17, 0x45, 0x24, 0xC6, 0x08, 0x80, 0x75, 0xED, 0x58, 0x64, 0xBF, + 0xEF, 0xD6, 0xBD, 0x57, 0x0A, 0xEE, 0xBC, 0x72, 0x25, 0x97, 0xAC, 0xDA, + 0x63, 0x9D, 0x75, 0x01, 0x05, 0x23, 0x7B, 0x3F, 0x89, 0x58, 0x42, 0x63, + 0x8C, 0x66, 0x53, 0x6B, 0x81, 0x1E, 0x40, 0x4E, 0xB5, 0x24, 0xC2, 0xDA, + 0x12, 0x0A, 0xDC, 0xDC, 0xAC, 0x5E, 0xBC, 0x7E, 0x6F, 0xC9, 0x6A, 0x2F, + 0x1C, 0x16, 0xE9, 0xBD, 0xF7, 0x7D, 0xB8, 0x59, 0x6D, 0x94, 0x6B, 0x73, + 0x36, 0x9B, 0xCE, 0x27, 0xF5, 0xEE, 0x6A, 0xB5, 0xDD, 0xEE, 0x7D, 0x88, + 0x1F, 0x7F, 0xFC, 0xD8, 0x26, 0x11, 0xE9, 0x63, 0x8C, 0x29, 0x39, 0x63, + 0xA8, 0xAE, 0xAA, 0xB6, 0xF3, 0x3F, 0xF9, 0xEC, 0x49, 0x5D, 0xBB, 0xAE, + 0xF3, 0x48, 0x24, 0x23, 0x03, 0x33, 0x8B, 0x01, 0x0C, 0x58, 0xEC, 0x14, + 0x55, 0x9D, 0x48, 0x4B, 0xD9, 0xAD, 0x20, 0x2B, 0xC4, 0xD1, 0x1A, 0x3F, + 0x11, 0xB0, 0xA2, 0x1A, 0xE5, 0xBE, 0x16, 0x28, 0xA9, 0x6B, 0x23, 0xE1, + 0x2C, 0xC0, 0x24, 0x8F, 0x12, 0x28, 0xED, 0xEB, 0xB0, 0xCE, 0x0B, 0xB6, + 0x29, 0x74, 0x82, 0x3A, 0x51, 0x02, 0xC0, 0x49, 0x4E, 0xB4, 0x12, 0x1F, + 0x43, 0x87, 0x2C, 0x23, 0x27, 0x94, 0x96, 0x93, 0x95, 0x59, 0xF8, 0xC0, + 0xA6, 0x3E, 0x3C, 0x7C, 0x5E, 0xB0, 0x98, 0xEF, 0x85, 0xAA, 0x3D, 0xE5, + 0x38, 0x3E, 0x27, 0xA2, 0x32, 0x5C, 0x65, 0x8C, 0x1A, 0x86, 0x83, 0x07, + 0x1B, 0x70, 0x34, 0x8C, 0x65, 0x68, 0xC6, 0x22, 0x01, 0xC0, 0x90, 0x0B, + 0x27, 0x58, 0x98, 0x80, 0x14, 0x6A, 0x99, 0xBC, 0xB4, 0x8F, 0xAC, 0xAB, + 0x19, 0xF2, 0xE9, 0xCD, 0x75, 0x37, 0x22, 0x30, 0x64, 0x40, 0xA0, 0xD2, + 0x5D, 0x90, 0x50, 0x91, 0x13, 0x33, 0x47, 0x4E, 0x1A, 0x34, 0xB7, 0x31, + 0x8F, 0x4B, 0x49, 0x6E, 0x80, 0x6C, 0x82, 0xAA, 0x6C, 0x33, 0x03, 0x8A, + 0x84, 0xC8, 0x5D, 0x17, 0x92, 0xCB, 0xDA, 0x57, 0xD3, 0x85, 0x6A, 0xE7, + 0x8C, 0x25, 0x6B, 0x8D, 0x73, 0xB9, 0xE2, 0xB2, 0xED, 0xFC, 0x66, 0xD7, + 0x2A, 0x15, 0x8E, 0x3A, 0x6E, 0x00, 0x21, 0x44, 0xEE, 0x7D, 0x36, 0xE4, + 0xB4, 0xA3, 0x90, 0xB3, 0x14, 0x12, 0x7B, 0x1F, 0xAD, 0xA1, 0xBA, 0x72, + 0xDD, 0xA1, 0x6F, 0xFB, 0xB6, 0xB2, 0x46, 0xDD, 0xF9, 0x31, 0x46, 0x74, + 0x36, 0xA6, 0xD4, 0x87, 0xB8, 0x98, 0x4E, 0x34, 0xC5, 0x5F, 0x8D, 0x4A, + 0xEF, 0x23, 0x95, 0xBE, 0xD3, 0x38, 0x32, 0x97, 0x3E, 0x28, 0xA0, 0x83, + 0x6E, 0x95, 0x5C, 0x14, 0x95, 0x77, 0xAC, 0x18, 0x93, 0x73, 0xEA, 0x69, + 0x44, 0x24, 0x30, 0xC6, 0x4C, 0x1A, 0x9C, 0x34, 0x6E, 0x5A, 0xBB, 0x97, + 0xEF, 0xD7, 0xEF, 0x56, 0x07, 0x73, 0x2F, 0x4B, 0xCE, 0x00, 0x22, 0xA2, + 0x31, 0xC8, 0x02, 0x29, 0x71, 0x76, 0x11, 0x03, 0x22, 0x8A, 0xB2, 0xB6, + 0x6A, 0x8E, 0x9E, 0xB1, 0xD9, 0xC4, 0x8E, 0x1C, 0x91, 0x00, 0x05, 0x0D, + 0x61, 0x53, 0xD9, 0x43, 0x17, 0x34, 0xC1, 0xB2, 0xF3, 0x51, 0xCB, 0xD7, + 0xBA, 0x3E, 0x26, 0xE6, 0xF5, 0xB6, 0xD5, 0x98, 0x49, 0x65, 0xCD, 0xBE, + 0x0B, 0x93, 0xDA, 0x89, 0x48, 0x88, 0xC9, 0x5A, 0xC3, 0x22, 0x7D, 0x48, + 0xAB, 0x5D, 0x77, 0x36, 0xAB, 0x2B, 0x67, 0x7C, 0x48, 0x6D, 0x1F, 0x34, + 0xD7, 0x17, 0x11, 0xF7, 0x6D, 0x3F, 0x9B, 0x54, 0x3B, 0x9F, 0x79, 0xD0, + 0x42, 0x4C, 0xB1, 0xA4, 0xAA, 0x6A, 0x9C, 0x4D, 0xDF, 0x94, 0x4B, 0xF7, + 0x07, 0x0D, 0xD5, 0x43, 0x5E, 0x21, 0xA2, 0x74, 0x89, 0xAE, 0xB2, 0x9A, + 0xEA, 0x35, 0x88, 0x5A, 0xC1, 0x49, 0x20, 0x25, 0xBE, 0x3C, 0x69, 0x9C, + 0x35, 0xA6, 0xEF, 0xC3, 0xBE, 0xED, 0x7A, 0x1F, 0x8A, 0x5D, 0x50, 0x1C, + 0x9A, 0x03, 0x7E, 0x38, 0x9A, 0x4B, 0x47, 0xF3, 0x04, 0xD5, 0xB0, 0xA5, + 0xCC, 0x6A, 0x09, 0x9A, 0x02, 0xA2, 0x9E, 0x75, 0x10, 0x6B, 0xB0, 0xEF, + 0xFA, 0x97, 0x6F, 0xAF, 0x6F, 0x57, 0x5B, 0x4E, 0x89, 0x10, 0xAB, 0xCA, + 0x7A, 0x1F, 0x99, 0x79, 0xB7, 0x3F, 0xB4, 0x9D, 0xDF, 0xB7, 0x7D, 0xD7, + 0x7B, 0x01, 0x30, 0xC6, 0x32, 0x43, 0xD3, 0xD4, 0xD6, 0xD9, 0x10, 0xE2, + 0x7A, 0xBD, 0x5D, 0x2E, 0x66, 0x7D, 0xDF, 0x5B, 0x6B, 0x43, 0xD0, 0x0E, + 0x7B, 0xD6, 0x87, 0x10, 0x62, 0x1C, 0x01, 0x05, 0x80, 0xA3, 0xFF, 0xE8, + 0xE8, 0xFC, 0xC4, 0x0F, 0xE9, 0xB2, 0xE1, 0xCB, 0x61, 0xBD, 0x9D, 0x60, + 0x37, 0xC5, 0x02, 0x78, 0x57, 0x2A, 0x06, 0x40, 0x34, 0xA0, 0xF7, 0x3B, + 0xA0, 0x0C, 0x46, 0x19, 0xA8, 0x23, 0xA3, 0xEC, 0xF8, 0xF7, 0xD1, 0x71, + 0x32, 0xE2, 0x47, 0x24, 0xCA, 0x8D, 0x42, 0x98, 0x07, 0x9D, 0x52, 0x50, + 0xC9, 0x48, 0x2F, 0x14, 0xE6, 0x2E, 0x80, 0xE2, 0xB3, 0xCE, 0x5C, 0x6B, + 0x45, 0x0B, 0xC0, 0xA8, 0xA5, 0xCB, 0x48, 0x7F, 0x0D, 0x2E, 0x2A, 0x22, + 0x73, 0x17, 0x07, 0x7D, 0x08, 0xF1, 0x8D, 0x34, 0xE6, 0x71, 0x64, 0xB9, + 0x3C, 0xEB, 0x09, 0x68, 0x18, 0x36, 0xB0, 0x11, 0x62, 0xBD, 0xB3, 0x3C, + 0x01, 0x8A, 0x17, 0x0F, 0x8E, 0x9E, 0xA8, 0x92, 0x0F, 0x74, 0xC7, 0x9B, + 0x96, 0xCF, 0xCA, 0x65, 0x61, 0xBA, 0xAC, 0x4A, 0x55, 0xC1, 0x00, 0x3C, + 0x59, 0x62, 0xE4, 0x98, 0x52, 0xA1, 0x27, 0x60, 0x4B, 0x54, 0xEA, 0xC8, + 0x45, 0x13, 0xF6, 0x20, 0xB7, 0x0D, 0x2D, 0xEF, 0x45, 0x40, 0x31, 0xA5, + 0x83, 0x88, 0x09, 0xC9, 0x50, 0xAE, 0xD1, 0x6E, 0x1A, 0x37, 0x9B, 0xD5, + 0xCE, 0x39, 0x65, 0x92, 0xE2, 0x94, 0xB4, 0x66, 0x65, 0xBD, 0x6D, 0x7B, + 0x1F, 0x75, 0xC7, 0x2E, 0x04, 0x46, 0x12, 0x93, 0x28, 0x09, 0x45, 0x01, + 0x53, 0x18, 0x13, 0x1F, 0xFA, 0x00, 0x00, 0x29, 0x71, 0xDB, 0x87, 0xED, + 0xA1, 0x27, 0xA2, 0xE5, 0xAC, 0x46, 0x22, 0x67, 0xC8, 0x5A, 0x23, 0x20, + 0x21, 0x26, 0x11, 0x26, 0x32, 0xD9, 0x50, 0xD7, 0x8C, 0xF9, 0x8C, 0x8C, + 0x78, 0x98, 0x9B, 0x61, 0x04, 0xEF, 0x57, 0x1A, 0x8C, 0x27, 0x52, 0xC3, + 0xD5, 0x9D, 0x0F, 0x9C, 0xA4, 0x4E, 0xAE, 0x69, 0xD0, 0x39, 0x04, 0x40, + 0x6B, 0x31, 0x25, 0x14, 0xC1, 0xE9, 0xA4, 0x7A, 0xFA, 0xD1, 0x39, 0x21, + 0xD6, 0x95, 0x5D, 0xEF, 0xFB, 0xD5, 0xB6, 0x53, 0x7E, 0x5E, 0x16, 0x10, + 0x10, 0x9B, 0xCB, 0xDA, 0x44, 0x15, 0x69, 0x16, 0x77, 0x01, 0x66, 0xEE, + 0x83, 0x88, 0x88, 0x76, 0x07, 0x61, 0x56, 0xEE, 0x1D, 0x04, 0x12, 0x0B, + 0xD9, 0x95, 0xA6, 0xD5, 0xC3, 0xD6, 0x1A, 0x6B, 0xA8, 0xF5, 0x41, 0xCD, + 0x73, 0x4D, 0xDD, 0x08, 0x91, 0x63, 0x4A, 0xFB, 0x36, 0xC4, 0xC8, 0x9C, + 0xEB, 0xE8, 0x25, 0x29, 0x59, 0x01, 0xA7, 0xF5, 0xAE, 0x0B, 0x21, 0xCD, + 0x26, 0x15, 0xB3, 0xEC, 0x0E, 0xBD, 0x21, 0x6A, 0xEA, 0x8C, 0xB7, 0x3B, + 0x1F, 0x7D, 0x48, 0x3E, 0x64, 0x48, 0x18, 0x42, 0x72, 0x36, 0x97, 0xBE, + 0x2A, 0x3D, 0x4E, 0x49, 0x24, 0x2E, 0x14, 0x60, 0x00, 0x29, 0xA5, 0x43, + 0xE7, 0x99, 0xB9, 0xED, 0x63, 0x4A, 0x69, 0x36, 0xAD, 0x6B, 0x67, 0xA7, + 0x93, 0x5A, 0x4B, 0x56, 0xC7, 0x80, 0x9C, 0x88, 0xB4, 0xBC, 0x30, 0x46, + 0x00, 0xC0, 0xA6, 0x76, 0x88, 0xB0, 0x3B, 0x74, 0x2C, 0xE0, 0x4C, 0xEE, + 0x4B, 0x36, 0x9A, 0x8E, 0x81, 0xDA, 0xF3, 0xB8, 0xC7, 0x98, 0xD2, 0x4B, + 0x12, 0x00, 0x41, 0x14, 0x8E, 0x41, 0xEF, 0x43, 0x0C, 0x1E, 0x39, 0xFD, + 0xE1, 0xDB, 0xE7, 0xF3, 0xF9, 0x5C, 0xEB, 0x19, 0x97, 0xCB, 0xF9, 0x76, + 0xBB, 0x4B, 0x21, 0xF6, 0x3E, 0x84, 0x18, 0x57, 0xAB, 0x2D, 0x00, 0xF9, + 0x98, 0xF6, 0x87, 0x2E, 0xA5, 0xE4, 0x9C, 0x8B, 0x91, 0x7B, 0xBF, 0x07, + 0x91, 0x07, 0x0F, 0x2E, 0x42, 0x88, 0x29, 0xF2, 0x66, 0xB3, 0x27, 0xA2, + 0x10, 0x82, 0x88, 0xA4, 0xC4, 0xFB, 0x83, 0xA4, 0xC4, 0xEB, 0xCD, 0xAE, + 0x6C, 0x5A, 0x90, 0xCB, 0xB5, 0x91, 0x11, 0xAD, 0xDA, 0x17, 0x59, 0xEB, + 0x28, 0xF3, 0xFE, 0x48, 0x93, 0x0C, 0x12, 0x32, 0xAC, 0x40, 0xCC, 0x08, + 0x69, 0xA4, 0x74, 0x06, 0xC4, 0xA4, 0x75, 0x4B, 0x34, 0x28, 0xC8, 0x1C, + 0x35, 0x3C, 0xAE, 0xE4, 0xA3, 0x27, 0x69, 0xAC, 0x11, 0xC6, 0x8A, 0x22, + 0xC3, 0xAE, 0x8C, 0x39, 0x80, 0xCB, 0x36, 0x90, 0x17, 0x79, 0x2A, 0xE4, + 0xF8, 0xEA, 0x29, 0x2B, 0x41, 0xB3, 0x3B, 0x2B, 0x1C, 0x4B, 0x5B, 0x1F, + 0x35, 0xE2, 0xA5, 0x90, 0xBE, 0x0E, 0x8A, 0x03, 0xEE, 0x66, 0x96, 0xD2, + 0x3D, 0x15, 0x2C, 0xA2, 0x0B, 0x5D, 0xED, 0x95, 0x6C, 0xD8, 0xDE, 0xC7, + 0xA9, 0x63, 0x68, 0x96, 0xDF, 0xE1, 0xEE, 0xCB, 0x0D, 0x28, 0x61, 0xAC, + 0xBF, 0x60, 0xA4, 0xD4, 0x4E, 0x14, 0x99, 0x1E, 0x93, 0xFB, 0x79, 0x18, + 0x63, 0x4C, 0xEE, 0x43, 0x3A, 0xBC, 0x97, 0x4A, 0xEC, 0x00, 0x41, 0xCA, + 0x45, 0xF4, 0x39, 0x73, 0xFE, 0x16, 0xAB, 0x31, 0xC9, 0x12, 0xB5, 0x64, + 0xBC, 0xB0, 0x4E, 0xAA, 0xB9, 0x88, 0x29, 0x57, 0x1D, 0xDC, 0xF1, 0x9D, + 0x63, 0xA6, 0x85, 0x03, 0x91, 0xDC, 0x97, 0x4B, 0x93, 0xDF, 0xE7, 0xF3, + 0xC9, 0xE5, 0xF9, 0xAC, 0xAA, 0x9C, 0x96, 0x89, 0xC6, 0x98, 0x7A, 0x1F, + 0x0F, 0x6D, 0x7F, 0xBB, 0x69, 0xBB, 0x10, 0x63, 0xCA, 0xC4, 0x47, 0xDA, + 0x63, 0x4C, 0x97, 0xB7, 0x00, 0x0C, 0x05, 0x46, 0x7D, 0xE0, 0x94, 0x7C, + 0x5D, 0x19, 0x1F, 0x93, 0x69, 0x95, 0x2B, 0x31, 0x47, 0x10, 0x11, 0x21, + 0x96, 0x70, 0xDE, 0xB4, 0xD1, 0x92, 0x54, 0x00, 0xC0, 0x18, 0x53, 0xD7, + 0x07, 0x4D, 0x5F, 0x68, 0x6A, 0xA7, 0xB3, 0x39, 0x54, 0x7F, 0x8D, 0x07, + 0x62, 0x50, 0x67, 0x32, 0x8A, 0xA2, 0xEA, 0x5C, 0xD6, 0x35, 0x59, 0x6B, + 0xB4, 0xF5, 0x59, 0xDB, 0xF9, 0x94, 0x4C, 0xAE, 0x9F, 0x60, 0x61, 0x81, + 0x10, 0x63, 0x08, 0x69, 0x39, 0xAB, 0x45, 0x60, 0x3E, 0x71, 0x21, 0xA6, + 0x98, 0x24, 0x69, 0x90, 0x1B, 0x10, 0x04, 0x38, 0x81, 0x26, 0xA6, 0x0A, + 0x80, 0xBA, 0xBD, 0x43, 0xE4, 0x10, 0xD3, 0x70, 0x40, 0x52, 0x4E, 0x77, + 0xED, 0x6B, 0x57, 0xFC, 0xC4, 0x5C, 0xAA, 0xD2, 0x10, 0x40, 0xC9, 0x66, + 0x61, 0x54, 0x54, 0x77, 0xE8, 0x42, 0x4C, 0xEC, 0xA3, 0x92, 0x46, 0x08, + 0x92, 0x86, 0x8C, 0x05, 0x73, 0xCF, 0x1F, 0xD8, 0x77, 0x21, 0xB1, 0x10, + 0x02, 0x8B, 0xB8, 0xCE, 0xEB, 0x9A, 0xAA, 0x9C, 0x0D, 0x29, 0x55, 0x8E, + 0xBA, 0x3E, 0xED, 0x3B, 0x3F, 0x9B, 0x54, 0xD3, 0x49, 0xED, 0x2C, 0xA9, + 0x07, 0x2D, 0x44, 0xD6, 0x66, 0x97, 0x2C, 0xE2, 0x8C, 0x09, 0x31, 0x71, + 0x62, 0x6B, 0xCD, 0x7A, 0xDB, 0xEE, 0x0E, 0x7D, 0xCA, 0xAD, 0x2C, 0x84, + 0x77, 0xFD, 0x9E, 0x7C, 0x8C, 0xBC, 0x5C, 0xC8, 0xE0, 0x29, 0x2B, 0xFB, + 0xB0, 0x14, 0xB9, 0xC9, 0xC0, 0xAB, 0xAA, 0xDC, 0x1C, 0xC0, 0x87, 0xA4, + 0xF4, 0x2C, 0x3A, 0x65, 0x03, 0x70, 0x80, 0xC2, 0x81, 0xA3, 0xE3, 0x6D, + 0x08, 0x2B, 0x6B, 0x20, 0x73, 0x45, 0x41, 0x55, 0xB9, 0xB6, 0xED, 0x56, + 0xEB, 0x0D, 0x21, 0x34, 0x4D, 0x7D, 0x75, 0xB3, 0x79, 0xF3, 0xE6, 0xEA, + 0xB3, 0xCF, 0xAA, 0xC9, 0xB4, 0x41, 0xA4, 0xD9, 0x74, 0xD2, 0xB7, 0x1D, + 0x13, 0x32, 0x80, 0x0F, 0x69, 0xBB, 0x6F, 0x9B, 0x66, 0xA2, 0xD0, 0x4C, + 0x2F, 0xE8, 0xBD, 0xEF, 0xFB, 0x5E, 0x44, 0xCE, 0xCE, 0x96, 0xCC, 0xEC, + 0x83, 0xEF, 0xFB, 0x1E, 0x91, 0x00, 0x50, 0x2B, 0xAB, 0xCE, 0xCE, 0x96, + 0xFB, 0x7D, 0xBB, 0xDE, 0xEC, 0x43, 0x0C, 0xD9, 0x86, 0x2D, 0x99, 0x01, + 0x39, 0x6E, 0x39, 0x2C, 0xB2, 0xE2, 0x86, 0x2A, 0x50, 0x12, 0x00, 0x8E, + 0x2D, 0x2C, 0x8F, 0xCA, 0xA2, 0x98, 0x46, 0x88, 0x38, 0x14, 0xD1, 0x80, + 0x66, 0xA2, 0xA2, 0x60, 0x31, 0x5D, 0x86, 0xFE, 0xBE, 0x43, 0x81, 0x63, + 0xD6, 0x4E, 0x79, 0xB5, 0xAB, 0x96, 0x53, 0x1A, 0x30, 0x55, 0x5C, 0xC7, + 0x9C, 0x8B, 0x8C, 0x92, 0x01, 0x00, 0x20, 0x95, 0x14, 0x61, 0xCE, 0x8C, + 0x88, 0x19, 0xF6, 0x8E, 0x75, 0xD9, 0x58, 0xD5, 0xE6, 0x24, 0xF9, 0x02, + 0xBA, 0x05, 0x07, 0x1D, 0x29, 0x59, 0x9D, 0xF2, 0x1D, 0x40, 0x38, 0xAC, + 0x82, 0x21, 0x8C, 0x98, 0x4D, 0x52, 0x73, 0x7C, 0xF1, 0x01, 0x5F, 0x0F, + 0xEA, 0xE9, 0xBE, 0x46, 0x93, 0xBB, 0xBF, 0x1E, 0x87, 0xEB, 0x1E, 0x3A, + 0x83, 0xA3, 0xBA, 0xBC, 0x73, 0xA9, 0x0C, 0x29, 0x4A, 0x7B, 0xE2, 0xF1, + 0x8E, 0xA2, 0x1C, 0xC5, 0x58, 0x8E, 0x38, 0x7A, 0x30, 0x74, 0xB8, 0x12, + 0x73, 0x42, 0x6D, 0xC1, 0x9E, 0x58, 0x38, 0x71, 0x86, 0x6B, 0x9C, 0x8D, + 0x87, 0xC4, 0x68, 0x8F, 0xD3, 0x99, 0x77, 0xA4, 0x6C, 0x45, 0x8B, 0x80, + 0x21, 0x32, 0x96, 0x72, 0x34, 0x1D, 0x91, 0x59, 0xEA, 0xCA, 0x5C, 0x9C, + 0xCD, 0xE6, 0xB3, 0x06, 0x00, 0xFA, 0xCE, 0x2B, 0xFF, 0xA7, 0x26, 0xB2, + 0xB7, 0x3E, 0x6A, 0x85, 0xB3, 0x68, 0xEA, 0x09, 0x83, 0x00, 0x10, 0xA1, + 0x25, 0x03, 0x68, 0xFA, 0x10, 0xB1, 0x64, 0x97, 0x68, 0x1E, 0x8B, 0xF7, + 0x29, 0x10, 0x0F, 0x12, 0x66, 0xAC, 0x09, 0x31, 0x6D, 0xF7, 0x7D, 0xEB, + 0x83, 0x33, 0xB4, 0x9C, 0x35, 0xD3, 0xA6, 0x82, 0xD1, 0x00, 0x59, 0x43, + 0x78, 0x1C, 0xB8, 0x61, 0x58, 0x8E, 0x3A, 0x6B, 0x3C, 0x6A, 0xF7, 0xB7, + 0x02, 0x8D, 0x9A, 0x1B, 0x63, 0x9C, 0xB3, 0x29, 0xC5, 0xB6, 0x0D, 0xDB, + 0x7D, 0xA7, 0x4F, 0xAB, 0x7C, 0xB4, 0x21, 0x26, 0x66, 0xB6, 0xC6, 0xB0, + 0x48, 0x4C, 0x3C, 0xA9, 0x6C, 0x48, 0xA9, 0xEB, 0x35, 0x2C, 0x4B, 0x90, + 0x33, 0xF4, 0x00, 0x01, 0xAC, 0x21, 0x37, 0x6D, 0x9C, 0xA5, 0xC4, 0xBC, + 0x3B, 0xF8, 0xFD, 0xB1, 0x46, 0x55, 0x10, 0x91, 0x01, 0x51, 0x80, 0x8E, + 0x9E, 0x46, 0x40, 0x38, 0xA2, 0xF4, 0x9C, 0xE3, 0xAE, 0xB4, 0x48, 0x2C, + 0x12, 0x35, 0x47, 0x3F, 0x8F, 0xBC, 0x92, 0x97, 0x95, 0x55, 0x25, 0x00, + 0xA8, 0xA6, 0x19, 0x13, 0x1A, 0x40, 0xEF, 0x93, 0x88, 0x68, 0xBA, 0xBF, + 0x0E, 0xB2, 0xB6, 0x02, 0x88, 0x91, 0x0D, 0x32, 0x11, 0x11, 0x8B, 0x35, + 0x46, 0x72, 0x6E, 0x5C, 0xE6, 0x53, 0xF6, 0x7D, 0x88, 0x89, 0xE3, 0xA1, + 0x6F, 0xFB, 0x6C, 0x7C, 0x11, 0x02, 0x82, 0xF6, 0x6A, 0xC2, 0xB6, 0xF7, + 0xD6, 0xD0, 0x74, 0x8A, 0x88, 0xA0, 0x95, 0xAA, 0x83, 0x7A, 0xA2, 0xEC, + 0x89, 0xD0, 0x01, 0x04, 0xE7, 0x6C, 0xB6, 0x7A, 0x52, 0x52, 0x50, 0xA9, + 0x7F, 0xAA, 0x9C, 0x4D, 0xB9, 0xAC, 0x27, 0x6B, 0x5F, 0x6D, 0x58, 0x27, + 0x92, 0xF9, 0x96, 0xB7, 0x9B, 0xCD, 0x76, 0xB3, 0x35, 0xD6, 0x34, 0x55, + 0x7D, 0x7D, 0xBD, 0x7A, 0xFD, 0xE6, 0xFA, 0xF2, 0xE2, 0xBC, 0xEF, 0xFB, + 0x10, 0xC3, 0xE3, 0xC7, 0x0F, 0x39, 0x31, 0x20, 0x12, 0x19, 0xE6, 0x74, + 0xBB, 0xDA, 0xEC, 0x0E, 0xDD, 0xA1, 0xF5, 0xBA, 0xB6, 0x07, 0xF3, 0xC9, + 0x18, 0x63, 0x0C, 0xF5, 0xBD, 0x6F, 0xBB, 0x2E, 0xF8, 0x80, 0x44, 0xD6, + 0xE2, 0x6C, 0x36, 0x5D, 0xAD, 0xB7, 0x1C, 0xD2, 0xFE, 0xD0, 0x26, 0xE6, + 0x49, 0x53, 0x6B, 0x7E, 0x86, 0xB3, 0xD6, 0x3A, 0x25, 0xB8, 0x54, 0xC5, + 0x73, 0xDF, 0x83, 0x55, 0x64, 0x22, 0xBB, 0x86, 0x06, 0xFD, 0x96, 0xD3, + 0x2C, 0xA0, 0xAC, 0x85, 0x41, 0x7E, 0x32, 0xE8, 0x20, 0x64, 0x64, 0x62, + 0xCA, 0x44, 0x2C, 0xA5, 0xE9, 0xB0, 0x2E, 0x9F, 0xF1, 0xBA, 0x45, 0x84, + 0xC4, 0xB1, 0x28, 0x30, 0x28, 0xA4, 0x3B, 0x59, 0x93, 0x49, 0x09, 0x85, + 0x0D, 0x88, 0x06, 0xCA, 0x16, 0xA2, 0x03, 0x9B, 0x95, 0x70, 0xCE, 0xC3, + 0x2F, 0x97, 0xC8, 0x73, 0x91, 0x55, 0x62, 0xD9, 0x7F, 0xCB, 0x11, 0xF9, + 0x7F, 0x28, 0x59, 0x87, 0x8F, 0x13, 0x68, 0x01, 0x09, 0x84, 0x8F, 0x5C, + 0x6C, 0xEA, 0x32, 0x62, 0x66, 0x5B, 0xBA, 0x8D, 0xA0, 0xAE, 0x2D, 0x3E, + 0xAA, 0x96, 0xF1, 0xDA, 0x39, 0xD1, 0x6B, 0x30, 0x2A, 0xD7, 0x19, 0x8D, + 0xE5, 0x1D, 0x75, 0x76, 0x5F, 0x1B, 0xE6, 0x13, 0x0B, 0xDA, 0x10, 0xC6, + 0x9C, 0x76, 0x55, 0x86, 0x97, 0xF3, 0x56, 0xA1, 0x7A, 0x0E, 0xA1, 0x28, + 0x68, 0x8E, 0xC0, 0x25, 0x4F, 0x96, 0x59, 0x94, 0xD0, 0x58, 0xF7, 0x07, + 0xCE, 0xAD, 0x0A, 0x50, 0x40, 0xAC, 0x3E, 0x3A, 0x95, 0xBE, 0x32, 0xC3, + 0x63, 0x29, 0x0C, 0x36, 0x44, 0x93, 0xCA, 0x4C, 0x9B, 0xCA, 0x3A, 0x2B, + 0x22, 0x4A, 0xB6, 0xB5, 0x3F, 0xF4, 0xCC, 0x9C, 0x9B, 0xB9, 0xF5, 0x21, + 0x46, 0x96, 0x82, 0xBF, 0x74, 0x57, 0x00, 0x40, 0x6D, 0x2F, 0x27, 0x00, + 0x4D, 0x6D, 0xAD, 0xA1, 0x49, 0x6D, 0x99, 0xA5, 0x0F, 0xB1, 0x0F, 0x09, + 0x24, 0xA7, 0x83, 0x69, 0x94, 0x90, 0x0B, 0x79, 0x61, 0xDB, 0x7B, 0xC0, + 0xDC, 0x70, 0xD9, 0x87, 0x04, 0xE0, 0xFB, 0x10, 0xB5, 0xA1, 0xA2, 0x35, + 0xD4, 0x34, 0x55, 0xF1, 0xE2, 0x50, 0xF9, 0x01, 0x87, 0x11, 0xFC, 0xE0, + 0xCE, 0x70, 0x32, 0xD0, 0xA3, 0x11, 0xA7, 0xAA, 0xB2, 0x6D, 0xEF, 0xDB, + 0x3E, 0xF8, 0xC0, 0x21, 0x26, 0x40, 0x0C, 0x31, 0x31, 0x8B, 0xB3, 0x04, + 0x90, 0x2B, 0x6C, 0xCE, 0xE7, 0x93, 0x83, 0x55, 0x9E, 0x0E, 0x09, 0x91, + 0x01, 0x30, 0x31, 0xEF, 0x3A, 0x8F, 0x00, 0x88, 0x38, 0x6D, 0x5C, 0x53, + 0xD9, 0xA6, 0xB2, 0x89, 0xB9, 0x0F, 0x47, 0x46, 0x06, 0x04, 0xA0, 0x63, + 0x76, 0xCC, 0x07, 0x36, 0xC6, 0xFC, 0x6B, 0x51, 0x72, 0x06, 0x41, 0x0C, + 0x45, 0xF5, 0x6A, 0x12, 0x66, 0x0D, 0x98, 0xC7, 0x1F, 0x88, 0xD0, 0x8C, + 0xBE, 0x42, 0x84, 0x10, 0x93, 0xB5, 0x64, 0x0C, 0x84, 0x08, 0x88, 0x50, + 0x39, 0x53, 0x59, 0xAD, 0x2B, 0x05, 0x6B, 0x31, 0xAA, 0xF3, 0x53, 0x80, + 0x85, 0x09, 0x20, 0x04, 0xE8, 0x43, 0xD4, 0xC6, 0x54, 0xCC, 0x0C, 0x08, + 0xA6, 0x44, 0xF7, 0xD5, 0x2C, 0x0C, 0x91, 0x0F, 0x9D, 0x57, 0x6A, 0x5C, + 0x24, 0x4D, 0x64, 0xD5, 0xB2, 0xA4, 0xEC, 0x07, 0xD3, 0x3E, 0x58, 0x00, + 0x60, 0x08, 0x9D, 0x55, 0x2A, 0x8B, 0xA4, 0xD1, 0x55, 0x22, 0xB4, 0xD6, + 0x5E, 0x2C, 0x67, 0x31, 0xA5, 0x10, 0x92, 0x52, 0xB8, 0x68, 0x7F, 0x62, + 0xF5, 0x42, 0xC6, 0x28, 0x29, 0x84, 0xED, 0x66, 0xA3, 0x98, 0x7A, 0xEB, + 0xF7, 0xC0, 0x5C, 0x39, 0xB3, 0xDD, 0xB7, 0xB6, 0xB2, 0x0F, 0x1F, 0x5C, + 0xA4, 0x94, 0x5E, 0xBF, 0x7A, 0xEB, 0xBD, 0x5F, 0x2C, 0xE6, 0xB7, 0xEB, + 0xDD, 0xD5, 0xCD, 0x3A, 0x86, 0xC4, 0x12, 0x11, 0x51, 0xB5, 0xEA, 0xE0, + 0xE6, 0x73, 0xCE, 0xED, 0xF6, 0x87, 0x94, 0xD2, 0x62, 0x3E, 0x67, 0xE6, + 0xBA, 0xAE, 0x91, 0xB0, 0x69, 0x6A, 0x00, 0x64, 0x91, 0xDD, 0xFE, 0xF0, + 0xE0, 0x72, 0xC9, 0x9C, 0x82, 0xF7, 0x86, 0xC8, 0x9A, 0x3A, 0xF7, 0xF1, + 0xC6, 0x42, 0xE8, 0xF3, 0x27, 0x3E, 0x77, 0x71, 0x04, 0x02, 0x1E, 0x1B, + 0x43, 0x0C, 0x7E, 0xAB, 0xB2, 0xF8, 0x41, 0x12, 0x03, 0x02, 0x9A, 0xFC, + 0x54, 0x65, 0x7E, 0x87, 0x69, 0xCD, 0x4C, 0xCD, 0x19, 0x4D, 0x70, 0x61, + 0x49, 0x11, 0x31, 0xE3, 0x48, 0x6D, 0xF6, 0x2A, 0x1E, 0x5D, 0x5B, 0xC3, + 0xD5, 0x52, 0x92, 0x01, 0x87, 0x42, 0xD9, 0x17, 0x8F, 0x8A, 0xB0, 0x80, + 0xBE, 0xFC, 0x30, 0x9C, 0xBB, 0x8D, 0x94, 0xDF, 0xB3, 0x80, 0x40, 0x56, + 0xC2, 0x47, 0xF7, 0x5D, 0x06, 0x92, 0x65, 0xE3, 0x19, 0xE4, 0x50, 0x78, + 0x5C, 0x6D, 0x2A, 0x00, 0x80, 0x04, 0x22, 0xA7, 0xE1, 0xDD, 0xB2, 0x88, + 0xF2, 0xE5, 0x4E, 0xD6, 0xD7, 0x78, 0x89, 0x9D, 0x80, 0xB2, 0x13, 0x0D, + 0x88, 0x88, 0x3A, 0x59, 0x43, 0xA9, 0x3F, 0xA4, 0xEC, 0xC1, 0x14, 0x51, + 0xF6, 0x5A, 0xED, 0xDA, 0x47, 0x39, 0x4D, 0x4E, 0xB2, 0x91, 0x9F, 0xC7, + 0xA2, 0xCC, 0xC8, 0x10, 0x9C, 0x15, 0xC1, 0x1C, 0xFA, 0x05, 0x41, 0x44, + 0x3B, 0xB8, 0x38, 0x51, 0xA9, 0xCB, 0xEE, 0xCE, 0x7A, 0x4A, 0x29, 0x24, + 0xDC, 0x77, 0xBE, 0x8A, 0xC9, 0x18, 0xEA, 0x7D, 0x50, 0xD2, 0x7D, 0x66, + 0x09, 0x29, 0x69, 0xD2, 0xA6, 0xBE, 0x8E, 0x0A, 0x9F, 0xA6, 0x5E, 0xFA, + 0xC0, 0x81, 0x93, 0x30, 0x20, 0xE0, 0xBE, 0xF5, 0xC6, 0x60, 0x53, 0xD9, + 0x49, 0xED, 0x1A, 0x67, 0xD6, 0x87, 0x5E, 0x3D, 0x38, 0x1A, 0x95, 0x5B, + 0xCC, 0x1A, 0x04, 0x50, 0x02, 0x55, 0x4E, 0xE2, 0x43, 0x42, 0x81, 0x94, + 0x64, 0x25, 0x9D, 0x21, 0x12, 0x90, 0xCA, 0xD0, 0xD9, 0xBC, 0x39, 0x5B, + 0x4C, 0xE9, 0xC8, 0xDE, 0x71, 0xCC, 0xA3, 0x1B, 0x90, 0xD7, 0x71, 0x7A, + 0xE4, 0xCE, 0x70, 0xDF, 0xD7, 0x65, 0xFA, 0xB3, 0x35, 0xD4, 0x54, 0xCE, + 0xFB, 0x98, 0x58, 0x18, 0xC8, 0x7B, 0xED, 0x2D, 0x24, 0x21, 0xB1, 0x21, + 0x10, 0x81, 0x98, 0xB8, 0xF7, 0x51, 0x8B, 0x0A, 0x7B, 0xCF, 0x02, 0x90, + 0x98, 0x39, 0x60, 0x4E, 0x99, 0x42, 0x88, 0x8A, 0x3D, 0xD5, 0xD6, 0xB3, + 0xA4, 0x93, 0x14, 0x52, 0x2A, 0x60, 0xEA, 0xCE, 0x48, 0x8E, 0xD5, 0x6E, + 0x79, 0x60, 0xC8, 0x16, 0xAB, 0x80, 0x7A, 0xD0, 0x00, 0x32, 0xA5, 0x55, + 0x39, 0x4F, 0x08, 0x8A, 0x85, 0xA9, 0xDB, 0x2C, 0x01, 0x80, 0x3A, 0xFB, + 0x84, 0x10, 0x9C, 0x25, 0x67, 0x8C, 0x73, 0x46, 0xF3, 0x2D, 0xAC, 0x35, + 0x22, 0xD0, 0xFB, 0x28, 0xCC, 0x7D, 0x88, 0x80, 0x68, 0x88, 0xB4, 0xB2, + 0xB5, 0x20, 0xA6, 0x92, 0x30, 0xC8, 0x9C, 0x18, 0x58, 0x24, 0xB2, 0x38, + 0x81, 0x0E, 0xA2, 0x0F, 0x91, 0xB4, 0x9A, 0x62, 0x52, 0x29, 0x81, 0x47, + 0x52, 0xFA, 0x4E, 0x96, 0xC9, 0xA4, 0xAA, 0x9C, 0x92, 0x91, 0x20, 0x8B, + 0x38, 0x6B, 0xAC, 0x25, 0x55, 0x72, 0x25, 0xAF, 0x58, 0xAC, 0x31, 0x4E, + 0x4B, 0x8E, 0x58, 0x5C, 0x65, 0x99, 0x19, 0x11, 0x0E, 0xFB, 0xFD, 0x9B, + 0x37, 0x57, 0x5D, 0xE7, 0x53, 0xE2, 0xD9, 0x7C, 0xDA, 0x77, 0xFD, 0x6E, + 0x77, 0x88, 0x29, 0xFB, 0x5E, 0x0F, 0x87, 0xF6, 0xF9, 0x8F, 0xAF, 0xDA, + 0x43, 0x07, 0x00, 0x40, 0xB8, 0xDE, 0xB6, 0xDB, 0xDD, 0x41, 0x45, 0xCB, + 0x5A, 0xA3, 0xEC, 0x7D, 0xC6, 0x18, 0xA8, 0x50, 0x41, 0x3E, 0x77, 0x7E, + 0xB1, 0x98, 0x19, 0x43, 0x4D, 0xD3, 0xC4, 0x14, 0x43, 0x08, 0x49, 0xE4, + 0xE1, 0x83, 0xCB, 0x1F, 0x5E, 0xBC, 0x6A, 0xAA, 0x6A, 0x3A, 0x99, 0x58, + 0x63, 0x43, 0x88, 0xCC, 0xE2, 0x2A, 0xA3, 0x3B, 0xDD, 0xB1, 0xAA, 0xFA, + 0x6E, 0x5B, 0x55, 0x9D, 0x8F, 0x3F, 0xA3, 0xDD, 0x74, 0x0B, 0x91, 0xEC, + 0xC0, 0x2A, 0x9F, 0xB2, 0x82, 0x02, 0xA5, 0x4C, 0x67, 0x80, 0x28, 0x02, + 0x83, 0x17, 0x7A, 0xBC, 0xC4, 0xD4, 0x53, 0x29, 0x92, 0x99, 0xC2, 0x8C, + 0x25, 0x42, 0x75, 0x0B, 0x49, 0xF1, 0xD0, 0x0C, 0xDC, 0xF9, 0x52, 0x5C, + 0xDB, 0xBA, 0x03, 0x1D, 0x53, 0x25, 0x8E, 0x34, 0x19, 0xA3, 0xC7, 0x2F, + 0xAB, 0x3B, 0x23, 0x30, 0x4D, 0x76, 0xD3, 0x4D, 0x10, 0x11, 0x91, 0xA4, + 0x94, 0x4C, 0x16, 0x74, 0x06, 0x00, 0x80, 0x03, 0xD9, 0xD7, 0x9D, 0x1D, + 0x1D, 0x65, 0xBC, 0x70, 0x8A, 0x54, 0xE6, 0x91, 0x19, 0x03, 0xCC, 0xE1, + 0x14, 0x81, 0x62, 0x11, 0x1E, 0xB1, 0x67, 0x36, 0x84, 0x71, 0x54, 0xA5, + 0x34, 0x08, 0xFC, 0xA0, 0x97, 0xCB, 0x5D, 0xB2, 0x32, 0x12, 0xC4, 0x52, + 0x8C, 0x80, 0x45, 0xC0, 0xB3, 0xE0, 0x2B, 0xA2, 0x54, 0x1B, 0xFD, 0x78, + 0xF7, 0xD1, 0xC3, 0x8C, 0xB4, 0xD8, 0x51, 0xE5, 0x22, 0xA2, 0x06, 0x1C, + 0xC7, 0x41, 0x5F, 0x54, 0x27, 0xEE, 0xA0, 0x41, 0xFB, 0x90, 0x7C, 0x4C, + 0x5D, 0x1F, 0x39, 0xF3, 0x9C, 0x40, 0x92, 0xF2, 0x53, 0xB9, 0xB7, 0xBA, + 0x1B, 0x35, 0x90, 0xE7, 0xAC, 0x99, 0x34, 0xD4, 0xB0, 0x15, 0x91, 0x3E, + 0x24, 0x66, 0x8E, 0x89, 0x0F, 0x5D, 0x08, 0x31, 0x35, 0x95, 0x9B, 0xD4, + 0x2E, 0x50, 0xEA, 0x7C, 0x44, 0xC4, 0xBA, 0xB2, 0xD3, 0xDA, 0xF9, 0x18, + 0xD5, 0x37, 0x94, 0xB8, 0x94, 0x3D, 0x20, 0x30, 0x73, 0xEF, 0x63, 0x53, + 0x59, 0x53, 0x51, 0x62, 0xF1, 0x31, 0xD9, 0x60, 0x94, 0xF7, 0xDD, 0xE5, + 0xEA, 0xA5, 0xA3, 0xE6, 0x3A, 0x51, 0x5B, 0x27, 0x73, 0x30, 0x4E, 0x6A, + 0x1F, 0xBE, 0x11, 0xC4, 0x99, 0x12, 0xDE, 0x6F, 0x0E, 0x7D, 0x88, 0x95, + 0x31, 0x7D, 0x4C, 0xDE, 0x47, 0x7D, 0xDF, 0x90, 0x04, 0x23, 0xB7, 0x7D, + 0x34, 0x86, 0x10, 0x20, 0x24, 0xCE, 0x5B, 0xBB, 0x88, 0x29, 0xA0, 0x30, + 0x32, 0x1F, 0x7A, 0x5F, 0x59, 0x0B, 0x00, 0x2C, 0xE0, 0x2C, 0x99, 0x9C, + 0x11, 0x0E, 0xC5, 0xCD, 0x32, 0xCC, 0xD6, 0x9D, 0x90, 0x90, 0x3E, 0x8C, + 0x0A, 0x30, 0x31, 0x88, 0x28, 0x67, 0x34, 0x61, 0xF6, 0xEA, 0x40, 0x31, + 0x54, 0x89, 0x10, 0x89, 0xB2, 0x6F, 0x51, 0x23, 0xC5, 0xE3, 0xEB, 0xD4, + 0xCE, 0xAA, 0x1B, 0xCB, 0x68, 0x9D, 0x86, 0x40, 0xEF, 0x23, 0x33, 0xE7, + 0x91, 0x04, 0xE8, 0xBD, 0x07, 0x54, 0x23, 0x42, 0x49, 0x32, 0xF4, 0xEE, + 0xC2, 0x90, 0x59, 0xEE, 0x26, 0x95, 0x55, 0x90, 0x35, 0x9F, 0x56, 0x4A, + 0x4F, 0x14, 0x42, 0x62, 0x94, 0xC8, 0x69, 0x70, 0xDC, 0x78, 0x8D, 0xB4, + 0x66, 0xF2, 0x4F, 0xB0, 0x96, 0xAC, 0x35, 0x29, 0x89, 0xB5, 0x64, 0xAD, + 0x55, 0x49, 0x4D, 0x29, 0xE9, 0x16, 0x58, 0x4D, 0xAA, 0x18, 0xC2, 0x7E, + 0xB7, 0x47, 0x80, 0x43, 0xDB, 0xED, 0xB6, 0xFB, 0xF5, 0x76, 0xFF, 0xF0, + 0xF2, 0xFC, 0x70, 0x68, 0xDF, 0xBC, 0xBB, 0xB9, 0x5D, 0x1D, 0x9C, 0x73, + 0x64, 0x60, 0xB7, 0x3B, 0x68, 0x9B, 0x02, 0x66, 0x06, 0xA1, 0xED, 0x7E, + 0xBF, 0x3B, 0xB4, 0x75, 0x5D, 0x4F, 0xA7, 0xD3, 0xDD, 0xFE, 0xBA, 0x4C, + 0x22, 0x50, 0xE6, 0xB0, 0x16, 0x25, 0x27, 0x3D, 0x1C, 0xBA, 0xBA, 0x76, + 0xDE, 0x47, 0x1F, 0x42, 0x0C, 0x71, 0x3A, 0x9D, 0xEC, 0xDB, 0xD6, 0x59, + 0x67, 0x9D, 0x6B, 0xDB, 0x76, 0x36, 0x6D, 0x0A, 0xB7, 0x1D, 0x65, 0xF7, + 0x88, 0x0C, 0xAB, 0xF3, 0xDE, 0xAE, 0x56, 0xA0, 0xD4, 0x58, 0x2A, 0x8A, + 0x7E, 0x10, 0x01, 0xCD, 0x03, 0xC9, 0xAE, 0x28, 0xD5, 0x37, 0x31, 0xA5, + 0x58, 0xC6, 0x24, 0xAF, 0xC9, 0x62, 0x80, 0x67, 0xCD, 0x51, 0x1C, 0x64, + 0xA2, 0x01, 0xB7, 0xCC, 0xBE, 0x8D, 0x00, 0x80, 0x09, 0xAD, 0x31, 0x26, + 0x31, 0x99, 0xBC, 0x31, 0x29, 0x01, 0x0E, 0x33, 0x94, 0x04, 0x73, 0x85, + 0x67, 0xFA, 0x54, 0xC5, 0xD3, 0x2A, 0x59, 0x9B, 0x8D, 0x9E, 0x50, 0xE4, + 0xCE, 0x7F, 0x61, 0xF0, 0xC0, 0xAB, 0x16, 0x1B, 0x32, 0xDA, 0xB4, 0xF1, + 0x87, 0x2E, 0x69, 0xD6, 0x00, 0x02, 0x02, 0xDC, 0xCB, 0xC9, 0x18, 0x2B, + 0x9A, 0x91, 0x6F, 0xF0, 0x8E, 0xB8, 0x16, 0xA1, 0xCD, 0xD7, 0x80, 0x41, + 0x03, 0xDD, 0xC5, 0x0D, 0xA7, 0x14, 0x06, 0x23, 0xDF, 0xF4, 0xF8, 0x82, + 0xA3, 0x1F, 0xF2, 0x30, 0xA6, 0xD1, 0x90, 0x96, 0x6B, 0xE6, 0x23, 0x3F, + 0x74, 0x56, 0xFE, 0x72, 0x4C, 0xEF, 0xAD, 0x67, 0xD9, 0x94, 0xC7, 0xAF, + 0x18, 0x3B, 0xE5, 0x42, 0xB9, 0xF5, 0x2F, 0x43, 0x1A, 0x93, 0x82, 0xEB, + 0x0C, 0x8F, 0xD2, 0x55, 0xF2, 0x85, 0xCA, 0x34, 0x86, 0xC4, 0xA9, 0x0B, + 0xCA, 0x39, 0x85, 0x1A, 0x5E, 0x11, 0x61, 0x11, 0x63, 0x51, 0x04, 0x36, + 0x87, 0x5E, 0x78, 0x18, 0x2F, 0x69, 0xFB, 0xA0, 0x1D, 0x7D, 0x20, 0xF3, + 0xFA, 0x00, 0x12, 0x1A, 0x42, 0x83, 0x28, 0x20, 0x54, 0x82, 0x1A, 0x89, + 0x39, 0x86, 0x78, 0xD3, 0x79, 0x16, 0x5E, 0xCC, 0xA6, 0x1A, 0x27, 0x1D, + 0xA7, 0x29, 0x0E, 0xAF, 0x3A, 0x14, 0x7E, 0x8E, 0xB5, 0xD8, 0x58, 0x0C, + 0xC6, 0x23, 0x82, 0x88, 0x4D, 0xED, 0xE2, 0xB4, 0x86, 0x16, 0x7A, 0x9F, + 0x26, 0x95, 0xAB, 0xAD, 0xD9, 0x77, 0x3E, 0x24, 0x86, 0x32, 0xF7, 0x21, + 0x96, 0x99, 0x06, 0xD1, 0x5A, 0xD5, 0xB2, 0x71, 0x00, 0x27, 0xF0, 0x90, + 0x98, 0x73, 0xC7, 0x04, 0x65, 0x43, 0x1C, 0x89, 0xC2, 0x71, 0x99, 0x0C, + 0xD2, 0x83, 0x79, 0x27, 0x2C, 0x66, 0x1B, 0x08, 0xB3, 0x56, 0xE1, 0x8A, + 0x76, 0xE1, 0x55, 0x5E, 0xDC, 0x81, 0xE3, 0x4E, 0xCD, 0x73, 0x6B, 0xE8, + 0x28, 0x46, 0xC7, 0xD9, 0xC9, 0x23, 0x90, 0x52, 0x8A, 0x09, 0x9D, 0xA5, + 0x90, 0xD2, 0xAE, 0xED, 0xB5, 0xE9, 0x14, 0x22, 0x86, 0x90, 0x92, 0x08, + 0xD1, 0x20, 0x58, 0x00, 0x08, 0xA4, 0x40, 0x85, 0x00, 0x11, 0xAC, 0x98, + 0xF3, 0xE5, 0xD4, 0x1A, 0x83, 0x28, 0x93, 0x49, 0x0D, 0x00, 0x5D, 0xE7, + 0xB5, 0xEB, 0xA5, 0x88, 0x28, 0x42, 0x24, 0x44, 0x32, 0xC8, 0xC5, 0x9C, + 0x2C, 0xC2, 0x2A, 0xC6, 0x68, 0x63, 0x6A, 0x8D, 0xB3, 0x6A, 0x74, 0x45, + 0x88, 0x4C, 0xDF, 0x75, 0xAB, 0x9B, 0xDB, 0xDB, 0xDB, 0xAD, 0x20, 0x12, + 0x11, 0xA3, 0xD9, 0xED, 0xBB, 0xDD, 0xFE, 0x4D, 0xE7, 0x63, 0x33, 0x99, + 0x2C, 0xCF, 0xE6, 0x6F, 0xDE, 0x5E, 0x1F, 0xDA, 0xCE, 0x39, 0x63, 0x88, + 0x42, 0x9B, 0xAC, 0xB5, 0x29, 0x85, 0x3E, 0xC4, 0xBA, 0xAE, 0x1F, 0x3F, + 0x7E, 0xB8, 0xDD, 0xED, 0xAB, 0xAA, 0x8A, 0x29, 0x69, 0xF1, 0x80, 0xCA, + 0x0F, 0x00, 0xD4, 0x35, 0x05, 0x1F, 0xB7, 0xFB, 0x76, 0xD7, 0x76, 0x88, + 0x50, 0x55, 0xAE, 0xA9, 0x2A, 0x66, 0x7E, 0x77, 0x75, 0x7B, 0x71, 0xB6, + 0x6C, 0xBB, 0x2E, 0xF8, 0xA8, 0x39, 0x2B, 0x05, 0x4F, 0x0C, 0x7B, 0xC9, + 0x71, 0x69, 0xE9, 0x86, 0x0B, 0x00, 0x08, 0x85, 0xD3, 0x7A, 0xFC, 0x91, + 0x21, 0x98, 0xA8, 0xA5, 0xD2, 0x92, 0x52, 0x4A, 0x51, 0x8E, 0x70, 0x2C, + 0x1D, 0x79, 0x01, 0x53, 0x3C, 0x72, 0x93, 0x96, 0x49, 0x2D, 0xB8, 0x83, + 0x40, 0x04, 0x94, 0xFB, 0x51, 0x7F, 0xD5, 0x3F, 0xA6, 0x28, 0xC6, 0x20, + 0x15, 0xE6, 0x75, 0x3D, 0x59, 0x8A, 0xE9, 0x3A, 0xF6, 0xFD, 0x43, 0x86, + 0x62, 0xDA, 0xA7, 0x4E, 0x10, 0x8E, 0x6E, 0x93, 0xE3, 0xBB, 0x0C, 0xA1, + 0xD4, 0xEC, 0x56, 0xCA, 0x37, 0x1A, 0x24, 0x6D, 0x38, 0x45, 0x40, 0xC8, + 0x64, 0x1F, 0xFE, 0x20, 0x7B, 0xBA, 0xC1, 0x8E, 0xD2, 0xF5, 0xC7, 0x08, + 0xE0, 0x74, 0xD3, 0x95, 0xA3, 0x45, 0x9A, 0x13, 0xC3, 0x8B, 0x67, 0xE2, + 0x38, 0x84, 0xE3, 0x55, 0x36, 0x7E, 0x86, 0x71, 0x86, 0xC7, 0xFD, 0xCF, + 0x18, 0xBE, 0x7D, 0x70, 0xBF, 0xF9, 0x53, 0xE7, 0x1E, 0xD5, 0xCE, 0xE8, + 0x18, 0x9B, 0x49, 0x9A, 0x04, 0x00, 0x85, 0x94, 0xDE, 0x4D, 0xF7, 0x03, + 0x66, 0x40, 0x4A, 0xA3, 0xC6, 0x6A, 0x74, 0xB4, 0x5B, 0x87, 0xDB, 0xEB, + 0xCE, 0x09, 0x86, 0x70, 0xE0, 0x4C, 0x67, 0x61, 0x60, 0xDA, 0xB5, 0x7E, + 0xB8, 0x9F, 0x41, 0x9C, 0xD6, 0x15, 0x19, 0x4C, 0x07, 0x9F, 0x54, 0x61, + 0xA1, 0x1A, 0x62, 0x0C, 0x05, 0xC7, 0xEB, 0x65, 0x55, 0x8B, 0x29, 0xB6, + 0x64, 0x6D, 0x86, 0x86, 0xB9, 0xD7, 0x31, 0x20, 0x56, 0xD6, 0xC5, 0x18, + 0x0F, 0x07, 0x99, 0xCD, 0x1A, 0x75, 0xB8, 0xDE, 0x1F, 0x3E, 0xB8, 0x6B, + 0x69, 0x22, 0x7E, 0xC0, 0x55, 0x39, 0x06, 0xC6, 0xF3, 0x69, 0x53, 0x39, + 0x7B, 0x75, 0xBB, 0xDB, 0xB7, 0x3E, 0x24, 0x6E, 0x7D, 0x8C, 0xB9, 0xE8, + 0x1F, 0x86, 0x9C, 0xB5, 0xBC, 0x7F, 0x03, 0xD2, 0x5D, 0xFE, 0x4D, 0x16, + 0x50, 0x5E, 0x1A, 0x50, 0xB1, 0x88, 0xC3, 0xF6, 0xA8, 0x05, 0xD1, 0x47, + 0xE0, 0x4B, 0x25, 0xFD, 0x6A, 0xD8, 0x33, 0x73, 0xE8, 0xA8, 0x30, 0xC5, + 0x0C, 0xFB, 0x0C, 0x22, 0xD8, 0xA3, 0xDB, 0x05, 0x0C, 0x12, 0x20, 0x94, + 0x9E, 0x8F, 0x32, 0xEC, 0x63, 0x88, 0xA8, 0x0C, 0x73, 0x06, 0x09, 0x00, + 0x25, 0xC7, 0x2B, 0x23, 0x80, 0x89, 0x31, 0x49, 0xA1, 0x32, 0x15, 0x90, + 0xD1, 0x84, 0x67, 0x93, 0x8A, 0x00, 0x04, 0x60, 0x3E, 0x6F, 0xA6, 0x93, + 0xDA, 0x18, 0xE5, 0xBC, 0x20, 0x44, 0x68, 0x9A, 0xAA, 0x56, 0xD2, 0xA1, + 0x98, 0x88, 0x50, 0x2B, 0x28, 0x38, 0x73, 0xF6, 0xB3, 0x31, 0xA0, 0x88, + 0x6C, 0x64, 0x29, 0x00, 0x11, 0x32, 0xA3, 0xB5, 0x36, 0xC6, 0xB8, 0xDB, + 0x6E, 0xF7, 0xDB, 0xFD, 0xED, 0x7A, 0xBB, 0xD9, 0x75, 0x31, 0x25, 0x16, + 0xB0, 0xD6, 0x9E, 0x5F, 0x5E, 0xEC, 0x76, 0x6D, 0xB7, 0x5B, 0xF5, 0xF1, + 0xB0, 0xDF, 0x1D, 0x0E, 0x6D, 0x6B, 0x8D, 0x4D, 0x91, 0x13, 0x0A, 0x11, + 0x22, 0xA6, 0xAA, 0x72, 0x53, 0x6E, 0xC8, 0xDA, 0x57, 0xAF, 0xDF, 0x3A, + 0xE7, 0x16, 0x8B, 0xD9, 0x6A, 0xB5, 0x19, 0x36, 0x2A, 0x95, 0x31, 0x22, + 0x0B, 0x10, 0x63, 0x8A, 0x24, 0x64, 0xAD, 0x8D, 0x31, 0xDD, 0x1C, 0x36, + 0x4D, 0x53, 0xA5, 0x24, 0xB1, 0x28, 0x97, 0x9B, 0xDB, 0xED, 0xE3, 0x87, + 0x4B, 0x10, 0x89, 0x29, 0x92, 0x21, 0x42, 0xFB, 0x27, 0x96, 0x8F, 0x6E, + 0x9A, 0x38, 0x2A, 0x86, 0x29, 0x39, 0x0C, 0x70, 0x74, 0x5A, 0x71, 0xD2, + 0x2C, 0x96, 0xC4, 0xCC, 0x91, 0x39, 0x45, 0x4E, 0x43, 0xCB, 0x74, 0x91, + 0x18, 0x4B, 0x6E, 0xDC, 0xB0, 0xC6, 0xF3, 0xD4, 0x0E, 0x60, 0x0D, 0x40, + 0x47, 0x95, 0x11, 0xB0, 0xCC, 0x99, 0x10, 0x6A, 0xF2, 0x79, 0x59, 0x44, + 0x2A, 0xA1, 0xEA, 0x4C, 0xBB, 0xE3, 0xCB, 0x93, 0xA2, 0x84, 0x06, 0xA7, + 0x4F, 0x56, 0x7D, 0x83, 0xB5, 0xAC, 0x02, 0x83, 0x45, 0x18, 0x20, 0xAB, + 0xB3, 0xA2, 0xC8, 0x33, 0x05, 0x98, 0x08, 0x65, 0x7C, 0x92, 0xDD, 0xD2, + 0x59, 0x0D, 0xE4, 0xD3, 0xEE, 0xA8, 0x03, 0xBD, 0xEF, 0x30, 0x66, 0x77, + 0xF7, 0x00, 0x50, 0x5C, 0x9C, 0x51, 0x9E, 0x9A, 0x76, 0x25, 0xBC, 0x76, + 0x0A, 0x6C, 0xC7, 0x3B, 0xF7, 0x08, 0x97, 0x0D, 0x76, 0xD2, 0x78, 0x49, + 0x0E, 0xBF, 0x8E, 0x69, 0xA9, 0x3E, 0x30, 0x65, 0xFA, 0x30, 0xA3, 0x11, + 0xC2, 0xE2, 0x63, 0x1E, 0x4E, 0xB1, 0x43, 0xEA, 0x1D, 0x22, 0x08, 0x09, + 0xE7, 0xD3, 0x04, 0x24, 0xE7, 0x78, 0x94, 0xE7, 0x51, 0x2A, 0xAE, 0x02, + 0x32, 0x07, 0xBE, 0x91, 0x9C, 0x38, 0x71, 0x47, 0x8B, 0xB3, 0x30, 0xB3, + 0xF2, 0x5B, 0x60, 0x12, 0xA1, 0xD2, 0x84, 0xCE, 0x18, 0x34, 0x06, 0x87, + 0xB6, 0x95, 0xC3, 0x60, 0x11, 0xE2, 0x62, 0x52, 0x4F, 0x9B, 0x8A, 0x10, + 0x9D, 0x25, 0xB5, 0xF2, 0x04, 0xC0, 0x19, 0x9A, 0x4D, 0x2A, 0x63, 0x94, + 0xDD, 0xD4, 0x6A, 0xD5, 0x34, 0x16, 0x70, 0x3E, 0xA4, 0xC9, 0x7D, 0x70, + 0x1C, 0xEF, 0xFF, 0x3A, 0x56, 0x73, 0xC7, 0x21, 0x23, 0xA8, 0x10, 0xE6, + 0xD3, 0xEA, 0x76, 0x7B, 0x68, 0xFB, 0xD8, 0x85, 0x14, 0x52, 0x29, 0xB2, + 0x2B, 0xB1, 0x7B, 0xA3, 0xF1, 0x3B, 0x7D, 0x7D, 0x5D, 0x07, 0xCA, 0xE9, + 0xC3, 0x20, 0x05, 0xCA, 0xE6, 0xF9, 0x80, 0x52, 0xFF, 0x01, 0x70, 0xCC, + 0x48, 0x28, 0x3F, 0x0F, 0x5A, 0x4C, 0xC1, 0xB8, 0x08, 0xD3, 0x5D, 0x1B, + 0x47, 0xCA, 0x41, 0xA0, 0x16, 0x0A, 0x83, 0xB1, 0x32, 0xB0, 0x10, 0x1F, + 0xE9, 0x66, 0x00, 0x44, 0xA4, 0x0F, 0x8C, 0x88, 0x62, 0xC1, 0xB0, 0x74, + 0x49, 0x42, 0x64, 0x83, 0x14, 0x22, 0x87, 0xA4, 0x7B, 0x93, 0x18, 0x40, + 0x6B, 0x08, 0x0D, 0xA8, 0x89, 0x93, 0x0A, 0x49, 0x9D, 0xAA, 0x09, 0x43, + 0x28, 0xC2, 0xA3, 0xAA, 0x5D, 0x54, 0x17, 0x8E, 0x96, 0xA6, 0x65, 0x17, + 0x6C, 0xA1, 0x0F, 0x18, 0xB2, 0xC6, 0xAC, 0xA5, 0x51, 0x73, 0x80, 0x3C, + 0x86, 0x9B, 0xF5, 0x66, 0xB3, 0xD9, 0xB6, 0xAD, 0x8F, 0x31, 0xBE, 0x7C, + 0x7D, 0xB5, 0xDB, 0x77, 0x87, 0xB6, 0x0B, 0x31, 0xD5, 0x55, 0x55, 0x37, + 0xF5, 0xF9, 0xF9, 0x12, 0x11, 0x6F, 0x6F, 0x56, 0xEA, 0xE4, 0x65, 0x61, + 0x14, 0x83, 0x00, 0x9A, 0x85, 0xFF, 0xB7, 0x7F, 0xF3, 0xEB, 0xD5, 0x7A, + 0xFB, 0xF6, 0xFD, 0xCD, 0xD3, 0xCF, 0x3E, 0x59, 0x6F, 0xB6, 0xBB, 0xDD, + 0x7E, 0xBC, 0x06, 0xD4, 0x11, 0xDE, 0xF7, 0x3D, 0x97, 0xE6, 0x89, 0x88, + 0xCA, 0xF9, 0x87, 0x00, 0x68, 0x0C, 0x5D, 0x5D, 0xDF, 0x22, 0xA1, 0x35, + 0xE6, 0x7A, 0xB5, 0x35, 0x64, 0x58, 0x92, 0xF2, 0xFF, 0xD5, 0x35, 0x10, + 0x9A, 0xA3, 0xD1, 0xF7, 0xE1, 0xF5, 0x01, 0x79, 0x0B, 0x15, 0x29, 0xDE, + 0xB0, 0x94, 0x92, 0xA4, 0x98, 0x7F, 0xCA, 0x0D, 0x86, 0x25, 0xC5, 0x90, + 0x1B, 0x2E, 0x1E, 0x19, 0x51, 0xC7, 0xCE, 0x20, 0x19, 0x76, 0x9E, 0x63, + 0xAC, 0xAD, 0xF4, 0x9D, 0xC5, 0x01, 0x87, 0x0F, 0x6B, 0x7E, 0x40, 0x8B, + 0x58, 0x8A, 0x07, 0xA1, 0xF0, 0x60, 0x0F, 0xD8, 0x44, 0xCA, 0xDA, 0xD0, + 0xEF, 0x8F, 0x4B, 0x78, 0x78, 0xA1, 0xD2, 0x93, 0x13, 0x14, 0x7D, 0x28, + 0x73, 0x49, 0x5D, 0xEB, 0xDF, 0x76, 0xFB, 0xAE, 0xAE, 0xAC, 0xA6, 0xC8, + 0x58, 0x73, 0x9C, 0xE2, 0xA2, 0x32, 0x73, 0x99, 0xD1, 0x78, 0xA5, 0xE8, + 0x5A, 0x1F, 0x02, 0xA1, 0xA3, 0x41, 0xCA, 0xDB, 0x67, 0xF6, 0x7B, 0x14, + 0xDD, 0x7D, 0x02, 0xDC, 0xF0, 0x4E, 0x41, 0xF8, 0xF1, 0x4B, 0x95, 0x58, + 0x3D, 0xFB, 0x44, 0xEB, 0x9D, 0x20, 0xAF, 0x13, 0xE5, 0xA8, 0x3F, 0x14, + 0xD3, 0x0F, 0xB2, 0xDB, 0x85, 0xA1, 0x94, 0xC6, 0xE7, 0x45, 0x37, 0xE4, + 0x30, 0x5A, 0x55, 0x4F, 0x46, 0x07, 0x8B, 0x87, 0xE7, 0x96, 0xC8, 0x9C, + 0xED, 0x91, 0x92, 0x79, 0x30, 0x3C, 0xE1, 0x5D, 0x61, 0xC8, 0x37, 0x1A, + 0x9E, 0x12, 0xA1, 0xF4, 0xFE, 0x11, 0xF1, 0x41, 0x90, 0x84, 0x01, 0x36, + 0x87, 0x5C, 0x5E, 0xAE, 0x8B, 0x03, 0xCB, 0xBE, 0x41, 0x88, 0x86, 0xE8, + 0x6C, 0xDE, 0x3C, 0x38, 0x9B, 0x55, 0xCE, 0x28, 0xCE, 0xEA, 0x7C, 0xD8, + 0x1D, 0x3A, 0xAD, 0xF2, 0x5B, 0xCC, 0x1A, 0x44, 0xD4, 0x8A, 0x4E, 0x93, + 0xFD, 0xA5, 0x39, 0x4A, 0x7D, 0x5F, 0x85, 0x8D, 0x64, 0xE5, 0xC3, 0x48, + 0x75, 0x98, 0x83, 0xF1, 0x52, 0x44, 0xC4, 0xD9, 0xB4, 0x99, 0x36, 0x6E, + 0x73, 0xD0, 0xE2, 0x2B, 0xD1, 0xE8, 0x5E, 0xBE, 0x0B, 0x88, 0x16, 0x40, + 0x23, 0x0E, 0xCD, 0xB3, 0x86, 0x1B, 0xE4, 0xE9, 0xC5, 0xBC, 0xC1, 0x17, + 0x2F, 0x57, 0x01, 0xDE, 0x03, 0x55, 0x07, 0x19, 0x94, 0x11, 0x36, 0x22, + 0x82, 0x21, 0x97, 0x7E, 0x90, 0x27, 0x2D, 0xE1, 0xA1, 0xE2, 0xE0, 0x35, + 0x94, 0x83, 0xE8, 0x52, 0x3C, 0xCA, 0xA6, 0xB4, 0xC0, 0x92, 0xEC, 0x53, + 0x01, 0x00, 0x49, 0x89, 0xA3, 0x80, 0x68, 0x4F, 0x40, 0xC9, 0x58, 0x83, + 0x50, 0x58, 0xB2, 0xD7, 0xC3, 0xE4, 0x0A, 0xAD, 0xEC, 0x3A, 0x2E, 0x58, + 0x40, 0x3A, 0x1F, 0x0C, 0xA1, 0x88, 0xD4, 0x4D, 0x35, 0x32, 0x01, 0xD0, + 0x1A, 0x63, 0xA7, 0xDA, 0x3F, 0x89, 0x75, 0x9F, 0x34, 0x86, 0x42, 0x08, + 0x88, 0xD9, 0x9C, 0x1C, 0x7B, 0x43, 0x10, 0xF1, 0xC7, 0xE7, 0x2F, 0xF7, + 0xBB, 0x7D, 0x1F, 0xE2, 0xCD, 0xED, 0x76, 0xB5, 0xDE, 0xCE, 0x66, 0x73, + 0x16, 0xF6, 0xDE, 0x13, 0xD2, 0x6A, 0xB5, 0x7A, 0xF0, 0xE8, 0x41, 0x4A, + 0x31, 0xC6, 0xA8, 0xDB, 0x39, 0x0A, 0xA9, 0xBA, 0x3C, 0x74, 0x9D, 0xB5, + 0xF6, 0xA7, 0x3F, 0xFD, 0x34, 0x44, 0xAE, 0xEB, 0xAA, 0xAA, 0x9C, 0x75, + 0x76, 0xBB, 0xDD, 0x89, 0x40, 0x55, 0xB9, 0x94, 0x58, 0x0F, 0x8B, 0x31, + 0xFA, 0x10, 0x5D, 0xE5, 0xAA, 0xBA, 0x4A, 0xB9, 0x30, 0x43, 0x09, 0xAF, + 0x8F, 0x2D, 0x9D, 0x38, 0x09, 0x5A, 0x7A, 0xF5, 0xEE, 0x66, 0x7F, 0xE8, + 0xA6, 0x4D, 0x15, 0x63, 0x02, 0xC0, 0x94, 0x22, 0xDA, 0xE2, 0x2C, 0xC3, + 0x63, 0x01, 0xD6, 0x51, 0x68, 0x07, 0x01, 0x11, 0xF5, 0x97, 0x64, 0x71, + 0x28, 0x08, 0x34, 0x86, 0x98, 0x52, 0x62, 0x45, 0x7C, 0xCA, 0xA4, 0x96, + 0x49, 0x21, 0xEF, 0x8A, 0x53, 0x16, 0x84, 0x2C, 0x6F, 0xAA, 0x46, 0x04, + 0x51, 0x7B, 0x7D, 0x67, 0x10, 0x80, 0x05, 0x9F, 0x67, 0x9B, 0xE5, 0xDE, + 0x67, 0x2C, 0x93, 0x63, 0x1D, 0xF1, 0x01, 0x2D, 0x3C, 0xA4, 0x88, 0x68, + 0xBC, 0xA8, 0x60, 0x7A, 0x67, 0xAD, 0x35, 0xE6, 0x8F, 0xCF, 0x5E, 0xCD, + 0x26, 0xCD, 0xD5, 0xCD, 0xE6, 0xB7, 0x7F, 0xF8, 0xF1, 0xD7, 0x3F, 0xFF, + 0xEC, 0xBF, 0xFB, 0xEB, 0x9F, 0xA6, 0x42, 0xC3, 0x59, 0xA6, 0x0C, 0x98, + 0x73, 0x4B, 0x9D, 0x61, 0xA5, 0x1C, 0xFF, 0x85, 0x53, 0x2D, 0xA6, 0x7F, + 0x62, 0x00, 0x3D, 0x47, 0x73, 0xB0, 0x86, 0xF8, 0x29, 0x8E, 0x88, 0xB0, + 0x35, 0x6C, 0x31, 0x4E, 0xCB, 0x18, 0xF6, 0x6C, 0x80, 0xA3, 0x25, 0x3E, + 0x5C, 0xFC, 0x44, 0x8B, 0x41, 0xE6, 0x41, 0xC8, 0xFC, 0x7A, 0x39, 0x50, + 0x22, 0xC0, 0x47, 0xDC, 0x28, 0xE5, 0x9D, 0x33, 0x90, 0xE6, 0x52, 0xE3, + 0xA5, 0x37, 0xB2, 0x54, 0xF0, 0x2A, 0x8B, 0x60, 0xD9, 0x13, 0x12, 0x03, + 0x03, 0x1B, 0xAD, 0x22, 0x44, 0x40, 0x40, 0x2A, 0xBD, 0xAD, 0x32, 0x3E, + 0x85, 0x6C, 0xF7, 0x09, 0xE4, 0xFC, 0x3B, 0x5D, 0xCC, 0xE3, 0x72, 0x8A, + 0x41, 0x99, 0x14, 0xAD, 0x01, 0x45, 0xA1, 0x83, 0x96, 0x28, 0x38, 0x43, + 0x93, 0xDA, 0xD5, 0x95, 0x9D, 0x36, 0xCE, 0x87, 0xD8, 0x7A, 0x5F, 0x57, + 0x8E, 0x59, 0x10, 0xC0, 0x10, 0x25, 0xE4, 0xE9, 0xA4, 0x52, 0x36, 0x21, + 0xCD, 0x06, 0x2E, 0xE7, 0x1F, 0x1B, 0x3E, 0xDD, 0x17, 0x88, 0xFB, 0x12, + 0x70, 0x6F, 0x64, 0x8F, 0x28, 0x77, 0xF8, 0xD9, 0x10, 0x3E, 0x38, 0x9B, + 0xEF, 0xDA, 0x10, 0x62, 0x27, 0x5C, 0xFA, 0x8C, 0x2A, 0x54, 0xCF, 0x53, + 0x05, 0x47, 0x43, 0x62, 0x48, 0x6C, 0x44, 0x39, 0x76, 0x42, 0x10, 0x25, + 0xF1, 0x01, 0x82, 0xA3, 0x92, 0x65, 0x11, 0x14, 0x75, 0xD8, 0x67, 0xBE, + 0x11, 0x2A, 0x7B, 0x14, 0x40, 0x16, 0x02, 0x75, 0x16, 0x13, 0x00, 0x0A, + 0xAA, 0x1E, 0x72, 0x36, 0x93, 0x7C, 0x15, 0xE7, 0x58, 0x7E, 0xE8, 0x21, + 0xE1, 0x4C, 0xB3, 0xDE, 0x10, 0xB5, 0x99, 0x1E, 0xA4, 0x94, 0x2D, 0xA5, + 0x21, 0x98, 0x48, 0x20, 0xC2, 0x42, 0x04, 0x43, 0x53, 0x9C, 0x23, 0x66, + 0xCC, 0x79, 0x09, 0x50, 0x59, 0xDB, 0x34, 0x95, 0xB1, 0xD6, 0x9A, 0x71, + 0xA1, 0x12, 0xA8, 0xA1, 0x3A, 0xA4, 0xC8, 0xEA, 0x59, 0xC6, 0x5A, 0xB5, + 0x40, 0xC7, 0x12, 0x8C, 0x08, 0xAF, 0x5E, 0xBE, 0xB9, 0xBA, 0xC9, 0x24, + 0x2E, 0xD3, 0x00, 0x00, 0x20, 0x00, 0x49, 0x44, 0x41, 0x54, 0xBA, 0x89, + 0x31, 0x5D, 0xDF, 0x6C, 0xB7, 0xDB, 0xDD, 0xF2, 0xEC, 0x0C, 0x09, 0x9B, + 0xC9, 0x44, 0x00, 0xBB, 0xB6, 0xFF, 0xE8, 0xA3, 0xC7, 0x8F, 0x3F, 0x7A, + 0xD8, 0x34, 0xF5, 0x64, 0x32, 0xDD, 0x6C, 0x77, 0xEB, 0xCD, 0x6E, 0xB5, + 0xDA, 0xA4, 0xC8, 0x21, 0xC5, 0xE5, 0x72, 0x71, 0x79, 0x79, 0x3E, 0x9B, + 0xCD, 0xBE, 0xFF, 0xE1, 0x45, 0xD7, 0xF7, 0x55, 0xE5, 0xFA, 0xDE, 0xAB, + 0x7A, 0xEA, 0x7B, 0x9F, 0x52, 0x9A, 0xCD, 0xA6, 0x4D, 0x53, 0xDF, 0xDC, + 0xAC, 0x22, 0x07, 0x62, 0xA6, 0x78, 0x24, 0x92, 0x41, 0xC4, 0x94, 0x92, + 0x1A, 0xC5, 0xCC, 0xF2, 0xC9, 0xC7, 0x8F, 0x1E, 0x5E, 0x9E, 0x7F, 0xF5, + 0xD5, 0xB7, 0x6F, 0xDF, 0xDF, 0xFE, 0xF2, 0x67, 0x9F, 0xB2, 0x67, 0xD5, + 0xEF, 0xC6, 0x30, 0xA0, 0x40, 0x66, 0xD0, 0x03, 0xB9, 0xE3, 0x20, 0x4E, + 0x02, 0x02, 0x92, 0xA3, 0xAE, 0x00, 0x1A, 0x67, 0xCC, 0x0E, 0xDD, 0xAC, + 0xB6, 0x62, 0x8A, 0xE9, 0x98, 0x77, 0x9A, 0x33, 0x30, 0xEF, 0x29, 0xB2, + 0x93, 0xD5, 0x38, 0xFE, 0x3D, 0x3F, 0x2B, 0x96, 0xA4, 0xA8, 0xA2, 0x39, + 0x70, 0x94, 0xE7, 0x05, 0xF7, 0xB4, 0xD5, 0xC9, 0xF7, 0x63, 0x75, 0x53, + 0x64, 0x38, 0x1B, 0x95, 0x99, 0xE9, 0x0F, 0xA5, 0xAE, 0x2A, 0x4E, 0xFC, + 0x4F, 0x5F, 0x7E, 0xFF, 0x5F, 0xFF, 0xF9, 0x9B, 0x8F, 0x1E, 0x5E, 0xAE, + 0xB6, 0x7B, 0x67, 0xCD, 0xBF, 0x7C, 0xFD, 0xE3, 0x8B, 0x37, 0xD7, 0x7F, + 0xFF, 0x3F, 0xFC, 0xF5, 0x62, 0x36, 0x51, 0x1A, 0x9B, 0xD1, 0x2A, 0x39, + 0x5A, 0x69, 0x77, 0x34, 0x8B, 0xDC, 0xF9, 0xB2, 0x60, 0xA2, 0x62, 0xD6, + 0x8A, 0xD6, 0x13, 0xCB, 0x38, 0x00, 0x81, 0x25, 0x2F, 0x0C, 0x0A, 0x5E, + 0xFE, 0x33, 0xAA, 0xEA, 0x83, 0x4B, 0x72, 0x58, 0x8C, 0x9A, 0xE6, 0x56, + 0xC6, 0xF9, 0xCE, 0x68, 0x64, 0xB4, 0x0B, 0x00, 0x85, 0xBF, 0xE1, 0xFE, + 0xA2, 0x56, 0x3E, 0x75, 0x12, 0x91, 0x9C, 0x7A, 0xAC, 0x69, 0xF6, 0x02, + 0xA0, 0x1D, 0x0D, 0x18, 0x88, 0x84, 0x50, 0xE9, 0xDA, 0x44, 0x99, 0x0D, + 0x14, 0xDA, 0x09, 0x00, 0x0E, 0x77, 0x2D, 0x96, 0x38, 0x00, 0x1E, 0x8B, + 0x9B, 0x40, 0x0A, 0x42, 0x19, 0xD4, 0x7F, 0x3E, 0x86, 0xCB, 0x36, 0x98, + 0x58, 0x7C, 0x8C, 0x6D, 0x17, 0x58, 0x84, 0x08, 0xAD, 0xE9, 0x2D, 0x11, + 0x11, 0x5A, 0x4B, 0x8B, 0xD9, 0xA4, 0xAE, 0x2A, 0x32, 0x0A, 0xB9, 0x07, + 0xD7, 0xBE, 0x7A, 0xA0, 0xFE, 0x64, 0x01, 0xF0, 0x89, 0xA8, 0x9D, 0xC8, + 0xC1, 0xFD, 0x83, 0xF5, 0x87, 0xC4, 0x6C, 0x2D, 0x3D, 0x38, 0x9B, 0x58, + 0x43, 0xBB, 0x36, 0xB4, 0x3E, 0xE6, 0xD0, 0xAD, 0x42, 0x5A, 0x84, 0x12, + 0xD5, 0x01, 0x94, 0xC1, 0xAF, 0x95, 0x81, 0xF6, 0x51, 0xE0, 0x4E, 0x9B, + 0x80, 0xDC, 0x41, 0xB2, 0x94, 0x75, 0x98, 0x50, 0xEE, 0x5D, 0x92, 0x5F, + 0xC7, 0xE4, 0x2A, 0x28, 0x40, 0x14, 0x8B, 0x68, 0x0C, 0x56, 0xC6, 0x10, + 0x91, 0x6E, 0x15, 0xA3, 0xB9, 0x07, 0xC8, 0x89, 0x8B, 0x60, 0x00, 0xA4, + 0x94, 0x0A, 0x0D, 0xC8, 0x9B, 0x28, 0x37, 0xE5, 0x61, 0x6D, 0x6C, 0x66, + 0x94, 0x14, 0x0C, 0x35, 0xD1, 0x9D, 0xA1, 0xB8, 0x51, 0x50, 0x10, 0xD1, + 0x12, 0xCD, 0x67, 0x4D, 0x5D, 0xD7, 0xC3, 0x48, 0x1E, 0x65, 0x77, 0x34, + 0x6E, 0xC3, 0xE8, 0x11, 0x80, 0x30, 0x24, 0x4E, 0x48, 0x68, 0xAD, 0xED, + 0xFB, 0x7E, 0xBB, 0x6B, 0xFB, 0xBE, 0xBF, 0x7A, 0x7F, 0x83, 0x48, 0xBD, + 0xEF, 0x9B, 0xA6, 0x9E, 0xCF, 0xE7, 0xC6, 0xDA, 0x3E, 0x46, 0x1F, 0xE2, + 0xA3, 0x87, 0x0F, 0x74, 0x22, 0xDA, 0xB6, 0x45, 0xC4, 0xB3, 0xB3, 0xF9, + 0x74, 0xDA, 0x9C, 0x9D, 0x9F, 0x3D, 0x7A, 0x78, 0xB9, 0xD9, 0xEC, 0xBA, + 0xDE, 0xA7, 0xC4, 0xAF, 0xDF, 0xBC, 0x7F, 0xF9, 0xF2, 0x4D, 0x62, 0xAE, + 0xEB, 0xDA, 0x10, 0x09, 0xC0, 0x7E, 0xB7, 0x47, 0xA2, 0x10, 0xE3, 0x6C, + 0x3A, 0x9D, 0x4C, 0x1A, 0xEF, 0xBD, 0xCF, 0x7D, 0xCB, 0x45, 0x85, 0x51, + 0x7D, 0xFF, 0x84, 0x82, 0x44, 0x3E, 0x24, 0x00, 0xB1, 0xD6, 0x58, 0x6B, + 0x6F, 0x6E, 0x37, 0x02, 0xF8, 0xFA, 0xDD, 0xED, 0x5F, 0xFD, 0xEA, 0xF3, + 0x3E, 0xE4, 0xAD, 0x45, 0x11, 0x25, 0x60, 0x2A, 0xEA, 0xA0, 0x6C, 0xD8, + 0xAC, 0x60, 0x53, 0x00, 0x93, 0x8A, 0x16, 0x21, 0x01, 0xA4, 0xE0, 0x63, + 0x8C, 0xC9, 0x18, 0x42, 0x10, 0x6D, 0x91, 0xA8, 0xE8, 0x2C, 0xC4, 0x38, + 0x00, 0xB1, 0x0F, 0x0A, 0xD2, 0xFD, 0x2F, 0x33, 0x36, 0xC9, 0xD6, 0x49, + 0x76, 0xC8, 0x4B, 0x11, 0x8F, 0xEC, 0x9E, 0x43, 0xC0, 0xD2, 0xE6, 0x66, + 0x38, 0xEB, 0x4F, 0xD9, 0x13, 0xF7, 0xA5, 0xBD, 0xAC, 0x6E, 0xAE, 0xEB, + 0xBA, 0xEF, 0xE3, 0x3F, 0x7F, 0xF9, 0xFD, 0x7A, 0xD7, 0x7F, 0xF1, 0x93, + 0x4F, 0x0F, 0xAD, 0x76, 0xA0, 0x14, 0x00, 0xB9, 0xDE, 0x74, 0xFF, 0xF0, + 0x8F, 0x7F, 0xF8, 0x0F, 0xFF, 0xFD, 0x5F, 0x22, 0x82, 0xE6, 0xF7, 0xC1, + 0x50, 0x60, 0x75, 0xAA, 0x56, 0x72, 0x5A, 0xD9, 0xC9, 0x06, 0x7F, 0x4C, + 0xE9, 0x1D, 0xBD, 0x23, 0xCB, 0xB1, 0x16, 0x70, 0xF8, 0x7E, 0xA0, 0x69, + 0x1B, 0xFF, 0xE9, 0xBE, 0xE6, 0x1A, 0x3F, 0xBF, 0x7E, 0x89, 0x9A, 0xC8, + 0x02, 0x20, 0x22, 0x5A, 0x92, 0xCD, 0x22, 0x20, 0xCA, 0x1D, 0x95, 0x5F, + 0x73, 0x94, 0x5E, 0x77, 0x54, 0x7F, 0xE3, 0x07, 0x40, 0xC4, 0xE3, 0xC6, + 0x4B, 0x02, 0xA5, 0xD7, 0x9C, 0xDA, 0xF0, 0x00, 0x80, 0x0C, 0x42, 0xA2, + 0xD1, 0x7A, 0x60, 0x91, 0xC2, 0xEC, 0x2C, 0x06, 0x51, 0xEB, 0x66, 0xB2, + 0x0B, 0x79, 0xFC, 0x9A, 0x02, 0x82, 0x40, 0x02, 0x05, 0x41, 0x1C, 0x07, + 0x4B, 0x0D, 0x7B, 0x24, 0x11, 0x16, 0x61, 0xB0, 0x8E, 0x44, 0xA4, 0xED, + 0x23, 0x40, 0x44, 0x84, 0xDA, 0xB9, 0x98, 0xB8, 0x76, 0xA6, 0x22, 0x1B, + 0x22, 0xAB, 0x67, 0x2A, 0x67, 0x25, 0x0C, 0xBA, 0xB9, 0x0C, 0xD3, 0x7D, + 0x15, 0xF6, 0x41, 0x91, 0x1A, 0xD2, 0x0E, 0xB5, 0xB6, 0x06, 0x47, 0x9F, + 0xF1, 0x45, 0x88, 0xC8, 0x59, 0xE3, 0x8C, 0x31, 0xA4, 0x7D, 0x73, 0x29, + 0x40, 0x3A, 0x6E, 0x5B, 0xD9, 0xDC, 0xBE, 0x73, 0xE5, 0x3C, 0xAA, 0x19, + 0x8E, 0x02, 0x80, 0x06, 0xC3, 0x64, 0xB8, 0x3A, 0x8E, 0x68, 0x20, 0x75, + 0x24, 0x0A, 0xFF, 0x43, 0xE9, 0x3E, 0xA8, 0xA7, 0x00, 0x14, 0x96, 0x4D, + 0x04, 0xC8, 0x01, 0xFB, 0x4C, 0x8E, 0x4E, 0xB9, 0xC5, 0xF7, 0xB0, 0xB7, + 0x28, 0x74, 0x8F, 0xCC, 0x7C, 0x94, 0xF5, 0x1C, 0x7C, 0x22, 0x02, 0x22, + 0x83, 0x28, 0x90, 0x8E, 0x06, 0xAB, 0x35, 0x68, 0xCA, 0x46, 0xA7, 0x63, + 0x43, 0x48, 0xCE, 0x9A, 0xD9, 0xB4, 0x6E, 0x9A, 0x53, 0x2D, 0x96, 0xCF, + 0x11, 0x01, 0x01, 0xCD, 0x85, 0xC9, 0xEB, 0x5F, 0xB4, 0xFD, 0xA1, 0x88, + 0x48, 0xED, 0xAA, 0x17, 0x2F, 0x5F, 0x7F, 0xF7, 0xC3, 0x2B, 0xB2, 0x16, + 0x01, 0x38, 0x32, 0x02, 0x1B, 0x63, 0xAA, 0xAA, 0x62, 0x34, 0x44, 0x64, + 0x58, 0x2E, 0x2F, 0x2F, 0x62, 0x8C, 0x9C, 0x18, 0x84, 0x63, 0xC2, 0x94, + 0xF8, 0x76, 0xB5, 0x49, 0x2C, 0x5D, 0xE7, 0xEB, 0xCA, 0x3E, 0x7A, 0x74, + 0x79, 0x76, 0xB6, 0x7C, 0xF6, 0xFC, 0xD5, 0xF9, 0xC5, 0x72, 0xBB, 0xDD, + 0xC7, 0xC4, 0x4F, 0x3F, 0x7D, 0xF2, 0xF6, 0xDD, 0xD5, 0x8B, 0x97, 0x6F, + 0x67, 0xF3, 0xD9, 0x76, 0xBB, 0x9F, 0x4E, 0x26, 0x67, 0x67, 0xCB, 0xCD, + 0x76, 0xB7, 0x5A, 0x6F, 0x13, 0xB3, 0xB5, 0x16, 0x80, 0xAB, 0xAA, 0x0E, + 0x21, 0xFA, 0x10, 0x40, 0x85, 0x1C, 0x24, 0x72, 0xB4, 0x84, 0x09, 0xF0, + 0xC7, 0x17, 0x6F, 0xAC, 0x35, 0xC6, 0x9A, 0xCD, 0xBE, 0x0D, 0x31, 0x59, + 0x32, 0x23, 0x5F, 0x64, 0xB6, 0x97, 0x55, 0x8D, 0xEB, 0x2B, 0xA8, 0x71, + 0xAA, 0xE8, 0x83, 0x59, 0x94, 0xF8, 0x80, 0x13, 0xC7, 0x98, 0xDA, 0xAE, + 0x57, 0x98, 0x13, 0x63, 0x12, 0xC1, 0xC4, 0x29, 0x67, 0xB1, 0xFD, 0x89, + 0x72, 0xC2, 0xF1, 0x82, 0xBC, 0x2B, 0x77, 0x77, 0xCC, 0xC3, 0x72, 0x3C, + 0x0C, 0x47, 0xE9, 0x86, 0x02, 0x79, 0xEF, 0x93, 0x91, 0xA4, 0xFD, 0x39, + 0x91, 0x16, 0x39, 0x4A, 0x14, 0x00, 0x00, 0x42, 0x5D, 0x55, 0x5D, 0xEB, + 0xFF, 0x9F, 0xDF, 0x7E, 0xD7, 0xF6, 0xE9, 0x66, 0xB5, 0xF9, 0xE8, 0xD1, + 0x83, 0xBA, 0x72, 0xBD, 0xF7, 0xB3, 0xE9, 0x34, 0x25, 0xEE, 0xDA, 0xEE, + 0xD5, 0x3B, 0xFE, 0xDF, 0xFE, 0x8F, 0x7F, 0x39, 0x5F, 0x4E, 0xFF, 0xDD, + 0xDF, 0xFE, 0xC5, 0x7C, 0xDA, 0xF4, 0x21, 0x11, 0x8E, 0x2E, 0x7B, 0x44, + 0x3E, 0x1F, 0x30, 0x53, 0xA4, 0xFC, 0x7D, 0xFC, 0x72, 0x27, 0x2F, 0x3B, + 0x80, 0xA9, 0xF1, 0xD3, 0xDE, 0x3F, 0x06, 0x46, 0x1A, 0x67, 0x3C, 0x2C, + 0xC3, 0x06, 0x53, 0xB4, 0xE6, 0x31, 0x0C, 0x52, 0x6E, 0x7D, 0x7C, 0xA4, + 0x62, 0x07, 0xE0, 0x58, 0x09, 0x0E, 0x77, 0xB9, 0xD3, 0x2A, 0xFC, 0x38, + 0xF3, 0x83, 0x55, 0x5F, 0x02, 0x98, 0xBA, 0x41, 0x95, 0x87, 0x20, 0x20, + 0x55, 0x6D, 0x00, 0xD9, 0xA2, 0x1A, 0x4F, 0x22, 0xE8, 0x46, 0x87, 0x94, + 0x57, 0xFF, 0xDD, 0x69, 0x16, 0x43, 0x98, 0x00, 0x38, 0x89, 0xF7, 0x49, + 0xB4, 0x4F, 0xAA, 0xA5, 0xCA, 0x1A, 0x67, 0x0D, 0x0B, 0x1F, 0xFA, 0xD0, + 0xF6, 0xC1, 0x19, 0x63, 0x0C, 0xCD, 0x53, 0xB2, 0xD6, 0xD4, 0xA5, 0xAA, + 0xF9, 0x3E, 0xBC, 0x3A, 0x19, 0xA3, 0x13, 0xF5, 0x34, 0x3E, 0x12, 0x4B, + 0x41, 0xB5, 0x42, 0x2D, 0x35, 0x4E, 0x73, 0x09, 0x7E, 0x09, 0x90, 0xCD, + 0x26, 0xB5, 0xA6, 0xE8, 0x6F, 0x0F, 0x9E, 0x73, 0x6B, 0x78, 0xC4, 0x52, + 0x8C, 0xA7, 0x7A, 0xA7, 0x28, 0x35, 0xCC, 0x35, 0x21, 0x05, 0x76, 0x11, + 0x20, 0x51, 0x99, 0x9E, 0x63, 0xB2, 0x68, 0xBE, 0x35, 0xC2, 0x51, 0xC1, + 0x09, 0x40, 0x21, 0xF1, 0x82, 0x02, 0x92, 0x54, 0x1A, 0x90, 0x08, 0x0D, + 0x62, 0x2E, 0x13, 0x40, 0x68, 0xC8, 0x58, 0x22, 0x01, 0x41, 0x81, 0x90, + 0xD2, 0xB3, 0x67, 0x3F, 0xF6, 0x7D, 0xF8, 0xF8, 0xD3, 0x27, 0xF3, 0xF9, + 0x7C, 0xF4, 0x8E, 0x00, 0x98, 0xB9, 0xA4, 0x2D, 0x91, 0x90, 0x0C, 0x38, + 0xD1, 0x12, 0x39, 0xAB, 0x79, 0xF6, 0xB6, 0xAE, 0x91, 0x13, 0xF7, 0x3E, + 0x32, 0x8B, 0xB5, 0x34, 0x99, 0xDC, 0xD1, 0x62, 0x27, 0x6E, 0xDA, 0x3C, + 0x83, 0x59, 0x92, 0xB2, 0x37, 0x8E, 0x0C, 0x39, 0xEB, 0xBE, 0xFF, 0xE1, + 0xC5, 0xCB, 0xD7, 0xD7, 0x48, 0xA6, 0x6F, 0xFB, 0x18, 0x93, 0x73, 0x36, + 0x25, 0xAE, 0x9C, 0xED, 0x7C, 0xDA, 0xEC, 0xB6, 0x93, 0xA6, 0xB6, 0xD6, + 0x79, 0x1F, 0x9C, 0x33, 0xC1, 0x87, 0xDE, 0xFB, 0xD5, 0x66, 0x0B, 0x40, + 0xF3, 0xD9, 0x4C, 0x40, 0xE6, 0xF3, 0xE9, 0x72, 0x31, 0x5F, 0xAD, 0xB7, + 0xBF, 0xFB, 0xF2, 0x9B, 0x98, 0xF8, 0xF2, 0xF2, 0xFC, 0xE3, 0x27, 0x8F, + 0x1F, 0x3F, 0xBA, 0x5C, 0x6F, 0xB6, 0xBB, 0x7D, 0x8B, 0x88, 0xB3, 0xF9, + 0x74, 0x3E, 0x9B, 0xF6, 0x3E, 0x20, 0x61, 0xDF, 0xFB, 0xC4, 0x6C, 0xC8, + 0x70, 0x62, 0x35, 0x21, 0x53, 0x4C, 0x08, 0x18, 0x85, 0x05, 0x18, 0x05, + 0x53, 0x4A, 0x56, 0x1D, 0x11, 0x84, 0x22, 0xD2, 0x87, 0xF0, 0xFE, 0x66, + 0xFB, 0x8F, 0xBF, 0xFD, 0x21, 0xC5, 0xF0, 0x57, 0xBF, 0x7C, 0x7A, 0x7E, + 0x56, 0x8F, 0x96, 0x53, 0x81, 0x16, 0xDA, 0x44, 0x23, 0x44, 0x11, 0x4E, + 0xCC, 0x84, 0xD4, 0xF5, 0xDE, 0x5A, 0xE3, 0x9C, 0xE3, 0xC4, 0xBD, 0x0F, + 0x87, 0xD6, 0x73, 0xA9, 0xD5, 0x25, 0xCC, 0x35, 0xC2, 0x27, 0x82, 0x37, + 0x5E, 0x90, 0x2A, 0x3C, 0x3C, 0x50, 0xA1, 0x66, 0x34, 0x7B, 0xDC, 0xF3, + 0x86, 0x55, 0x77, 0xBA, 0xCA, 0xF2, 0x61, 0x1A, 0x56, 0x1E, 0xBB, 0x55, + 0x8F, 0x67, 0xC1, 0xDD, 0x8F, 0x73, 0x16, 0xA1, 0xF8, 0x6A, 0x75, 0x55, + 0x1B, 0x04, 0x80, 0x2F, 0xBF, 0x7D, 0x79, 0xB3, 0x6A, 0xDB, 0xBE, 0x5F, + 0x6D, 0x0E, 0x80, 0xF4, 0x93, 0xA7, 0x1F, 0x1F, 0xDA, 0xFE, 0x66, 0xB5, + 0x0D, 0x21, 0x5E, 0xDF, 0xAE, 0x99, 0xF9, 0xA3, 0xC7, 0x0F, 0xDE, 0xBC, + 0x5F, 0x6D, 0xF7, 0xDD, 0xDF, 0xFF, 0xFB, 0x5F, 0x2F, 0xE7, 0x93, 0xCE, + 0x87, 0x21, 0x62, 0x2B, 0x47, 0x37, 0xCB, 0x1D, 0x1D, 0x5D, 0xB4, 0xCA, + 0xB0, 0xB0, 0x33, 0x92, 0x3D, 0x79, 0xB6, 0xA1, 0x1D, 0x2F, 0xDE, 0xF5, + 0xF4, 0x8F, 0x81, 0xD8, 0x78, 0x15, 0x9C, 0x8C, 0x43, 0xE6, 0xD7, 0x92, + 0x3C, 0x72, 0x32, 0xEA, 0x5A, 0x87, 0x23, 0x93, 0x73, 0xBC, 0x55, 0x8C, + 0xAF, 0x7C, 0xB2, 0x79, 0xD8, 0x90, 0x09, 0x1B, 0x86, 0xE7, 0xD6, 0x9D, + 0x2A, 0x3F, 0xBD, 0x20, 0xA4, 0xE1, 0xB5, 0x8E, 0x1F, 0x61, 0x86, 0xA3, + 0x49, 0xAD, 0x8E, 0xEE, 0x61, 0x28, 0x04, 0x28, 0x1B, 0xF0, 0x23, 0xAD, + 0x89, 0xA0, 0xC6, 0xA4, 0xDA, 0x86, 0x84, 0xCC, 0x2A, 0x9D, 0x00, 0x91, + 0x25, 0x24, 0x0E, 0x51, 0x0B, 0x75, 0x80, 0x41, 0x08, 0x31, 0x59, 0xC1, + 0x7D, 0x1F, 0x63, 0x9A, 0xD4, 0xAE, 0x72, 0x06, 0x06, 0x1B, 0xF5, 0x2E, + 0x7C, 0x18, 0xDE, 0xE7, 0x83, 0x00, 0x6D, 0xF8, 0x5E, 0xE9, 0xF7, 0x62, + 0x8C, 0x1A, 0xFA, 0x4B, 0x89, 0x99, 0x93, 0xB5, 0x77, 0xB2, 0x34, 0xAC, + 0xB5, 0x8B, 0x85, 0x99, 0xCF, 0x27, 0x6D, 0xE7, 0xA7, 0x13, 0xB7, 0xDD, + 0xFB, 0x5D, 0xEB, 0x7D, 0xE4, 0xC1, 0x95, 0x0F, 0x05, 0x34, 0xE5, 0xC9, + 0x90, 0xC1, 0x57, 0x01, 0x04, 0x88, 0x28, 0xA5, 0x88, 0x1D, 0x0C, 0x91, + 0x35, 0xA8, 0xAF, 0x6E, 0x0D, 0x55, 0x36, 0xBB, 0xAA, 0x62, 0xCA, 0x9A, + 0x74, 0xAC, 0x75, 0x8B, 0x70, 0x80, 0x32, 0x89, 0xE8, 0xC5, 0x59, 0xC4, + 0x22, 0x19, 0x63, 0x12, 0x0B, 0x20, 0x54, 0x95, 0xBB, 0xBE, 0xBA, 0x3E, + 0x6C, 0x77, 0xEB, 0xED, 0x21, 0x89, 0xFC, 0xF2, 0x57, 0x3F, 0xDF, 0x6E, + 0x77, 0x17, 0x67, 0x4B, 0x63, 0x0D, 0x40, 0xD4, 0x8D, 0xDA, 0x19, 0xB2, + 0x56, 0x17, 0x55, 0xBE, 0x74, 0xD7, 0xB6, 0x29, 0xD2, 0x6C, 0x3A, 0x51, + 0x72, 0x37, 0x11, 0xEE, 0x43, 0xB4, 0x96, 0x66, 0xD3, 0x86, 0xC8, 0x9C, + 0x6E, 0x9E, 0xA5, 0x3E, 0xBC, 0x98, 0xA0, 0x20, 0x7C, 0xFC, 0x2B, 0x11, + 0xEE, 0x76, 0x87, 0xDF, 0xFF, 0xE1, 0xFB, 0xEB, 0xDB, 0xDD, 0x6C, 0x3A, + 0xD1, 0xBA, 0x4B, 0x16, 0xD6, 0xCE, 0xE7, 0x21, 0x26, 0x22, 0x42, 0x81, + 0xAB, 0xEB, 0x55, 0xDF, 0xF7, 0x9F, 0x7C, 0xF2, 0x04, 0x40, 0x92, 0xC8, + 0x6C, 0x36, 0xB3, 0xCE, 0xBD, 0x7A, 0xFD, 0x3E, 0x4D, 0xB8, 0x99, 0xD4, + 0x67, 0x67, 0x8B, 0x17, 0x2F, 0xDE, 0x3C, 0x7B, 0xFE, 0xEA, 0xFA, 0x66, + 0x6D, 0x8C, 0x79, 0xF4, 0xF0, 0x72, 0xB1, 0x98, 0x11, 0xE1, 0xFB, 0xAB, + 0xDB, 0xC3, 0xBE, 0x25, 0xA2, 0xF6, 0xD0, 0x01, 0x82, 0x30, 0xB4, 0xB7, + 0x9B, 0xDD, 0xA1, 0x15, 0x01, 0x32, 0xE4, 0xFB, 0x58, 0xD5, 0x4E, 0xD9, + 0x96, 0x35, 0xD0, 0x00, 0x05, 0xB1, 0x86, 0x98, 0x88, 0xC0, 0x91, 0xB1, + 0xD6, 0x26, 0xEF, 0xB7, 0xDB, 0xC3, 0x8B, 0xD7, 0xD7, 0x57, 0x37, 0xAB, + 0x47, 0x0F, 0x96, 0x0F, 0x2E, 0x17, 0x7D, 0x9F, 0x06, 0x8B, 0x40, 0x04, + 0x83, 0x0F, 0x0A, 0xCC, 0x43, 0xD0, 0xC2, 0x01, 0x06, 0xC4, 0x18, 0x92, + 0xB1, 0xC9, 0x87, 0x94, 0x62, 0xEA, 0x7D, 0x88, 0x29, 0x96, 0xE4, 0xE1, + 0x3B, 0xEE, 0x8B, 0xC1, 0x87, 0x7D, 0xA2, 0x8C, 0x86, 0x2D, 0xB0, 0x08, + 0xFE, 0x9D, 0x0D, 0x75, 0x2C, 0xAE, 0x27, 0x27, 0x96, 0x9F, 0xB3, 0x5F, + 0x00, 0x4E, 0xE1, 0xFE, 0xDD, 0xDD, 0x1A, 0x60, 0xD2, 0xD4, 0xFF, 0xF5, + 0x9F, 0x7E, 0xF7, 0xC9, 0x47, 0x8F, 0xBE, 0x78, 0xFA, 0x71, 0xEF, 0x03, + 0x11, 0x01, 0x4A, 0xE5, 0xEC, 0x7E, 0xDF, 0x7D, 0xF7, 0xFC, 0xDD, 0xED, + 0x7A, 0x57, 0xD7, 0x75, 0x5D, 0x57, 0x29, 0x25, 0x43, 0x34, 0x9F, 0x4D, + 0xDE, 0x5D, 0xAD, 0x66, 0xB3, 0x69, 0xD7, 0xFB, 0x37, 0x6F, 0xAF, 0x5E, + 0xBC, 0x78, 0xF3, 0xF8, 0xF1, 0x83, 0xDF, 0x7C, 0xF5, 0xEC, 0xDD, 0xD5, + 0xED, 0xFF, 0xF4, 0x1F, 0xFE, 0xCD, 0xE3, 0x07, 0xCB, 0xA4, 0xB5, 0x56, + 0x38, 0x00, 0x21, 0x1C, 0x23, 0xB2, 0xD1, 0xAD, 0x71, 0x50, 0x65, 0xE3, + 0xEF, 0xC7, 0x2F, 0x28, 0x23, 0x07, 0xFF, 0x78, 0xC4, 0x86, 0x53, 0xEE, + 0xA7, 0x98, 0xDD, 0x7D, 0xCF, 0x21, 0x12, 0x7A, 0x67, 0x70, 0x4E, 0xD4, + 0xD6, 0xF8, 0xCA, 0xF7, 0x1E, 0x32, 0x7F, 0xAC, 0x52, 0x51, 0x8F, 0xBC, + 0x39, 0x38, 0x3E, 0x26, 0xE3, 0xBD, 0xD1, 0x55, 0x8E, 0x1B, 0x42, 0x41, + 0xD6, 0xC3, 0xBA, 0xC6, 0x72, 0x57, 0x02, 0x64, 0x06, 0x2C, 0xBA, 0x0C, + 0x72, 0xC3, 0x2D, 0x60, 0x10, 0x64, 0xE8, 0x7C, 0x74, 0x96, 0xAC, 0x21, + 0x46, 0xE5, 0xC2, 0x96, 0x24, 0x1C, 0xA2, 0x10, 0x81, 0x23, 0xB2, 0x96, + 0x9A, 0xCA, 0xCE, 0x9A, 0xCA, 0x18, 0x74, 0xD6, 0xD4, 0x5A, 0x20, 0x43, + 0xE6, 0x3E, 0x1C, 0x1B, 0x36, 0x81, 0x61, 0x5B, 0xF8, 0x53, 0xA2, 0xA0, + 0x9F, 0x82, 0xB0, 0x72, 0x2D, 0xD7, 0x7D, 0x7A, 0x13, 0xBD, 0xC8, 0x6C, + 0x5A, 0xFF, 0xB4, 0x79, 0xD8, 0xF5, 0xFE, 0xFD, 0xED, 0xEE, 0xDD, 0xCD, + 0xAE, 0xF3, 0xB1, 0x64, 0x35, 0x2A, 0x28, 0x2F, 0x2E, 0x18, 0x00, 0x55, + 0xDF, 0x9A, 0x62, 0x9A, 0xED, 0x3B, 0x00, 0x40, 0x34, 0x0A, 0x8E, 0x24, + 0x27, 0xA0, 0x58, 0x4B, 0xCA, 0xA3, 0x1F, 0x53, 0x0A, 0x31, 0xA5, 0x84, + 0x6A, 0xA4, 0x8F, 0xDE, 0x08, 0x8B, 0x19, 0xAE, 0x44, 0xB3, 0xA0, 0xFD, + 0xBD, 0x45, 0x32, 0xB2, 0x7D, 0xF5, 0xF2, 0xCD, 0xBB, 0xB7, 0xEF, 0xAC, + 0xB3, 0xD3, 0xE9, 0x74, 0xBF, 0x6F, 0x7F, 0xF3, 0xAF, 0x5F, 0x75, 0x5D, + 0xF7, 0xF0, 0xF2, 0xEC, 0xD0, 0x87, 0xCF, 0x3E, 0xFB, 0x64, 0x36, 0xAD, + 0xFB, 0x3E, 0x55, 0x8B, 0xA9, 0x12, 0xBB, 0x84, 0x10, 0x56, 0xB7, 0xEB, + 0x94, 0x52, 0x8C, 0xC1, 0x58, 0xB3, 0xB2, 0xF6, 0xE3, 0x27, 0x8F, 0x16, + 0x8B, 0x29, 0xA2, 0x39, 0x5F, 0xCE, 0xD4, 0xA9, 0x74, 0x67, 0x70, 0x06, + 0x13, 0x02, 0x86, 0x95, 0x75, 0x94, 0x24, 0x11, 0x41, 0x84, 0x7F, 0xF9, + 0xED, 0x37, 0x6F, 0xDF, 0xAF, 0x0F, 0x6D, 0x67, 0xAD, 0x21, 0xC2, 0xCA, + 0xB9, 0xA6, 0x76, 0xAF, 0x5F, 0xBF, 0xBB, 0x5D, 0x6D, 0x97, 0xCB, 0x79, + 0x5D, 0xD7, 0x6D, 0xD7, 0xBD, 0xBD, 0xBA, 0x7E, 0xF8, 0xE0, 0xC1, 0xC5, + 0xE5, 0x79, 0x5D, 0x57, 0xCB, 0xC5, 0x4C, 0x1D, 0xCC, 0xF3, 0xF9, 0x6C, + 0x79, 0xB6, 0x34, 0x44, 0x4D, 0x5D, 0x7F, 0xF5, 0xCD, 0xF7, 0x5F, 0x7D, + 0xF5, 0x6D, 0x8C, 0xDC, 0xD4, 0xF5, 0xD3, 0xA7, 0x9F, 0x54, 0x95, 0x43, + 0x80, 0xC3, 0xA1, 0x5B, 0xAF, 0x77, 0x6D, 0xDB, 0x91, 0x31, 0xDE, 0xEF, + 0x8C, 0xB5, 0xCB, 0xE5, 0xE2, 0xFA, 0x76, 0xC5, 0xC2, 0xC0, 0xD8, 0x77, + 0x41, 0x9F, 0x64, 0x36, 0x9B, 0x8A, 0xEC, 0x11, 0x09, 0x7D, 0x00, 0x00, + 0x1F, 0x82, 0x0A, 0xAA, 0x96, 0x2A, 0xA6, 0x98, 0x38, 0xF1, 0xA1, 0x6D, + 0x13, 0x73, 0xDF, 0x87, 0xAB, 0x9B, 0x2D, 0x02, 0xA5, 0xC8, 0x1A, 0x1F, + 0x11, 0x8D, 0x7E, 0xC6, 0x10, 0x63, 0x8A, 0x21, 0xC5, 0xC8, 0x31, 0xC6, + 0x98, 0x92, 0x6E, 0x22, 0x89, 0x19, 0x31, 0xC5, 0x18, 0x13, 0xB3, 0xA8, + 0x5F, 0x64, 0xB4, 0xBD, 0x15, 0x3D, 0x7E, 0x27, 0x36, 0x37, 0x96, 0xBA, + 0xB1, 0xFC, 0x9C, 0x48, 0xD4, 0x87, 0x34, 0xD7, 0x11, 0xA3, 0x1D, 0x45, + 0x4A, 0x00, 0x0A, 0xFC, 0x1D, 0xBC, 0x57, 0x58, 0xB2, 0xAB, 0xD4, 0x74, + 0xE8, 0x7D, 0x78, 0x7F, 0xBD, 0x45, 0xAA, 0x1E, 0x3D, 0xBC, 0x5C, 0x4C, + 0x9B, 0x90, 0x22, 0x11, 0x75, 0x9D, 0xFF, 0x87, 0xFF, 0xF6, 0xB5, 0x20, + 0x2D, 0x17, 0xB3, 0x17, 0xAF, 0xDF, 0xCF, 0xE7, 0x33, 0x10, 0xF9, 0xCD, + 0xEF, 0xBF, 0x25, 0x32, 0x6D, 0xD7, 0xBF, 0x7C, 0xFD, 0xAE, 0xAE, 0xAB, + 0x8F, 0x1E, 0x3F, 0xDC, 0x1F, 0xDA, 0xD7, 0x6F, 0xAE, 0x52, 0x4A, 0x97, + 0x17, 0xCB, 0xFF, 0xFD, 0x1F, 0x7E, 0xFB, 0xEF, 0xFE, 0xF6, 0x8B, 0xBF, + 0xFC, 0xD9, 0x27, 0x9D, 0x0F, 0x5A, 0x62, 0x55, 0xA8, 0xC0, 0xEE, 0x68, + 0x07, 0xF9, 0x90, 0xFE, 0x1A, 0xBF, 0xCB, 0x18, 0x69, 0xC2, 0x3D, 0x35, + 0x37, 0x92, 0x1C, 0x1C, 0xBF, 0xF8, 0xC9, 0xA5, 0x44, 0x8E, 0x09, 0xCC, + 0xCC, 0x77, 0xD6, 0xF5, 0xF8, 0xAC, 0x61, 0x6D, 0x8E, 0xB7, 0x8D, 0xB1, + 0x36, 0xD0, 0xBB, 0x58, 0x16, 0x31, 0x6A, 0x48, 0x8E, 0x83, 0x9B, 0x7A, + 0xC5, 0xF2, 0x34, 0x43, 0x66, 0xE8, 0xB1, 0x16, 0x17, 0x00, 0x00, 0x34, + 0x45, 0x40, 0x3D, 0x8B, 0x26, 0xDB, 0x60, 0x1A, 0x73, 0xCC, 0x49, 0xAD, + 0x9A, 0xF2, 0x83, 0x85, 0x50, 0xC0, 0x00, 0x12, 0xA1, 0x73, 0x34, 0xAD, + 0x1D, 0x22, 0x6E, 0xF6, 0x3D, 0xC7, 0x44, 0x84, 0x06, 0x8D, 0x1E, 0x50, + 0x59, 0x22, 0xA4, 0xCA, 0x9A, 0xA6, 0xB6, 0x22, 0x42, 0x88, 0xD6, 0x8C, + 0x5A, 0x01, 0x94, 0xF7, 0x3F, 0x31, 0x85, 0xC6, 0x32, 0x74, 0x7F, 0xE0, + 0x86, 0x6F, 0x86, 0x20, 0xB4, 0x31, 0xA7, 0xD6, 0xC1, 0x78, 0x32, 0xF5, + 0xE0, 0xAA, 0x72, 0x1F, 0x3F, 0x3A, 0x9B, 0x4D, 0xEA, 0x9B, 0xF5, 0x7E, + 0xBB, 0xEF, 0x22, 0xB3, 0x86, 0x19, 0x54, 0x92, 0x99, 0xC5, 0x10, 0xCE, + 0x9A, 0x6A, 0xD2, 0x38, 0x66, 0xD1, 0x45, 0x8B, 0x45, 0x36, 0x8D, 0x21, + 0x6B, 0x48, 0x24, 0x87, 0xAB, 0x63, 0x4C, 0x84, 0xA8, 0xEE, 0x2A, 0x72, + 0x18, 0x89, 0x59, 0x72, 0x5A, 0x96, 0x08, 0x68, 0xDA, 0x44, 0xA6, 0x2E, + 0x29, 0x78, 0x48, 0x85, 0xCC, 0x39, 0xEB, 0x7D, 0xFF, 0xFB, 0x2F, 0xBF, + 0xBB, 0x7A, 0x7F, 0xB3, 0x5C, 0xCE, 0x91, 0x30, 0x24, 0x6E, 0x0F, 0x5D, + 0xDB, 0xAE, 0xDB, 0xDE, 0xAF, 0x56, 0x3B, 0x11, 0x79, 0xFB, 0xEE, 0xE6, + 0xF2, 0xE2, 0x3C, 0xC6, 0x18, 0x63, 0x9C, 0xCF, 0x26, 0xCA, 0x0D, 0x8D, + 0x00, 0x55, 0x6D, 0x8D, 0xB1, 0xF3, 0xF9, 0x34, 0x58, 0xF9, 0xE3, 0x77, + 0x2F, 0xAD, 0x35, 0x4F, 0x3E, 0xBA, 0x9C, 0xCD, 0x14, 0x9D, 0x99, 0x18, + 0xE3, 0x68, 0x94, 0x58, 0xEB, 0x69, 0x46, 0x03, 0x98, 0xC7, 0x21, 0xA5, + 0x54, 0x55, 0xEE, 0xE5, 0xAB, 0x77, 0x3F, 0x3C, 0x7F, 0x7B, 0xF9, 0xE0, + 0xE2, 0xE2, 0xF2, 0xDC, 0x1A, 0x72, 0xCE, 0x76, 0x9D, 0x37, 0x22, 0x9B, + 0xF5, 0xA6, 0x3D, 0xB4, 0xC6, 0xA0, 0x2A, 0x81, 0xE9, 0x74, 0x72, 0xBB, + 0x5E, 0x3F, 0x74, 0x0F, 0xA0, 0xEB, 0x6E, 0x57, 0x6B, 0x44, 0xBC, 0xBC, + 0x38, 0x37, 0xD6, 0x24, 0x96, 0xD5, 0x7E, 0xD7, 0xF7, 0x7E, 0xB7, 0x3B, + 0x24, 0x96, 0xB3, 0xF3, 0xE5, 0xCF, 0x7F, 0xF6, 0xF9, 0x62, 0x31, 0x43, + 0xC0, 0xCD, 0x76, 0xFF, 0xEA, 0xCD, 0xFB, 0xDE, 0x87, 0xE5, 0xD9, 0xF2, + 0xFD, 0xD5, 0x4D, 0x62, 0xFE, 0xE5, 0x2F, 0x3E, 0xD9, 0xEF, 0x0F, 0xCB, + 0xE5, 0xFC, 0xDD, 0xFB, 0x5B, 0x7D, 0x0A, 0x7D, 0x1E, 0xDD, 0x4E, 0x8D, + 0xA5, 0xC9, 0xB4, 0x49, 0x4A, 0x24, 0x99, 0x9D, 0xFD, 0xC4, 0x2C, 0x3E, + 0x46, 0x1F, 0xA2, 0x31, 0x74, 0xBE, 0x9C, 0xCF, 0x67, 0xD3, 0xB6, 0x8F, + 0xBB, 0x5D, 0x8B, 0x88, 0x31, 0x46, 0x44, 0x64, 0x6D, 0x9F, 0x91, 0x58, + 0xE9, 0xCC, 0x52, 0xE2, 0xA8, 0x89, 0x14, 0x4A, 0xF6, 0x59, 0x16, 0x8F, + 0x48, 0xC9, 0x50, 0xBA, 0x6B, 0x3F, 0x8E, 0x97, 0xDF, 0xC9, 0x1A, 0xD6, + 0x9F, 0x87, 0x98, 0xDD, 0xC9, 0x89, 0x63, 0x85, 0x08, 0x77, 0x3F, 0xA3, + 0x6F, 0x54, 0xB6, 0x4B, 0x5F, 0xDD, 0xA3, 0xF5, 0xA2, 0x4A, 0x18, 0x7F, + 0xF7, 0xCD, 0x8B, 0x9B, 0xF5, 0x16, 0x00, 0x96, 0xCB, 0xE5, 0xC7, 0x8F, + 0x2F, 0x7E, 0x7C, 0xF9, 0x86, 0x45, 0xFE, 0xF2, 0xE7, 0x4F, 0xA7, 0x93, + 0xFA, 0xB7, 0xCF, 0xDE, 0xDE, 0x6E, 0x3B, 0x22, 0x7C, 0xF5, 0xF6, 0xFA, + 0xE2, 0x7C, 0x69, 0x8C, 0xF9, 0xFE, 0xD9, 0x4B, 0xE7, 0x5C, 0x55, 0xB9, + 0xC5, 0x6C, 0xFA, 0xD1, 0xE3, 0x87, 0x02, 0xD2, 0xD4, 0x55, 0x55, 0xB9, + 0x14, 0x13, 0x54, 0x8E, 0x08, 0x93, 0xC0, 0x37, 0x3F, 0xBC, 0xF9, 0xC5, + 0x17, 0x4F, 0x50, 0xB3, 0x20, 0xC7, 0x01, 0xC2, 0x61, 0x71, 0x1D, 0xC9, + 0x3A, 0x4E, 0x15, 0x1C, 0x22, 0x8E, 0xFB, 0x73, 0x0F, 0x0B, 0x6A, 0xAC, + 0x6E, 0x4E, 0x14, 0xFD, 0x07, 0x50, 0xD8, 0xE8, 0xAF, 0xE3, 0x18, 0xE5, + 0x78, 0x48, 0x4F, 0xAE, 0x33, 0xDC, 0x7A, 0x7C, 0x97, 0x93, 0x27, 0xB7, + 0xC7, 0x11, 0x1D, 0x65, 0x35, 0x71, 0x29, 0x5F, 0x28, 0x40, 0x0D, 0xB3, + 0xC1, 0x51, 0x1E, 0x58, 0x04, 0x9C, 0xC5, 0x69, 0x65, 0x13, 0x8B, 0x56, + 0x77, 0x6B, 0x01, 0x79, 0x62, 0x41, 0xCC, 0x8C, 0x17, 0xAD, 0x0F, 0x00, + 0x54, 0x57, 0x06, 0x01, 0xFA, 0x10, 0xA5, 0xD0, 0x43, 0x27, 0x2E, 0x84, + 0x49, 0x08, 0x95, 0x35, 0xCA, 0xF5, 0x6C, 0x0D, 0x29, 0x79, 0xEC, 0xB4, + 0x71, 0x44, 0xC4, 0x2C, 0xC6, 0x98, 0xF9, 0xA4, 0x72, 0xCE, 0xC4, 0x98, + 0x0C, 0xB1, 0x86, 0x31, 0xB4, 0xFE, 0x4E, 0x33, 0x15, 0x07, 0xDC, 0xAB, + 0x2F, 0x56, 0x55, 0xB6, 0xAA, 0xAA, 0xE1, 0x55, 0x87, 0xEF, 0x4F, 0xA4, + 0x07, 0x8B, 0x5F, 0x63, 0x18, 0x91, 0xF1, 0x0E, 0x30, 0x1E, 0x65, 0x22, + 0xBA, 0x3C, 0x9B, 0xCD, 0x27, 0xD5, 0xBE, 0xF5, 0x37, 0xEB, 0x43, 0xEF, + 0xC3, 0x6C, 0x52, 0xAB, 0xE3, 0x9C, 0x08, 0x17, 0xB3, 0x66, 0x31, 0x6B, + 0x84, 0xA5, 0xF3, 0x51, 0x75, 0x6E, 0xE4, 0x63, 0xA3, 0xC1, 0x98, 0x53, + 0x90, 0x8E, 0x4C, 0xEA, 0x89, 0x41, 0x44, 0xAB, 0x54, 0xB3, 0x72, 0x4F, + 0x2C, 0x2C, 0x62, 0x8C, 0x81, 0x04, 0xEA, 0xBA, 0xD3, 0x18, 0xA3, 0x35, + 0x88, 0x84, 0x0C, 0xF0, 0xED, 0x77, 0xCF, 0xAF, 0xDE, 0x5F, 0x1D, 0xDA, + 0xDE, 0x56, 0xB5, 0xB6, 0xF9, 0xF0, 0xDE, 0x2B, 0xC4, 0x05, 0x91, 0x94, + 0x52, 0x55, 0x55, 0x5D, 0xE7, 0x5F, 0xBD, 0x7E, 0xDF, 0x4C, 0xEA, 0x94, + 0x78, 0xB5, 0x39, 0x38, 0x67, 0x09, 0xB1, 0xAA, 0x2B, 0x26, 0x49, 0x5D, + 0xFF, 0xFA, 0xED, 0xCD, 0xA7, 0x1F, 0x3F, 0x9A, 0x4C, 0x9A, 0xCD, 0x6E, + 0xF7, 0xFE, 0x6A, 0x65, 0x08, 0x43, 0x0C, 0xFF, 0xE6, 0xEF, 0xFE, 0xF2, + 0xC9, 0xA3, 0x07, 0xB9, 0x94, 0x1C, 0x65, 0xF0, 0x82, 0x0D, 0xA2, 0x9C, + 0x05, 0x9A, 0xC5, 0x59, 0xF3, 0xFC, 0xC5, 0xEB, 0xFF, 0xF2, 0xDF, 0xBE, + 0xBC, 0xB8, 0xB8, 0x70, 0xAE, 0x9A, 0x36, 0x8D, 0x0F, 0xFE, 0xF6, 0x76, + 0xE3, 0x7D, 0x88, 0xC1, 0xC7, 0xC4, 0xCD, 0xA4, 0x89, 0x29, 0xC5, 0xFD, + 0x81, 0x13, 0x5B, 0x67, 0x11, 0xE0, 0xF5, 0xAB, 0xB7, 0xD3, 0x69, 0x23, + 0x00, 0x4D, 0x53, 0x6F, 0x36, 0xBB, 0xCE, 0x07, 0xEB, 0x6C, 0x08, 0x69, + 0xB7, 0xDB, 0xF7, 0xBD, 0xFF, 0xD5, 0x2F, 0xBF, 0xF8, 0xE4, 0xE3, 0xC7, + 0x2C, 0x50, 0x57, 0x2E, 0xC6, 0xB8, 0xDD, 0xF7, 0x87, 0xB6, 0x7B, 0x77, + 0x75, 0x13, 0x53, 0xEA, 0x7A, 0xFF, 0x93, 0xCF, 0x3F, 0x39, 0x5B, 0xCE, + 0x9F, 0xFD, 0xF8, 0xFA, 0x6C, 0xB9, 0x48, 0x49, 0x03, 0xAD, 0x99, 0x77, + 0x30, 0x31, 0xCF, 0x66, 0xD3, 0xDD, 0xBE, 0xBD, 0xBC, 0x3C, 0x7F, 0xFA, + 0xE9, 0xE3, 0x7F, 0xFD, 0xED, 0x37, 0x7D, 0xBF, 0x77, 0xCE, 0xA4, 0xC4, + 0xDE, 0xA7, 0xAA, 0xB2, 0xCC, 0xC2, 0x1C, 0xDF, 0xBC, 0xBF, 0xB9, 0x3C, + 0x5F, 0x3E, 0x7F, 0x79, 0xFD, 0x77, 0xBF, 0xFE, 0xC9, 0x6C, 0x5A, 0x87, + 0x14, 0x41, 0x84, 0x19, 0x62, 0x4A, 0x29, 0xA6, 0x81, 0x25, 0xB8, 0xBC, + 0x20, 0xE3, 0x5D, 0xEF, 0xC4, 0x20, 0x06, 0xE3, 0xD5, 0x72, 0xA2, 0xB6, + 0x4A, 0x8F, 0xEA, 0x23, 0xE2, 0x18, 0x21, 0xAC, 0x53, 0x49, 0xFB, 0xA0, + 0x04, 0x8E, 0x7F, 0xE6, 0x51, 0x69, 0x52, 0x81, 0x27, 0xB9, 0x18, 0xC0, + 0x5A, 0xF3, 0xF5, 0xB7, 0x2F, 0xFF, 0xEF, 0x7F, 0xFE, 0xDA, 0x55, 0x35, + 0x73, 0x7A, 0xF2, 0xE8, 0xF2, 0x5F, 0x7E, 0xFF, 0xC3, 0xD5, 0xCD, 0x6A, + 0x3A, 0x99, 0x3C, 0xFD, 0xF4, 0xA3, 0xDD, 0xA1, 0x5F, 0xED, 0xFA, 0xCB, + 0xF3, 0xE5, 0xBB, 0xAB, 0xDB, 0xF3, 0xE5, 0xC2, 0x58, 0x32, 0xC6, 0xFC, + 0xE2, 0x67, 0x3F, 0xD9, 0xED, 0xDB, 0x18, 0xE3, 0xED, 0x6A, 0xFB, 0xF9, + 0xE7, 0x1F, 0x1B, 0x63, 0xBE, 0xF9, 0xE3, 0x0F, 0x75, 0x5D, 0x7F, 0xF6, + 0xD9, 0x47, 0xD3, 0x49, 0xF3, 0xEE, 0xEA, 0xA6, 0xA9, 0x6B, 0xA2, 0x85, + 0xB2, 0x9B, 0x1C, 0xA9, 0xD6, 0x46, 0xF3, 0x5E, 0x1A, 0x80, 0x03, 0x80, + 0x8C, 0x51, 0x92, 0x7E, 0x86, 0xB2, 0xE5, 0x61, 0x0C, 0xC7, 0x6B, 0xED, + 0x64, 0x05, 0x41, 0x09, 0x65, 0x0E, 0x38, 0xE3, 0x24, 0x66, 0x22, 0x85, + 0x71, 0x4C, 0xEE, 0x9E, 0x35, 0xDC, 0x6B, 0x7C, 0xF0, 0x89, 0x4E, 0x1C, + 0x1C, 0x76, 0x03, 0x58, 0x33, 0xFF, 0xF3, 0xFF, 0xF2, 0xBF, 0xEA, 0xE3, + 0x19, 0x44, 0xCA, 0x85, 0x0C, 0xC7, 0x6C, 0xF5, 0x5C, 0xCC, 0x5C, 0x7E, + 0x85, 0x6C, 0x6C, 0xA2, 0x7A, 0x7F, 0xAC, 0xA1, 0x87, 0x67, 0xB3, 0xBA, + 0xB2, 0x21, 0xB1, 0xD1, 0x30, 0xBF, 0x88, 0xB5, 0x64, 0x48, 0xE9, 0x5C, + 0xA4, 0xAA, 0x8C, 0x33, 0x86, 0x25, 0x37, 0x5E, 0xD3, 0x0E, 0x6F, 0x89, + 0x25, 0xC4, 0x24, 0xCC, 0xD6, 0x98, 0xE5, 0xB4, 0xBE, 0x3C, 0x9B, 0x5C, + 0x2E, 0xA7, 0xCE, 0xE5, 0x4E, 0x88, 0x7D, 0x4C, 0xFB, 0xD6, 0x13, 0xE2, + 0x7C, 0x52, 0x19, 0x63, 0xBA, 0x3E, 0xB4, 0xBD, 0xEF, 0xFA, 0xA0, 0xFF, + 0xF7, 0xF1, 0x98, 0x5C, 0xAD, 0xD9, 0x80, 0xEA, 0x36, 0x41, 0xD4, 0xD4, + 0xA7, 0x21, 0xB8, 0x4E, 0x27, 0xE3, 0x3B, 0x1E, 0x88, 0x41, 0x46, 0x35, + 0xBE, 0x3E, 0x4C, 0xC9, 0xFD, 0x52, 0x01, 0x2E, 0xD3, 0x6A, 0x88, 0xCE, + 0x16, 0x93, 0xF9, 0xB4, 0x9E, 0x4F, 0xEB, 0xF3, 0xE5, 0xF4, 0x62, 0x39, + 0x9B, 0x4D, 0x6B, 0xCC, 0x2D, 0xC6, 0x40, 0xC9, 0xB8, 0xEB, 0xCA, 0x4E, + 0x9A, 0xCA, 0x39, 0x6B, 0x8C, 0x76, 0x40, 0xC4, 0xCA, 0x59, 0x25, 0xC6, + 0x51, 0x52, 0xE9, 0x18, 0xB3, 0x7B, 0x8C, 0x75, 0x38, 0x58, 0xC8, 0x9A, + 0x9B, 0x9B, 0x95, 0xB5, 0x66, 0x3A, 0x9D, 0x18, 0x63, 0x08, 0xD1, 0x39, + 0x4B, 0x48, 0x5D, 0x17, 0x5E, 0xBC, 0x7C, 0xF3, 0xDD, 0xB7, 0x3F, 0x26, + 0xE6, 0x66, 0xD2, 0x84, 0x10, 0xFB, 0x10, 0xBA, 0xCE, 0x6F, 0xB6, 0x3B, + 0x91, 0x21, 0xC1, 0x9D, 0x03, 0x73, 0x4A, 0x6C, 0xAC, 0x89, 0x21, 0x97, + 0x25, 0xC5, 0xC4, 0x5D, 0xEF, 0xEB, 0xBA, 0xEE, 0xDA, 0xFE, 0xD0, 0xF6, + 0x57, 0x37, 0x2B, 0x8D, 0x0C, 0xBE, 0x7C, 0xFD, 0x9E, 0x99, 0x9F, 0x3C, + 0x79, 0xBC, 0xDE, 0x1C, 0xAE, 0x6F, 0xD6, 0xEF, 0xAF, 0x56, 0x00, 0x7C, + 0xBE, 0x9C, 0xF9, 0xDE, 0xF3, 0x40, 0x06, 0x30, 0xDA, 0x84, 0x59, 0xB9, + 0x95, 0x08, 0x7F, 0xF3, 0xE5, 0xB7, 0x5D, 0xEB, 0xA3, 0x36, 0x4A, 0x44, + 0x7C, 0xFD, 0xEA, 0xED, 0xED, 0x6A, 0x93, 0x24, 0xC5, 0xC8, 0x64, 0x08, + 0x80, 0x40, 0xE0, 0x70, 0xE8, 0x0E, 0x6D, 0x17, 0x42, 0x8C, 0x31, 0x71, + 0x76, 0xD3, 0x4C, 0xA7, 0x4D, 0x9D, 0x62, 0xDA, 0xED, 0xDB, 0xEB, 0x9B, + 0xD5, 0xF5, 0xF5, 0x6D, 0xDB, 0x76, 0x4F, 0x3E, 0x7A, 0xF4, 0xF0, 0xE1, + 0xC5, 0xF5, 0xED, 0x3A, 0x84, 0x68, 0xAD, 0xB9, 0xB9, 0xDD, 0xDC, 0xDC, + 0xAE, 0x9A, 0xA6, 0xFE, 0xE1, 0xF9, 0x2B, 0x66, 0xAE, 0xEB, 0x1A, 0x00, + 0xDF, 0x5F, 0xAD, 0x6E, 0x6F, 0xB7, 0xFB, 0xC3, 0x21, 0x26, 0x26, 0xC2, + 0xB3, 0xB3, 0xB9, 0x12, 0xD8, 0x2E, 0x97, 0x73, 0x55, 0xB7, 0x3F, 0x7D, + 0xFA, 0x09, 0x80, 0xAC, 0x37, 0x7B, 0x55, 0x4B, 0x25, 0xA1, 0x0C, 0x7D, + 0x48, 0xD6, 0x98, 0x18, 0xE3, 0x62, 0x31, 0x7F, 0xFB, 0xEE, 0xFA, 0xF3, + 0x4F, 0x1F, 0x2E, 0x17, 0x13, 0xED, 0x95, 0xC5, 0xCC, 0x51, 0x9B, 0xA6, + 0x8C, 0xDE, 0x6E, 0x10, 0x12, 0xD1, 0xCC, 0xCB, 0xBB, 0x12, 0x72, 0x02, + 0xF0, 0xCB, 0x42, 0xD0, 0xB8, 0xEC, 0xE9, 0x9F, 0x4E, 0xD6, 0xF3, 0xFD, + 0x85, 0x3D, 0x5E, 0xFC, 0x7F, 0x06, 0xA3, 0xA1, 0x2E, 0x3D, 0x02, 0x44, + 0xB4, 0xC6, 0x3C, 0x7B, 0xF5, 0xFE, 0x87, 0x57, 0xB7, 0x49, 0x60, 0x52, + 0xBB, 0x5F, 0xFE, 0xEC, 0xA9, 0x31, 0xE6, 0x66, 0xB5, 0x79, 0xF2, 0xE8, + 0x61, 0xEF, 0xE3, 0xBB, 0xAB, 0xD5, 0xFB, 0x9B, 0xDD, 0xD7, 0xDF, 0xBD, + 0x52, 0x38, 0x3C, 0x99, 0xD4, 0x86, 0x28, 0xC6, 0x34, 0x99, 0x34, 0xBB, + 0xDD, 0xE1, 0xD5, 0x9B, 0xF7, 0xBB, 0xDD, 0x7E, 0xB1, 0x98, 0x09, 0xC3, + 0xA3, 0x87, 0x97, 0x31, 0xC6, 0xC3, 0xA1, 0x9B, 0xCF, 0xA7, 0xDA, 0x19, + 0x63, 0xDF, 0x76, 0xE7, 0x8B, 0xD9, 0xE5, 0xF9, 0x7C, 0x40, 0xE5, 0x30, + 0x54, 0x37, 0x8C, 0x3E, 0xE3, 0xDF, 0xC6, 0x0B, 0xE7, 0xFE, 0xB0, 0x9C, + 0x94, 0x33, 0x0F, 0xA3, 0x37, 0x04, 0xD3, 0x60, 0x04, 0x57, 0x45, 0xD3, + 0x1A, 0xB2, 0x12, 0xCF, 0xFE, 0x98, 0xF1, 0xC8, 0xDC, 0x1F, 0xF3, 0x93, + 0x71, 0x96, 0x51, 0x10, 0x79, 0x30, 0x36, 0x89, 0xC8, 0xFC, 0xC7, 0xFF, + 0xF4, 0x9F, 0x09, 0xC1, 0x64, 0x1E, 0x6D, 0x50, 0x65, 0x66, 0x10, 0xB5, + 0xF2, 0x61, 0x5C, 0x8C, 0x3A, 0x7A, 0x33, 0x20, 0x44, 0x10, 0x70, 0x96, + 0x08, 0xF1, 0x76, 0xD7, 0xB5, 0x7D, 0xE4, 0x9C, 0xBF, 0x04, 0x00, 0x90, + 0x58, 0x34, 0xE5, 0x27, 0x97, 0xBC, 0x8A, 0x4C, 0xEA, 0xAA, 0xA9, 0x2C, + 0x02, 0x52, 0x6E, 0x62, 0x42, 0x80, 0x60, 0x8D, 0xB6, 0x47, 0x4C, 0x21, + 0x26, 0x1F, 0xE2, 0xBE, 0xF5, 0xEF, 0xD7, 0x87, 0xD5, 0xAE, 0x8F, 0x89, + 0x0F, 0x9D, 0xEF, 0x7C, 0x3C, 0xB4, 0x7E, 0xDF, 0xF5, 0xDB, 0x7D, 0x7F, + 0xBB, 0xEB, 0xDA, 0x3E, 0xE8, 0xD3, 0x57, 0xCE, 0x3A, 0x67, 0x88, 0xC0, + 0x59, 0xE3, 0x9C, 0x25, 0x42, 0x53, 0x3A, 0x6C, 0x0E, 0x21, 0xA7, 0xFB, + 0x82, 0x32, 0x16, 0x97, 0x61, 0x5C, 0x78, 0x04, 0xAD, 0x07, 0x14, 0x96, + 0xB7, 0xCA, 0x23, 0xED, 0x91, 0x00, 0xE0, 0x44, 0x59, 0x58, 0x9D, 0x51, + 0x9D, 0x65, 0xAC, 0xC6, 0x1F, 0x80, 0x08, 0xAC, 0xB5, 0xBA, 0x96, 0x86, + 0x48, 0x28, 0x11, 0x18, 0x43, 0x95, 0x33, 0x75, 0x65, 0xB5, 0x39, 0x9B, + 0x1A, 0x9B, 0xB9, 0xCA, 0xC7, 0x90, 0x52, 0x59, 0xB8, 0xBA, 0x7A, 0xF1, + 0xE3, 0xAB, 0x2F, 0x7F, 0xFB, 0xF5, 0x66, 0x7B, 0xF0, 0x3E, 0xC4, 0x10, + 0x8D, 0x35, 0xEB, 0xF5, 0xEE, 0xEB, 0x3F, 0x3E, 0xFB, 0xC3, 0x1F, 0x9F, + 0xC5, 0x10, 0xCF, 0xCE, 0x97, 0x29, 0xC6, 0xDE, 0x87, 0xAE, 0xF3, 0xDE, + 0x87, 0xD5, 0x66, 0xD7, 0xF9, 0x18, 0x63, 0x22, 0x22, 0x2D, 0xF3, 0x64, + 0x01, 0xEF, 0x43, 0xD7, 0xFB, 0xDE, 0x7B, 0x22, 0x33, 0x9D, 0x4E, 0x67, + 0xD3, 0x86, 0x0C, 0x75, 0x9D, 0x47, 0x44, 0x63, 0xAC, 0x80, 0x5C, 0x5D, + 0xDF, 0xB6, 0x87, 0x3E, 0xC6, 0xB4, 0xDE, 0xEE, 0x13, 0xC3, 0xA3, 0x87, + 0x17, 0x64, 0xEC, 0xFE, 0xD0, 0xBD, 0x79, 0x77, 0xDB, 0xFB, 0xFE, 0xC1, + 0xC5, 0x52, 0x05, 0x5A, 0xEE, 0x7C, 0xC0, 0x59, 0x1B, 0x63, 0x7C, 0xF6, + 0xE2, 0xDD, 0xCD, 0xCD, 0xA6, 0xEF, 0xDA, 0xAA, 0xAA, 0xB4, 0xB9, 0x72, + 0xF0, 0xE1, 0xD0, 0x1E, 0x9A, 0xA6, 0x51, 0xD4, 0x5C, 0x55, 0xCE, 0xFB, + 0x28, 0x88, 0x75, 0x55, 0xB5, 0xBD, 0x37, 0x64, 0x42, 0x8C, 0x31, 0x25, + 0x41, 0x60, 0x91, 0x18, 0xC2, 0x6A, 0xB5, 0xB9, 0xBA, 0xBE, 0xD5, 0xD8, + 0x59, 0x55, 0xB9, 0xED, 0x6E, 0x7F, 0x71, 0x7E, 0x46, 0x86, 0x0E, 0x87, + 0xAE, 0xAE, 0xAB, 0xA7, 0x9F, 0x3D, 0xF9, 0xF2, 0xF7, 0xDF, 0xAD, 0xD7, + 0x3B, 0x11, 0xF0, 0xBD, 0x0F, 0x31, 0x74, 0xBD, 0x8F, 0x31, 0x09, 0xF3, + 0x74, 0x52, 0x6B, 0x32, 0x5D, 0xD0, 0x14, 0x7B, 0x16, 0x6B, 0xED, 0xA7, + 0x9F, 0x7C, 0xF4, 0xE8, 0xC1, 0xC5, 0xF5, 0xF5, 0xAA, 0xEB, 0xFB, 0x8F, + 0x9F, 0x3C, 0x3A, 0x5B, 0xCC, 0x0E, 0x6D, 0x1B, 0x42, 0x14, 0x81, 0x14, + 0x79, 0x3A, 0x9B, 0xFC, 0xCD, 0x5F, 0xFD, 0x6C, 0xBB, 0xDD, 0xBD, 0x7E, + 0x7B, 0x6D, 0x8C, 0xF9, 0xF9, 0x4F, 0x3F, 0xF5, 0x21, 0x4A, 0xC9, 0xCB, + 0x2F, 0x6B, 0x36, 0x3B, 0x4C, 0x86, 0x89, 0x06, 0x38, 0x5D, 0x45, 0xC3, + 0x67, 0x58, 0x27, 0xC3, 0xB2, 0xC1, 0x63, 0xF6, 0x03, 0x0E, 0xEA, 0x69, + 0x40, 0x1C, 0x27, 0x9B, 0xE5, 0x07, 0xC5, 0x0F, 0xFE, 0xB4, 0x96, 0x44, + 0x44, 0x32, 0x88, 0x80, 0x95, 0x75, 0xDE, 0xFB, 0xFF, 0xF2, 0x8F, 0x5F, + 0x5F, 0xDD, 0xEE, 0x36, 0xEB, 0x7D, 0x88, 0xE1, 0xD0, 0x76, 0xC6, 0x98, + 0xDB, 0xF5, 0xBE, 0xED, 0xBA, 0xD5, 0x7A, 0xF7, 0xFA, 0xDD, 0xED, 0xBE, + 0xF5, 0x7D, 0xEF, 0x57, 0xEB, 0x5D, 0x5D, 0x57, 0x67, 0xCB, 0x45, 0xEF, + 0x63, 0xEF, 0xC3, 0x62, 0x3E, 0x59, 0x6F, 0xF6, 0xDB, 0xED, 0x41, 0x04, + 0x66, 0xB3, 0x29, 0x0B, 0x37, 0xB5, 0xBB, 0x38, 0x5F, 0xBE, 0x7D, 0x77, + 0xF5, 0xEE, 0xFD, 0x8D, 0x0F, 0xD1, 0x5A, 0xEB, 0x7D, 0x40, 0x84, 0x2F, + 0x3E, 0x7B, 0x94, 0x52, 0xD9, 0xBA, 0x4A, 0x58, 0x0F, 0x4A, 0xFE, 0xC1, + 0xA8, 0xEE, 0xE1, 0x54, 0xF3, 0x0E, 0x20, 0x6E, 0x50, 0x61, 0xE3, 0x71, + 0x18, 0xDE, 0xF4, 0xB8, 0x12, 0x06, 0x16, 0xC6, 0xA2, 0xC8, 0x10, 0x4B, + 0x64, 0x1D, 0x20, 0x27, 0x02, 0xDC, 0x1D, 0xF9, 0xFB, 0xF7, 0x1D, 0x96, + 0xE4, 0xE0, 0xA3, 0xBC, 0x7F, 0x98, 0x35, 0x94, 0x95, 0x55, 0xCE, 0x0D, + 0x47, 0x44, 0xCC, 0xF6, 0xF3, 0x78, 0x0E, 0x04, 0x8E, 0x31, 0x3B, 0xD0, + 0xC4, 0x0B, 0x94, 0x3E, 0xA4, 0x98, 0xBA, 0x3E, 0x26, 0xBD, 0x02, 0xB3, + 0xD6, 0x5A, 0x43, 0x64, 0xEE, 0xA3, 0x54, 0xC6, 0x98, 0x8A, 0x9A, 0xDA, + 0xD1, 0xC0, 0xCF, 0x27, 0xD1, 0xC7, 0x18, 0x52, 0x02, 0x44, 0x6B, 0xB0, + 0xF3, 0x31, 0x26, 0x26, 0xC4, 0x69, 0xC3, 0x02, 0xD0, 0xF9, 0xA8, 0x6C, + 0x10, 0x2A, 0x3A, 0x0A, 0xC1, 0x58, 0x40, 0xE9, 0xED, 0x75, 0x8C, 0x89, + 0xC8, 0x18, 0x1F, 0x93, 0xA9, 0x2B, 0xAB, 0x55, 0x2C, 0x44, 0xC8, 0x89, + 0xBD, 0x4F, 0x54, 0x98, 0x57, 0xE1, 0x43, 0xA1, 0xE2, 0xF1, 0xCB, 0xDF, + 0x8F, 0xB3, 0x1C, 0x5F, 0x53, 0x01, 0xB6, 0xFA, 0x90, 0x55, 0xD3, 0x1B, + 0x53, 0xD7, 0x38, 0x44, 0x3C, 0x46, 0xF3, 0x07, 0x44, 0x06, 0x60, 0xE8, + 0x4D, 0x77, 0xBC, 0x8E, 0x96, 0x52, 0x95, 0x7D, 0x43, 0x1A, 0x22, 0xAD, + 0x44, 0x9F, 0x4C, 0x2A, 0x61, 0x49, 0xCC, 0x90, 0xD8, 0x54, 0xEE, 0xEA, + 0xFA, 0xF6, 0x87, 0xEF, 0x9F, 0xD7, 0x75, 0x9D, 0x62, 0x7C, 0xF3, 0xE6, + 0x5D, 0x55, 0xD5, 0xC6, 0xD0, 0xBB, 0x77, 0xD7, 0xAE, 0xAE, 0x41, 0x24, + 0x86, 0x18, 0x6C, 0x38, 0xB4, 0x5D, 0xD7, 0xF7, 0xBB, 0x7D, 0x67, 0x8D, + 0x25, 0x63, 0xA6, 0x4D, 0xB3, 0x5C, 0xCC, 0x43, 0xF0, 0x5D, 0x1F, 0x18, + 0x92, 0x24, 0x59, 0x2C, 0x16, 0x3E, 0x44, 0xEF, 0x3D, 0x00, 0xEC, 0x0F, + 0x87, 0xBA, 0x3E, 0x5B, 0x2C, 0xE6, 0x75, 0xE5, 0x44, 0x60, 0xBD, 0xD9, + 0x31, 0x4B, 0xD3, 0xD4, 0x93, 0x69, 0x03, 0x00, 0x9B, 0xCD, 0xF6, 0xC7, + 0x97, 0x6F, 0x9A, 0xA6, 0xAA, 0x9C, 0x65, 0x4E, 0xDE, 0x87, 0xE7, 0x2F, + 0xDE, 0xFD, 0xF2, 0x2F, 0x9E, 0x8E, 0xA5, 0x50, 0x51, 0xA1, 0x20, 0xAC, + 0xB7, 0xBB, 0xAF, 0xBF, 0x79, 0xB6, 0xDD, 0x75, 0x31, 0x78, 0x6B, 0x1D, + 0x8A, 0x70, 0x4A, 0x7D, 0x4A, 0x02, 0xA2, 0x09, 0x68, 0xCE, 0x39, 0x63, + 0x0C, 0xB3, 0xCC, 0x96, 0xB3, 0x19, 0x50, 0x55, 0xD9, 0x7A, 0xBD, 0x0D, + 0x21, 0xCE, 0x0D, 0xAD, 0x6E, 0xD7, 0xEB, 0xF5, 0x7E, 0xB7, 0xEB, 0xDA, + 0xB6, 0x7D, 0xFC, 0xE8, 0xC1, 0xD3, 0xCF, 0x3F, 0xBD, 0xB8, 0x38, 0xDB, + 0x6C, 0xF7, 0xEF, 0xAF, 0x6E, 0x2E, 0xCE, 0xCF, 0x9C, 0x33, 0x86, 0x8D, + 0x30, 0x3C, 0x7A, 0x70, 0xB6, 0x5A, 0xEF, 0xAE, 0x6F, 0x6E, 0x7D, 0x8C, + 0xE7, 0xB3, 0xF9, 0xE5, 0xF9, 0xE2, 0xA3, 0x47, 0x97, 0xD7, 0x37, 0xAB, + 0x18, 0xD2, 0xAB, 0x77, 0x37, 0x87, 0xCE, 0x3B, 0x63, 0xFB, 0xBE, 0x47, + 0x84, 0xF3, 0x8B, 0xC5, 0x2F, 0x7E, 0xF6, 0x79, 0x62, 0xA9, 0x9C, 0x6D, + 0xBB, 0xAE, 0xED, 0xFA, 0xBA, 0xAE, 0x2F, 0xCE, 0x96, 0x6F, 0xDE, 0x5D, + 0x13, 0x6A, 0x1D, 0x68, 0xD2, 0x68, 0x6C, 0x53, 0xD7, 0x3F, 0x7D, 0xFA, + 0xF1, 0x7C, 0x36, 0xB1, 0xD6, 0xF4, 0x3E, 0x00, 0x40, 0x8A, 0x5C, 0x92, + 0x1F, 0x29, 0x97, 0xEA, 0x21, 0x1A, 0x32, 0x80, 0xA7, 0x96, 0xCE, 0x78, + 0x39, 0x8D, 0x17, 0x2D, 0x16, 0x81, 0x84, 0x0F, 0x7D, 0xE4, 0x9E, 0x6D, + 0xF5, 0x67, 0x0E, 0x3E, 0x39, 0x05, 0xB2, 0xB1, 0x96, 0x5D, 0x3A, 0x44, + 0x44, 0x90, 0xFD, 0x0B, 0xBF, 0xF9, 0xFA, 0xF9, 0xDB, 0xEB, 0x6D, 0x08, + 0x71, 0xD2, 0xD4, 0x95, 0xB3, 0xDF, 0x3F, 0x7F, 0x63, 0xCC, 0xFB, 0x9F, + 0x7F, 0xF1, 0xE9, 0xC3, 0x8B, 0xB3, 0x6F, 0xBE, 0x7F, 0xF1, 0xFC, 0xE5, + 0x9B, 0xA7, 0x9F, 0x3D, 0x51, 0x54, 0x5B, 0x55, 0xD5, 0xD5, 0xF5, 0x6A, + 0x36, 0x9D, 0x4C, 0x27, 0xCD, 0x8F, 0x2F, 0xDE, 0xBE, 0x7B, 0x7F, 0xBB, + 0xD9, 0xED, 0x2F, 0xCF, 0xCF, 0x10, 0xF1, 0xE6, 0x66, 0xED, 0xBD, 0x3F, + 0x5B, 0x2E, 0x7E, 0xF5, 0x8B, 0x2F, 0x6E, 0xD7, 0x9B, 0xFD, 0xBE, 0xBB, + 0x5D, 0x6D, 0x10, 0xF1, 0xFA, 0x76, 0x1B, 0x4B, 0xAE, 0xBF, 0x14, 0xCB, + 0x4E, 0x8E, 0xF9, 0xDB, 0xF7, 0xF2, 0xA9, 0x46, 0x43, 0x34, 0xD8, 0x94, + 0x83, 0x43, 0xE6, 0xCF, 0x8C, 0xCC, 0x89, 0xF1, 0xAE, 0x0B, 0x68, 0xA4, + 0xF1, 0x10, 0xF1, 0x38, 0xC8, 0xF7, 0x35, 0xD4, 0x70, 0x62, 0x81, 0x1D, + 0xC7, 0xB4, 0xD8, 0xE2, 0x3C, 0x3D, 0xDE, 0xCB, 0x02, 0xA2, 0x6A, 0xCB, + 0xD1, 0x63, 0xE5, 0x89, 0x49, 0x20, 0xC7, 0x1A, 0xB5, 0xE1, 0xBF, 0xF9, + 0xD2, 0x90, 0x04, 0x24, 0x30, 0x91, 0x9A, 0x93, 0x38, 0xA4, 0x0E, 0x48, + 0x61, 0xB4, 0x23, 0x42, 0x22, 0xF0, 0x21, 0xC5, 0x94, 0xB4, 0xC3, 0x9B, + 0xF2, 0x8E, 0x11, 0xE1, 0xD9, 0xAC, 0x11, 0x80, 0x6B, 0xBF, 0xF7, 0x91, + 0x0D, 0x61, 0x4A, 0xE2, 0x53, 0xEA, 0x7D, 0x32, 0x5A, 0x73, 0xC3, 0x6C, + 0x89, 0x42, 0x14, 0x1F, 0x19, 0x49, 0x23, 0x00, 0xB9, 0xCC, 0x50, 0x99, + 0x63, 0x17, 0xB3, 0x46, 0x01, 0x02, 0xB3, 0x78, 0x1F, 0x7C, 0x48, 0x95, + 0x33, 0x55, 0x65, 0x45, 0xA0, 0x54, 0x73, 0xDE, 0x41, 0xB9, 0xF7, 0x77, + 0x15, 0xFD, 0xD3, 0x49, 0xF2, 0xCB, 0x58, 0xDF, 0x0F, 0xC0, 0x18, 0x75, + 0x7C, 0xCA, 0xDC, 0x8E, 0x76, 0xF2, 0xE3, 0x34, 0xE3, 0xA8, 0xAB, 0xE0, + 0xF8, 0x9A, 0xE5, 0xBE, 0xA0, 0x80, 0x51, 0xEF, 0xAC, 0xDE, 0x9F, 0xF5, + 0x66, 0xF7, 0xD5, 0x57, 0x7F, 0xB4, 0xD6, 0x0D, 0x25, 0xD9, 0xC1, 0x87, + 0x9E, 0x93, 0x21, 0xF4, 0x6D, 0xCB, 0xCC, 0xEB, 0xD5, 0x9A, 0x45, 0x62, + 0xE4, 0xDE, 0x7B, 0x25, 0xFF, 0x78, 0x70, 0x79, 0x51, 0x55, 0x75, 0x62, + 0x69, 0x26, 0xD3, 0xF3, 0xF3, 0x6A, 0xB7, 0xDB, 0x5F, 0xDD, 0xAC, 0x5C, + 0xE5, 0xAC, 0xB5, 0xCC, 0x42, 0x84, 0x87, 0xB6, 0x7B, 0xE3, 0xC3, 0x64, + 0xD2, 0x4C, 0x27, 0xF5, 0x6C, 0x36, 0x35, 0xC6, 0xCC, 0x26, 0x8D, 0x35, + 0x64, 0x8D, 0x61, 0xE1, 0xC5, 0x62, 0xC1, 0x22, 0xEB, 0xF5, 0x0E, 0x09, + 0xAD, 0xC1, 0xB3, 0xE5, 0x3C, 0xA5, 0xB4, 0xD9, 0x1E, 0xCE, 0x97, 0xF3, + 0x10, 0x23, 0x33, 0x1B, 0x43, 0xEB, 0xCD, 0xDE, 0xFB, 0x70, 0x7D, 0xBB, + 0x7E, 0xF9, 0xFA, 0xDA, 0x87, 0x70, 0xB6, 0x5C, 0x78, 0x22, 0x57, 0x31, + 0x82, 0x52, 0x5C, 0xA4, 0xD9, 0xC5, 0xCC, 0x59, 0x7B, 0x75, 0x75, 0xD3, + 0x75, 0x7D, 0xDD, 0xD4, 0xC6, 0x28, 0x43, 0x00, 0xC4, 0xC4, 0x9F, 0x7E, + 0xFA, 0x64, 0xB3, 0xD9, 0x9D, 0x9F, 0x2F, 0x37, 0x17, 0xE7, 0x2F, 0x5F, + 0xBE, 0x9D, 0x4C, 0x9B, 0xBF, 0xFA, 0xF5, 0xCF, 0xE7, 0xF3, 0xE9, 0x6A, + 0xBD, 0x5D, 0x6F, 0x76, 0x95, 0xB3, 0x3F, 0x79, 0xFA, 0xB1, 0x75, 0xCE, + 0x1A, 0xF3, 0xFD, 0xB3, 0x97, 0xAB, 0xF5, 0x6E, 0x3A, 0x6D, 0xFE, 0xF8, + 0xED, 0xF3, 0xDD, 0xBE, 0x9D, 0x4E, 0xAA, 0x7F, 0xFB, 0x77, 0x7F, 0x35, + 0x9F, 0x4D, 0xFB, 0xBE, 0xDB, 0x6E, 0xF7, 0x00, 0xF0, 0xE0, 0x62, 0xEE, + 0x43, 0xE2, 0x04, 0x8B, 0xC5, 0x64, 0xBB, 0x3B, 0x4C, 0x27, 0xCD, 0x67, + 0x9F, 0x3C, 0x0A, 0x31, 0x39, 0x6B, 0xBF, 0xFC, 0xFA, 0xFB, 0x67, 0x2F, + 0xDE, 0x3C, 0x7A, 0x70, 0x71, 0xBB, 0xDE, 0xBC, 0x7C, 0xF5, 0x6E, 0xBF, + 0x6F, 0xD5, 0xAB, 0xF0, 0xC9, 0xC7, 0x8F, 0x43, 0x08, 0xBF, 0xFF, 0xC3, + 0x0F, 0x97, 0x17, 0x8B, 0xBF, 0xFD, 0xF5, 0x5F, 0xFC, 0xE1, 0xDB, 0xE7, + 0x6D, 0xE7, 0x27, 0xB5, 0xEB, 0x39, 0x16, 0x3F, 0x94, 0x18, 0x32, 0x28, + 0x18, 0x25, 0xE9, 0x74, 0x52, 0xB1, 0x6B, 0xEE, 0x6F, 0x66, 0x78, 0xCF, + 0xD9, 0x3C, 0x4C, 0xE9, 0x09, 0xDF, 0xC1, 0x78, 0xAE, 0xE5, 0x8E, 0x03, + 0xE8, 0x78, 0xC0, 0xC9, 0x6E, 0x5A, 0x44, 0x08, 0x07, 0xBF, 0x33, 0x22, + 0xE6, 0xD2, 0x31, 0x80, 0xCA, 0xB9, 0xAF, 0xBE, 0x7B, 0xF1, 0xD5, 0xB7, + 0xAF, 0x36, 0xDB, 0xFD, 0xD9, 0x72, 0xF1, 0xF0, 0xE1, 0x79, 0x7B, 0xE8, + 0x8C, 0x31, 0x17, 0x67, 0x8B, 0xF9, 0x74, 0xB2, 0xD9, 0x1D, 0x12, 0xCB, + 0x74, 0x3A, 0xBD, 0x5D, 0x6D, 0x8D, 0x35, 0x75, 0x55, 0x39, 0x6B, 0x26, + 0x93, 0xC5, 0x6A, 0xB5, 0x5D, 0x6F, 0x77, 0xEB, 0xF5, 0xEE, 0xFA, 0x76, + 0x25, 0x00, 0x21, 0xA6, 0xCD, 0x76, 0xF7, 0xF4, 0xD3, 0xC7, 0x7D, 0x1F, + 0xDF, 0xBD, 0xBF, 0x59, 0xAD, 0x36, 0x9F, 0x7E, 0xFC, 0x68, 0x3E, 0x9D, + 0xBE, 0x79, 0x77, 0xDD, 0x76, 0x7E, 0xBB, 0xDD, 0x0F, 0xFE, 0xF5, 0x12, + 0x5D, 0x28, 0x39, 0x70, 0x45, 0x8D, 0x8C, 0x47, 0x63, 0x78, 0x05, 0xC9, + 0x69, 0xBD, 0x43, 0x60, 0xF0, 0x78, 0x00, 0xDC, 0xD5, 0xE0, 0xE3, 0x31, + 0x1C, 0x7E, 0x16, 0x38, 0x2D, 0x2C, 0xBF, 0x63, 0x05, 0x8C, 0x16, 0x17, + 0x8E, 0x0C, 0xC9, 0xE1, 0xEE, 0xA3, 0xB4, 0xDB, 0x3B, 0xEB, 0x0B, 0x00, + 0x98, 0xD9, 0x1E, 0x0F, 0xCD, 0x3D, 0xF2, 0x80, 0x47, 0xF1, 0x57, 0x10, + 0x7D, 0x6E, 0x80, 0xC2, 0x16, 0x42, 0x99, 0x6A, 0xFA, 0x88, 0x92, 0x9C, + 0x21, 0x93, 0x0B, 0x0A, 0x00, 0x50, 0x84, 0xC1, 0x1A, 0xB2, 0x96, 0x9C, + 0xA1, 0xD6, 0xA7, 0x7D, 0xD7, 0x59, 0x42, 0x61, 0xA9, 0x2A, 0x40, 0x94, + 0xDA, 0xD9, 0xCA, 0x19, 0x00, 0x68, 0x3B, 0x0F, 0x80, 0xB3, 0xC6, 0x59, + 0x43, 0x3E, 0xA6, 0x3E, 0xE4, 0x2D, 0x82, 0x01, 0x52, 0xE4, 0x8E, 0x13, + 0x02, 0x34, 0x95, 0x01, 0xC0, 0x98, 0x94, 0x88, 0x03, 0x0C, 0x51, 0x62, + 0x26, 0xB2, 0x31, 0xA6, 0xDD, 0xBE, 0xD7, 0xC8, 0x7A, 0xDF, 0xAB, 0xF1, + 0x61, 0x53, 0x62, 0xE7, 0xAC, 0x31, 0xB9, 0x06, 0x6D, 0x3C, 0x46, 0x63, + 0x5B, 0xFA, 0x64, 0x7A, 0x4E, 0x46, 0x7F, 0x2C, 0x6A, 0xC3, 0xE6, 0x3C, + 0x78, 0x3F, 0x4E, 0x64, 0xF7, 0x64, 0xB2, 0xA1, 0x40, 0xB9, 0xE1, 0xFB, + 0x93, 0x24, 0x1A, 0x11, 0x60, 0x4E, 0x55, 0xE5, 0x36, 0xEB, 0xDD, 0x3F, + 0xFE, 0xD3, 0x97, 0xDB, 0x7D, 0xDF, 0x34, 0xD5, 0xA1, 0xF5, 0x95, 0x33, + 0x37, 0xB7, 0x6B, 0x11, 0x68, 0x26, 0xB5, 0x08, 0x20, 0xD1, 0x6E, 0x77, + 0xD0, 0x50, 0xA0, 0x00, 0x28, 0xB2, 0x30, 0xC6, 0xBC, 0x7F, 0x7F, 0x6D, + 0x8C, 0xF5, 0xBD, 0x27, 0x43, 0x8B, 0xF9, 0xEC, 0xE1, 0xA3, 0x07, 0xC6, + 0xD8, 0x9B, 0xDB, 0xF5, 0x7C, 0x36, 0x3B, 0xB4, 0xDD, 0x6E, 0xB7, 0x9F, + 0x4E, 0x9A, 0xC3, 0xA1, 0xED, 0xBA, 0xDE, 0xFB, 0x69, 0x8C, 0x8C, 0x39, + 0x76, 0x2C, 0xAB, 0xCD, 0x76, 0x36, 0x9D, 0x02, 0xC0, 0x6E, 0xB7, 0x0F, + 0xDE, 0xC7, 0x98, 0x3E, 0x7A, 0xFC, 0x00, 0x44, 0x9A, 0xBA, 0xFA, 0xE1, + 0xC7, 0x37, 0x93, 0xA6, 0x7A, 0xFC, 0xF0, 0x62, 0x36, 0x6D, 0xFE, 0xF8, + 0xDD, 0x8B, 0x67, 0x2F, 0xDE, 0x57, 0xB5, 0xE3, 0x94, 0xBC, 0xF7, 0x64, + 0x0D, 0x11, 0xCD, 0xE7, 0xD3, 0x9B, 0x9B, 0x5B, 0x63, 0x2C, 0x89, 0x34, + 0x93, 0x9A, 0x45, 0xDA, 0xAE, 0x0B, 0x41, 0xBB, 0x34, 0x04, 0x4E, 0xCC, + 0x02, 0xCE, 0xB9, 0x8F, 0x9F, 0x3C, 0x5A, 0xCC, 0x67, 0x8B, 0xF9, 0xCC, + 0x87, 0xF0, 0xD9, 0x67, 0x4F, 0x3E, 0x7F, 0xFA, 0xB1, 0xF7, 0x71, 0xBB, + 0x3F, 0xBC, 0x7D, 0x77, 0xFB, 0xEC, 0xF9, 0x4B, 0x22, 0xFC, 0xD9, 0x17, + 0x4F, 0x3F, 0x7A, 0xFC, 0x70, 0xBF, 0x6F, 0x9F, 0xBF, 0x7C, 0x53, 0x39, + 0xFB, 0xF1, 0x93, 0x87, 0xCF, 0x7E, 0x7C, 0xFD, 0xFB, 0xAF, 0xBF, 0x9B, + 0xCF, 0x66, 0x3F, 0xFF, 0xD9, 0xD3, 0xBE, 0xF7, 0x8F, 0x1F, 0x5D, 0x5E, + 0x5F, 0x5D, 0x13, 0x91, 0x2A, 0xAC, 0xE5, 0x7C, 0x62, 0x8C, 0xB1, 0xD6, + 0x4E, 0x1A, 0x57, 0x57, 0xF6, 0xF9, 0x8B, 0x37, 0x95, 0xB3, 0x17, 0x17, + 0x67, 0xBF, 0xFA, 0xF9, 0xE7, 0x7D, 0x1F, 0xAE, 0x6E, 0xD7, 0xEF, 0xAF, + 0x6F, 0xC9, 0x90, 0x73, 0x56, 0xE9, 0x36, 0xF7, 0x87, 0xB6, 0xEF, 0x7A, + 0x20, 0xB4, 0x86, 0x6E, 0x57, 0xBB, 0xA6, 0xA9, 0xBF, 0xFC, 0xE6, 0xF9, + 0xBF, 0xFF, 0xBB, 0x5F, 0x89, 0xF4, 0xC3, 0xF8, 0x33, 0x88, 0x21, 0x63, + 0x88, 0x62, 0xE2, 0xC4, 0x49, 0x94, 0xE1, 0x5D, 0xEE, 0x38, 0xB9, 0x4E, + 0x22, 0x3F, 0x38, 0xB6, 0x2B, 0x3F, 0x64, 0x43, 0x8D, 0x97, 0xD3, 0x9F, + 0x07, 0x65, 0x83, 0x44, 0x8D, 0x96, 0x6B, 0x96, 0x2A, 0xED, 0x4D, 0x26, + 0x22, 0x88, 0xD4, 0xD4, 0x36, 0xC6, 0xB8, 0xDE, 0x77, 0xEA, 0x71, 0xFE, + 0xFE, 0xD9, 0x6B, 0x16, 0x39, 0x5B, 0xCC, 0x17, 0xF3, 0xE9, 0x76, 0xDF, + 0xFA, 0x90, 0x76, 0xFB, 0xC3, 0xE3, 0x47, 0x0F, 0x6E, 0xD7, 0xDB, 0xBF, + 0xFF, 0x1F, 0xFF, 0x2D, 0x11, 0xFE, 0xF8, 0xF2, 0xDD, 0x9B, 0xB7, 0xD7, + 0x3E, 0x04, 0x04, 0xDA, 0xEC, 0xF6, 0x2C, 0x62, 0x8D, 0xD9, 0xEE, 0xF6, + 0x93, 0xA6, 0xBA, 0xB9, 0x5D, 0xAF, 0x56, 0xBB, 0x8B, 0xCB, 0xB3, 0x18, + 0xE2, 0x6F, 0x7E, 0xF7, 0x4D, 0x88, 0xE9, 0xF2, 0xE2, 0xAC, 0xEF, 0x7B, + 0x98, 0xD7, 0x1A, 0x5B, 0xCB, 0x8F, 0x91, 0x1F, 0x0F, 0x10, 0x47, 0xCB, + 0x1E, 0x60, 0xAC, 0xCE, 0xEE, 0xBE, 0xA0, 0x68, 0x46, 0xD4, 0x07, 0x87, + 0xE2, 0xE4, 0xA3, 0x07, 0xB0, 0x28, 0x0F, 0x61, 0xC9, 0xC4, 0x1D, 0x29, + 0xA0, 0x93, 0x8B, 0x8C, 0x11, 0xAE, 0x42, 0x0D, 0x1E, 0xB5, 0x13, 0x12, + 0xF9, 0xB0, 0xCD, 0x8B, 0x88, 0xE6, 0x3F, 0xFE, 0xA7, 0xFF, 0x0C, 0x00, + 0x48, 0xC4, 0xA0, 0x1C, 0x3E, 0xC0, 0x50, 0x40, 0x17, 0x64, 0xED, 0x3B, + 0x7E, 0x56, 0x63, 0x68, 0xDA, 0xD8, 0xCA, 0x19, 0x10, 0xB1, 0x16, 0x27, + 0x95, 0x45, 0x84, 0xCA, 0x92, 0x3E, 0x92, 0x31, 0xB9, 0x19, 0x7A, 0x5D, + 0x1B, 0x24, 0x0C, 0x31, 0xA9, 0x2F, 0xBC, 0xAA, 0xCC, 0x7C, 0x5A, 0x3D, + 0x38, 0x9B, 0x3D, 0x38, 0x9B, 0x55, 0x95, 0x09, 0x31, 0x85, 0x24, 0xCB, + 0x59, 0xAD, 0x65, 0xCF, 0x02, 0x39, 0xDB, 0x3E, 0x31, 0x87, 0xC4, 0x21, + 0x66, 0x5E, 0x3A, 0xED, 0x23, 0xE9, 0x8C, 0xE9, 0x03, 0xAB, 0xB2, 0xBB, + 0xD9, 0x75, 0xBB, 0xD6, 0x83, 0xC8, 0x7A, 0xD7, 0x1E, 0x5A, 0xDF, 0xFB, + 0x88, 0x84, 0xC5, 0xCC, 0xCC, 0x34, 0xB3, 0x5A, 0x38, 0x45, 0x04, 0x6A, + 0xFB, 0xC4, 0x58, 0x78, 0x87, 0x01, 0xD4, 0xB8, 0x18, 0x20, 0xE7, 0x30, + 0x0A, 0x03, 0x04, 0x2B, 0x6D, 0xAA, 0xF0, 0x3E, 0xF2, 0x3A, 0x11, 0xD6, + 0x61, 0xB7, 0x39, 0xD9, 0xBA, 0xC7, 0xFF, 0x8E, 0xE7, 0x49, 0x44, 0x98, + 0xC5, 0x5A, 0xF3, 0xFA, 0xCD, 0xFB, 0xFF, 0xF3, 0xFF, 0xFA, 0xA7, 0xB7, + 0xEF, 0xD7, 0x49, 0x64, 0xB5, 0xDE, 0xB6, 0x7D, 0xEC, 0x7C, 0x58, 0xDD, + 0x6E, 0xBB, 0xCE, 0x33, 0x40, 0x08, 0xA9, 0x8F, 0xB1, 0xEB, 0xFD, 0xA1, + 0xED, 0x42, 0x48, 0x7D, 0xDF, 0xCF, 0x17, 0x73, 0x2D, 0x6F, 0x44, 0xA4, + 0xBE, 0x0F, 0x20, 0x10, 0x13, 0x6F, 0xF7, 0x87, 0xCD, 0x66, 0x4B, 0x48, + 0x8B, 0xE5, 0x1C, 0x00, 0x67, 0xD3, 0x26, 0x86, 0xE8, 0x63, 0xB8, 0xB8, + 0x38, 0x03, 0x80, 0xE9, 0xA4, 0x21, 0xA2, 0xED, 0x76, 0xB7, 0xDD, 0xEE, + 0x45, 0xA4, 0xEB, 0xFD, 0x6E, 0x7B, 0xD8, 0xEE, 0x76, 0x21, 0x44, 0x67, + 0xAD, 0xB5, 0xD6, 0x10, 0x59, 0x6B, 0xE6, 0xB3, 0x89, 0x08, 0xAC, 0x36, + 0xBB, 0xC3, 0xBE, 0xED, 0xBB, 0xEE, 0xD9, 0x8B, 0xF7, 0x31, 0xC5, 0xC5, + 0x7C, 0x66, 0xAD, 0x61, 0x66, 0x6B, 0xAC, 0xB5, 0xA6, 0x69, 0x2A, 0x63, + 0x0C, 0x12, 0x56, 0xCE, 0x85, 0x98, 0xDA, 0xAE, 0x45, 0xA4, 0xF3, 0x8B, + 0x33, 0x22, 0x9A, 0x4D, 0x27, 0x4F, 0x3E, 0x7A, 0xFC, 0xE4, 0xF1, 0xC3, + 0x47, 0x0F, 0x2F, 0x66, 0xD3, 0x49, 0x4C, 0x1C, 0x7C, 0x00, 0x40, 0x6B, + 0x8C, 0xF7, 0x7E, 0xB3, 0xDD, 0x75, 0xBD, 0x7F, 0x7F, 0x75, 0x1B, 0x63, + 0xFA, 0xC9, 0xE7, 0x9F, 0x58, 0x6B, 0x5E, 0xBE, 0x7E, 0x7B, 0x71, 0xBE, + 0x9C, 0xCD, 0xA6, 0xC6, 0xD0, 0xBB, 0xF7, 0xB7, 0xBF, 0xF9, 0xDD, 0x1F, + 0x45, 0x24, 0xA6, 0x34, 0x9B, 0x4D, 0xEA, 0xCA, 0xB5, 0x6D, 0xDF, 0x34, + 0x6E, 0xB3, 0xD9, 0xE9, 0x32, 0x52, 0x02, 0x0C, 0x63, 0x68, 0x36, 0x9D, + 0x4C, 0x67, 0xD3, 0x10, 0x22, 0x21, 0x7A, 0x1F, 0x1F, 0x3F, 0xBA, 0xFC, + 0xEB, 0xBF, 0xFC, 0x02, 0x01, 0x98, 0x65, 0x3E, 0x9B, 0x5E, 0x9C, 0x2F, + 0x1F, 0x3F, 0xBC, 0x7C, 0xFC, 0xF8, 0x72, 0x7F, 0x68, 0x53, 0xE2, 0x27, + 0x8F, 0x1F, 0xEE, 0x0E, 0x2D, 0x11, 0x59, 0x6B, 0x5F, 0xBD, 0xB9, 0xFA, + 0xF9, 0x4F, 0x3F, 0x1E, 0xD6, 0x52, 0x8E, 0x90, 0x30, 0x83, 0x80, 0x51, + 0x4A, 0xC8, 0xD2, 0x60, 0x05, 0x47, 0xEE, 0xB0, 0xF1, 0x14, 0x53, 0x29, + 0xFC, 0x18, 0x44, 0xE5, 0xE4, 0x98, 0xFB, 0xEB, 0xEA, 0x44, 0x36, 0xC6, + 0xC7, 0xEB, 0x0F, 0xC6, 0x18, 0xF5, 0x46, 0x0F, 0xFE, 0x23, 0x43, 0x59, + 0xE0, 0xEA, 0xAA, 0x22, 0xC2, 0xCD, 0xFE, 0xF0, 0xFB, 0x6F, 0x7E, 0xDC, + 0xEC, 0x7B, 0x6B, 0xED, 0x7A, 0xBB, 0x9B, 0x34, 0xD5, 0x4F, 0x3E, 0x7B, + 0xFC, 0xC5, 0xE7, 0x4F, 0x00, 0xF0, 0xDD, 0xD5, 0x6A, 0xB5, 0xDE, 0x4E, + 0x9A, 0x66, 0xB9, 0x98, 0xDD, 0xAE, 0x36, 0xAE, 0x72, 0x2F, 0x5F, 0xBD, + 0xEB, 0xFA, 0x90, 0x52, 0x7A, 0x7F, 0x75, 0x9B, 0x52, 0x5A, 0xAD, 0x37, + 0xEA, 0xC4, 0x35, 0x06, 0x27, 0x4D, 0xDD, 0x75, 0xBE, 0xAE, 0x2B, 0x6B, + 0xCC, 0x62, 0x31, 0xB3, 0xD6, 0xAE, 0xD7, 0x9B, 0xC4, 0x1C, 0x7C, 0x00, + 0xA4, 0xBF, 0xFE, 0xC5, 0xD3, 0x49, 0x53, 0x0D, 0x06, 0x1A, 0x0E, 0xC8, + 0xF0, 0xF8, 0x76, 0x1F, 0xF6, 0x32, 0x03, 0x00, 0x96, 0xFE, 0xAA, 0xF7, + 0x41, 0xD3, 0x7D, 0x65, 0x2D, 0x22, 0xA5, 0xDC, 0x1F, 0x45, 0xEF, 0x37, + 0xDA, 0x0F, 0x4E, 0x76, 0xFD, 0x93, 0x15, 0x34, 0xE8, 0xAF, 0xE1, 0xDF, + 0x61, 0xA6, 0xEE, 0x4E, 0x0D, 0x29, 0xFF, 0xDC, 0xB0, 0xE4, 0xEE, 0x2F, + 0x5A, 0x01, 0x38, 0x56, 0xCA, 0x8B, 0x08, 0x33, 0x20, 0xB0, 0x76, 0xC5, + 0x54, 0xFD, 0x4D, 0x84, 0x8D, 0xAB, 0x94, 0x25, 0x71, 0xDE, 0x54, 0xCC, + 0x72, 0x80, 0x88, 0x00, 0x4A, 0x78, 0xAF, 0xB5, 0x93, 0x8F, 0x2F, 0xE7, + 0x67, 0x8B, 0x89, 0x35, 0x34, 0x9D, 0xD4, 0xCC, 0x1C, 0x77, 0x89, 0x10, + 0xE7, 0x8D, 0xF3, 0x31, 0x1D, 0xBA, 0xA0, 0x17, 0x27, 0xC4, 0x10, 0x25, + 0x84, 0x52, 0xB1, 0x20, 0xA8, 0xE9, 0x01, 0xCE, 0x9A, 0xC8, 0x1C, 0x12, + 0x13, 0x41, 0x4A, 0x82, 0x80, 0x3E, 0xA6, 0xCD, 0xA1, 0x5F, 0xCE, 0xEA, + 0xC2, 0x7F, 0xC0, 0x31, 0x61, 0x4C, 0x8C, 0x88, 0x86, 0x08, 0x10, 0x4C, + 0xA2, 0xCA, 0x82, 0x31, 0x0E, 0x11, 0x75, 0x4D, 0x7A, 0x1F, 0x9D, 0xB3, + 0xCC, 0xAC, 0x79, 0x6D, 0xD6, 0x82, 0x29, 0xE4, 0xCD, 0x63, 0x68, 0x06, + 0xF7, 0x0C, 0x84, 0xFB, 0x9F, 0x0F, 0x5A, 0x22, 0x27, 0x26, 0xC6, 0xD8, + 0x68, 0x1D, 0x6F, 0x23, 0xC6, 0x50, 0x4A, 0xFC, 0xCF, 0xFF, 0xFA, 0x87, + 0xAB, 0xDB, 0xAD, 0xB5, 0x86, 0x53, 0x02, 0x81, 0xAA, 0x76, 0xEB, 0xCD, + 0xB6, 0xF5, 0x3D, 0x01, 0xFA, 0x55, 0x34, 0xD6, 0xA4, 0x98, 0x2E, 0x2E, + 0xCF, 0x01, 0x70, 0xBD, 0xDE, 0x32, 0x4B, 0x08, 0x71, 0xB9, 0x5C, 0x10, + 0xD1, 0x76, 0xBB, 0xAF, 0x9B, 0xFA, 0xE2, 0xE2, 0x6C, 0x75, 0xBB, 0xDE, + 0x1F, 0x0E, 0x22, 0xE0, 0x43, 0x08, 0x3E, 0x3A, 0xE7, 0x98, 0xF9, 0x2F, + 0xBE, 0xF8, 0xFC, 0xC5, 0xCB, 0xD7, 0x22, 0xFC, 0x93, 0xCF, 0x3F, 0xF5, + 0x3E, 0xBC, 0x7A, 0xFD, 0x36, 0x84, 0xD0, 0xF7, 0xC1, 0x7B, 0xDF, 0x75, + 0xDD, 0x6C, 0x36, 0x5B, 0x2E, 0x17, 0x8B, 0xC5, 0x8C, 0x53, 0x8A, 0x31, + 0x2E, 0x97, 0xD3, 0xB3, 0xE5, 0x9C, 0x0C, 0xF5, 0xBD, 0x5F, 0x4C, 0x1B, + 0x4E, 0xE9, 0xD9, 0xB3, 0x57, 0x3E, 0x70, 0x33, 0x99, 0x80, 0x88, 0x73, + 0x76, 0x31, 0x9F, 0x01, 0x40, 0x33, 0xA9, 0x8D, 0x31, 0x44, 0x33, 0x24, + 0xDC, 0x6C, 0x76, 0xC6, 0x98, 0x87, 0x0F, 0x1E, 0x10, 0xA1, 0x0F, 0xF1, + 0xE9, 0x67, 0x9F, 0x20, 0xA2, 0x32, 0xDE, 0x68, 0xF2, 0xC4, 0xD9, 0x7C, + 0x7A, 0xE0, 0xB4, 0x6F, 0xBB, 0xDD, 0x6E, 0xAF, 0x11, 0xCF, 0x94, 0xD2, + 0xE1, 0xD0, 0x8A, 0xC8, 0xE1, 0xD0, 0x7D, 0xF5, 0xE3, 0xAB, 0xCB, 0x8B, + 0xB3, 0xDE, 0xFB, 0xBE, 0xF3, 0xB7, 0xAB, 0xCD, 0x8F, 0x2F, 0xDE, 0x5C, + 0xDF, 0xDC, 0x7E, 0xF4, 0xD1, 0x03, 0x22, 0x0C, 0xDE, 0x77, 0x5D, 0xC7, + 0x2C, 0x17, 0xE7, 0x8F, 0x66, 0xB3, 0xE9, 0xED, 0x6A, 0x6D, 0xAD, 0xFD, + 0x7F, 0x19, 0x7B, 0xAF, 0x26, 0xC9, 0xB6, 0xEC, 0x3C, 0x6C, 0x6D, 0x7F, + 0x7C, 0x9A, 0x72, 0x5D, 0xD5, 0xF6, 0xF6, 0xBD, 0x77, 0xEE, 0x38, 0x80, + 0x00, 0x83, 0x08, 0x90, 0x7C, 0xA1, 0x4C, 0x04, 0x1F, 0x18, 0xC1, 0x9F, + 0x20, 0x85, 0x14, 0x18, 0x90, 0xA0, 0x02, 0x23, 0xFE, 0x30, 0xBD, 0xEA, + 0x41, 0x0F, 0x32, 0x94, 0x28, 0x20, 0x30, 0x00, 0x89, 0xE1, 0xCC, 0x9D, + 0xB9, 0xB6, 0x7D, 0x77, 0x55, 0x97, 0x4B, 0x7B, 0xDC, 0xF6, 0x5B, 0x0F, + 0xFB, 0x64, 0x56, 0x76, 0x55, 0xCF, 0x08, 0x27, 0x3A, 0xAA, 0x33, 0x4F, + 0x9E, 0x34, 0x67, 0xEF, 0xBD, 0xBE, 0xBD, 0xEC, 0xB7, 0x00, 0x40, 0x4A, + 0xCD, 0x19, 0x1B, 0xEC, 0x6E, 0x63, 0xB5, 0xD2, 0x5C, 0xF0, 0xD7, 0x6F, + 0xDE, 0x3F, 0x7E, 0x74, 0xFC, 0xD9, 0x27, 0xF7, 0x9F, 0x3E, 0x3E, 0x89, + 0x6D, 0x05, 0xBA, 0x4E, 0x5E, 0xCE, 0x56, 0xEB, 0xBA, 0x3D, 0x3A, 0xDC, + 0xF3, 0xDE, 0x4B, 0xA9, 0x5F, 0xBD, 0x7D, 0xEF, 0xAC, 0x1F, 0x57, 0xF9, + 0x37, 0xCF, 0xDE, 0xFD, 0xE8, 0xB3, 0x87, 0x76, 0x43, 0x5D, 0xB7, 0x11, + 0x09, 0x80, 0x98, 0x45, 0xB1, 0x21, 0x4A, 0x8A, 0x8B, 0xFF, 0xEE, 0xD4, + 0xEF, 0xE2, 0xD7, 0x2D, 0x71, 0xFD, 0xA8, 0x62, 0x7E, 0xF7, 0xD8, 0x4A, + 0xE3, 0xF6, 0xE9, 0xF6, 0xD3, 0x06, 0xB1, 0x44, 0x28, 0x5A, 0x33, 0x04, + 0xE3, 0xB7, 0x17, 0xD7, 0xEF, 0xCE, 0x17, 0x4D, 0xA7, 0xCE, 0xAE, 0xD7, + 0x75, 0xD3, 0x1A, 0x6D, 0xB4, 0x31, 0x0B, 0x6B, 0xBD, 0xF7, 0x6D, 0x27, + 0xFB, 0x5E, 0x9D, 0x5D, 0x5C, 0x53, 0x42, 0x8A, 0x22, 0x0B, 0x21, 0x3C, + 0x7A, 0x70, 0x7C, 0x71, 0xB5, 0x58, 0x2E, 0xD7, 0xEB, 0x75, 0x43, 0x28, + 0x0E, 0x3E, 0xD4, 0x75, 0x83, 0x09, 0xF1, 0x21, 0x30, 0x46, 0xA7, 0xE3, + 0x51, 0x51, 0x64, 0xA3, 0x32, 0x6F, 0xBB, 0xBE, 0xEB, 0xD4, 0xE9, 0xD9, + 0x85, 0xD6, 0x9A, 0x10, 0x6C, 0x8C, 0x25, 0x84, 0x2C, 0x56, 0x75, 0x27, + 0xD5, 0xA8, 0xCA, 0x62, 0x32, 0xFC, 0xAD, 0x9F, 0xBC, 0x5D, 0xD7, 0xF0, + 0x21, 0x3A, 0xEF, 0xDE, 0x14, 0x7C, 0x47, 0x02, 0x5C, 0x71, 0x00, 0x00, + 0x20, 0x00, 0x49, 0x44, 0x41, 0x54, 0xB8, 0x91, 0xDF, 0xBA, 0x0C, 0xED, + 0x18, 0x95, 0x91, 0x90, 0x27, 0xC4, 0xDE, 0x62, 0x3B, 0x12, 0xB1, 0x1D, + 0xCF, 0xDD, 0x6D, 0x66, 0x77, 0xAC, 0x6E, 0x7D, 0xDA, 0xC6, 0x85, 0x37, + 0xE4, 0x09, 0xDF, 0xDA, 0x78, 0x10, 0x02, 0xBA, 0xF9, 0xCA, 0xCD, 0x6F, + 0xBF, 0x71, 0xA3, 0x85, 0xB0, 0x69, 0xD9, 0xBB, 0x95, 0x54, 0x42, 0xD0, + 0xA4, 0x4A, 0x9C, 0x0B, 0xBD, 0x35, 0x00, 0x90, 0x0A, 0x46, 0x10, 0x1E, + 0xF2, 0xAA, 0x52, 0x81, 0x00, 0x4C, 0xF0, 0xCE, 0x7B, 0x04, 0x88, 0x62, + 0x24, 0x18, 0x99, 0x56, 0x59, 0x9E, 0xF2, 0x2A, 0x4F, 0x00, 0xA1, 0xC8, + 0x27, 0xB0, 0xAE, 0xFB, 0x75, 0x2B, 0xAD, 0xF3, 0xAD, 0xD4, 0x6D, 0x6F, + 0x42, 0x00, 0x42, 0x86, 0xF2, 0x77, 0x40, 0xC1, 0x43, 0x08, 0x08, 0x8E, + 0xC6, 0x99, 0xF7, 0xA1, 0x91, 0x46, 0x5B, 0xAF, 0xB4, 0x63, 0x0C, 0xA5, + 0x82, 0x32, 0x8C, 0x32, 0x41, 0xED, 0x26, 0x1E, 0xDA, 0x6B, 0xAB, 0xB5, + 0x75, 0x01, 0x08, 0x42, 0x84, 0x00, 0x0A, 0x50, 0x64, 0x62, 0x5A, 0xC5, + 0x18, 0xF3, 0x10, 0xED, 0x02, 0xA0, 0x00, 0x01, 0x63, 0x9C, 0x65, 0x62, + 0x67, 0x38, 0x86, 0xF0, 0xE2, 0x2D, 0xF8, 0x0F, 0x1F, 0x5A, 0xF5, 0xB7, + 0x56, 0xDE, 0x76, 0x0E, 0x6E, 0x3D, 0xB8, 0xF5, 0xD2, 0x2D, 0x25, 0x79, + 0xF7, 0x71, 0x08, 0x61, 0xB5, 0x6E, 0x5E, 0xBD, 0x7E, 0x3F, 0x5F, 0xD4, + 0x82, 0x73, 0xAD, 0x2D, 0x26, 0x38, 0xCF, 0xB3, 0xA6, 0xE9, 0x8C, 0x36, + 0x94, 0x52, 0xC6, 0x18, 0xE3, 0x2C, 0x11, 0x42, 0x4A, 0x75, 0x3D, 0x5B, + 0x96, 0x45, 0x9E, 0x97, 0x45, 0xFC, 0xFA, 0x75, 0xDD, 0x08, 0xC1, 0x08, + 0x25, 0x52, 0xAA, 0xC5, 0x62, 0xC5, 0x19, 0x2B, 0xCB, 0x82, 0x73, 0x96, + 0xA6, 0xA9, 0xB1, 0xB6, 0xED, 0xBA, 0xAE, 0x93, 0xE7, 0x17, 0xB3, 0x34, + 0x4D, 0xE6, 0x57, 0x8B, 0xE0, 0x91, 0x0F, 0xDE, 0x1A, 0xAB, 0xB5, 0x49, + 0x12, 0x4E, 0x09, 0xA9, 0xCA, 0x82, 0x31, 0xFA, 0xF8, 0xD1, 0xFD, 0x24, + 0x11, 0x4A, 0x29, 0x82, 0x21, 0x15, 0x1C, 0x63, 0x24, 0x38, 0x13, 0x9C, + 0x81, 0xF7, 0xD6, 0xB8, 0x80, 0x30, 0x26, 0xC0, 0x28, 0x15, 0x09, 0x4F, + 0xD3, 0xC4, 0x3A, 0xCF, 0x19, 0xA3, 0x94, 0x2C, 0x16, 0x2B, 0x6B, 0x5C, + 0x51, 0xE6, 0xE3, 0x71, 0x15, 0x42, 0xDC, 0x00, 0x80, 0x73, 0x8E, 0x10, + 0x38, 0xEF, 0x00, 0x80, 0x10, 0x22, 0x95, 0x0E, 0xC1, 0xBF, 0x7E, 0x7B, + 0x96, 0x65, 0xD9, 0xC5, 0xE5, 0xB5, 0xF7, 0xE1, 0x60, 0x7F, 0x9C, 0xF2, + 0x64, 0xBE, 0xA8, 0xF7, 0xF7, 0xC6, 0x3E, 0xF8, 0xF9, 0x7C, 0x91, 0x65, + 0xC9, 0xE3, 0xC7, 0x27, 0xD7, 0xF3, 0xF5, 0xD9, 0xF9, 0x55, 0x08, 0xC1, + 0x3A, 0xBB, 0x37, 0x29, 0x12, 0x86, 0x31, 0x21, 0x04, 0x41, 0xDB, 0xF6, + 0x3E, 0xC0, 0xE5, 0xD5, 0x9C, 0x10, 0x62, 0xAC, 0x23, 0x14, 0xC6, 0x55, + 0xD9, 0x4B, 0x69, 0xBD, 0x47, 0x21, 0xF6, 0x04, 0x70, 0x8B, 0xE5, 0xBA, + 0xCC, 0x73, 0x42, 0x68, 0xD7, 0xCB, 0x98, 0xA7, 0x92, 0xA7, 0x89, 0xD6, + 0x66, 0x32, 0x2E, 0xB5, 0xB1, 0x52, 0x8D, 0x18, 0x65, 0x17, 0x17, 0x33, + 0x6D, 0x0C, 0x25, 0x78, 0xB5, 0x6E, 0x08, 0xC1, 0xCF, 0x5E, 0x9D, 0x3D, + 0x79, 0x78, 0x84, 0x37, 0x75, 0xD2, 0x00, 0x40, 0x10, 0xF6, 0x9B, 0x0C, + 0x2A, 0x02, 0x18, 0x10, 0xF8, 0x9B, 0xE0, 0x0F, 0xC0, 0xC6, 0x73, 0xBA, + 0xBB, 0xF9, 0xEF, 0x42, 0xD8, 0xAD, 0x03, 0xEF, 0x90, 0x9A, 0xDE, 0x35, + 0xB2, 0xEE, 0x5E, 0xBF, 0x11, 0x54, 0x14, 0x02, 0x78, 0xE7, 0x11, 0xC1, + 0x10, 0xC0, 0x7B, 0x9F, 0x26, 0xE2, 0xF2, 0x7A, 0xF1, 0xD7, 0xFF, 0xF9, + 0x5B, 0x1F, 0x50, 0xDD, 0xB4, 0xDA, 0x58, 0xE7, 0x3C, 0x26, 0x84, 0x86, + 0xD0, 0x4B, 0x79, 0xA5, 0x75, 0x4C, 0x37, 0x11, 0x82, 0xC7, 0x44, 0x42, + 0xA5, 0xCC, 0xD1, 0xD1, 0x74, 0x54, 0xE5, 0xF3, 0xC5, 0x0A, 0xA3, 0x21, + 0xAF, 0x15, 0x63, 0xE2, 0x8C, 0xA2, 0x94, 0x8C, 0xCA, 0x02, 0x20, 0xB4, + 0x5D, 0x8F, 0x11, 0x7A, 0x70, 0x72, 0xF8, 0xF6, 0xDD, 0xF9, 0xC2, 0x3A, + 0xA5, 0x0D, 0xA3, 0x2C, 0xC6, 0xDC, 0xB5, 0xB5, 0x5F, 0x3F, 0x3F, 0xFB, + 0xE4, 0xC1, 0xE1, 0x96, 0xA6, 0x14, 0x06, 0x6F, 0xD2, 0x60, 0xF0, 0xC6, + 0x5B, 0xF9, 0x28, 0x88, 0xC3, 0x87, 0x74, 0x3D, 0xBB, 0x42, 0x74, 0x6B, + 0xB5, 0xC7, 0x21, 0x77, 0xE1, 0x03, 0xBD, 0xF5, 0xD6, 0x96, 0xBF, 0xF3, + 0x46, 0xB4, 0xAB, 0x1A, 0xC3, 0x26, 0xF8, 0xB0, 0xA3, 0x25, 0x84, 0xCD, + 0x99, 0x81, 0xBA, 0x79, 0x13, 0x27, 0x41, 0x21, 0x00, 0xC6, 0x70, 0xD3, + 0xD7, 0x72, 0x4B, 0x91, 0x38, 0x38, 0xFC, 0x37, 0x7D, 0x64, 0xD1, 0xC6, + 0x18, 0x4B, 0x04, 0x4D, 0x39, 0x4D, 0x39, 0x0D, 0x01, 0x08, 0x46, 0x6D, + 0x6F, 0x94, 0xB6, 0xBD, 0x0F, 0x9C, 0xE1, 0x54, 0x30, 0xEB, 0x03, 0x67, + 0x84, 0x01, 0x2E, 0x53, 0x51, 0x65, 0x42, 0xF0, 0xC1, 0x03, 0x4D, 0x09, + 0x56, 0xC6, 0x12, 0x8C, 0xB5, 0xB1, 0x8B, 0xBA, 0x6D, 0x3A, 0xD5, 0x29, + 0xDB, 0xF4, 0x26, 0xA6, 0x9E, 0x31, 0x82, 0x01, 0x40, 0x59, 0x87, 0x00, + 0x18, 0x25, 0xD3, 0x32, 0x49, 0x39, 0xCB, 0x12, 0x16, 0xF7, 0x8A, 0xAB, + 0x55, 0xC7, 0x28, 0x19, 0x67, 0x3C, 0xFE, 0x74, 0x42, 0xB0, 0x71, 0xD6, + 0xFB, 0xE0, 0x42, 0x50, 0xC6, 0x31, 0x8A, 0x31, 0x02, 0x1F, 0x3C, 0x09, + 0x84, 0x31, 0x3C, 0x2A, 0xD2, 0x2C, 0xE5, 0x9C, 0x53, 0x6B, 0x7D, 0x74, + 0x9B, 0x29, 0x6D, 0x19, 0xC5, 0x49, 0x22, 0x18, 0xA3, 0xB7, 0x76, 0xD1, + 0x5B, 0x1B, 0xEF, 0xEF, 0x9A, 0x92, 0xBB, 0x0B, 0x31, 0xEC, 0x38, 0x53, + 0x76, 0xA7, 0x6D, 0x77, 0x41, 0x87, 0x5B, 0x71, 0x03, 0x44, 0x18, 0xA7, + 0x6F, 0xDE, 0x9C, 0xFE, 0xCD, 0x2F, 0xBE, 0xC4, 0x94, 0x22, 0x40, 0x46, + 0x29, 0xEF, 0xBD, 0x31, 0xA1, 0xEF, 0x7A, 0x40, 0xA8, 0x1A, 0x95, 0x59, + 0x96, 0x85, 0x10, 0xB4, 0x36, 0xCE, 0xB9, 0xAA, 0x2A, 0x7B, 0xA9, 0xCE, + 0x2F, 0xAE, 0x1F, 0x3E, 0x3C, 0xB6, 0xD6, 0x59, 0x6B, 0xEB, 0xBA, 0x59, + 0xAF, 0xDD, 0xA8, 0xAA, 0x9C, 0x0B, 0xAB, 0x55, 0x4D, 0x29, 0x39, 0x38, + 0x98, 0xEE, 0xEF, 0x4D, 0xA3, 0x4A, 0x25, 0xA5, 0xF4, 0xDE, 0x59, 0x6B, + 0xA5, 0x94, 0xD6, 0xBA, 0x8B, 0xCB, 0xAB, 0xD1, 0xA8, 0xAC, 0xAA, 0x22, + 0x4D, 0x93, 0xA6, 0xED, 0x94, 0x54, 0x87, 0x87, 0xFB, 0x7B, 0xD3, 0x11, + 0x42, 0x08, 0x20, 0x8C, 0x47, 0x05, 0x40, 0xE0, 0x04, 0x31, 0xC6, 0x8C, + 0xB5, 0x10, 0x7C, 0x70, 0x8E, 0xA7, 0x82, 0xA5, 0x02, 0x00, 0x10, 0xC2, + 0x55, 0x59, 0x10, 0x8C, 0x84, 0xE0, 0x6D, 0x27, 0x9B, 0xB6, 0xA3, 0x8C, + 0x95, 0x55, 0xE5, 0xBD, 0x0F, 0xCE, 0xA1, 0x00, 0x98, 0x60, 0xB2, 0xD1, + 0x37, 0x13, 0xC1, 0x29, 0x25, 0x52, 0x2A, 0xC1, 0x99, 0x36, 0xA6, 0xED, + 0xA4, 0x48, 0x92, 0xFB, 0x27, 0x87, 0x89, 0x10, 0x65, 0x99, 0x7B, 0xEF, + 0x47, 0x55, 0x49, 0x09, 0xD1, 0xD6, 0x9C, 0x9E, 0x9E, 0xBF, 0x7C, 0xF3, + 0x1E, 0x61, 0xB2, 0xBF, 0x37, 0x7E, 0xF8, 0xE0, 0x9E, 0xF7, 0xFE, 0xED, + 0xDB, 0xB3, 0xBF, 0xFF, 0xE5, 0x97, 0x89, 0x60, 0x79, 0x5E, 0x30, 0xCE, + 0xAF, 0xAF, 0x67, 0x08, 0x41, 0x91, 0xA5, 0x71, 0xED, 0x1A, 0x63, 0x8D, + 0xB1, 0x91, 0x13, 0x2D, 0x8E, 0xA7, 0x52, 0x1A, 0x13, 0xD2, 0xF7, 0x92, + 0x71, 0xB6, 0x5C, 0x36, 0x55, 0x99, 0x51, 0x4A, 0x22, 0xBB, 0xFF, 0xF5, + 0x6C, 0xC1, 0x28, 0xFE, 0xEC, 0xF1, 0xFD, 0x8B, 0xEB, 0x45, 0xDB, 0xF7, + 0x8C, 0x52, 0x8C, 0x71, 0x96, 0xA5, 0xC6, 0x3A, 0xA3, 0xED, 0xF9, 0xE5, + 0xFC, 0xC9, 0xC3, 0x23, 0xA9, 0xCD, 0xD6, 0x41, 0x33, 0xAC, 0xF4, 0xCD, + 0xC6, 0xB6, 0x2B, 0x80, 0xF0, 0xA1, 0x23, 0x15, 0xA1, 0x4D, 0x93, 0xE1, + 0x0F, 0xA5, 0xF4, 0xEE, 0xB2, 0x81, 0x8F, 0xED, 0x6D, 0xBB, 0x26, 0xD2, + 0xEE, 0x99, 0x28, 0x5E, 0x51, 0x1B, 0x74, 0xE0, 0x19, 0x61, 0xBD, 0xD2, + 0x7F, 0xF3, 0xAB, 0xEF, 0x2F, 0xAE, 0x96, 0x94, 0x92, 0x07, 0x27, 0x87, + 0x57, 0xB3, 0x15, 0x63, 0xDC, 0x3B, 0xD7, 0x4B, 0x8D, 0x10, 0x0A, 0xDE, + 0x2B, 0x6D, 0xA2, 0xFE, 0x3B, 0x9D, 0x8C, 0xF3, 0x2C, 0x3B, 0x3C, 0x18, + 0x07, 0x40, 0xDF, 0x3D, 0x7F, 0xA3, 0x95, 0xA1, 0x94, 0x19, 0x6B, 0x07, + 0x36, 0x84, 0x00, 0x08, 0x90, 0xF7, 0xBE, 0xEF, 0x25, 0xA5, 0xC4, 0x68, + 0xB3, 0x37, 0xA9, 0x18, 0x67, 0xF7, 0xEE, 0xED, 0x4F, 0xC7, 0x55, 0xDF, + 0xCB, 0x97, 0xAF, 0xCF, 0x00, 0xE0, 0x70, 0x7F, 0xF2, 0xF2, 0xF4, 0xFA, + 0xAB, 0x17, 0x67, 0x9F, 0x3E, 0x3C, 0x34, 0x66, 0xC0, 0xB2, 0x8D, 0xE1, + 0xF5, 0x81, 0x82, 0xF5, 0x51, 0xEB, 0x64, 0x6B, 0xCA, 0xDC, 0xD5, 0x61, + 0x77, 0x9F, 0xFA, 0x10, 0x6E, 0x28, 0xAF, 0x3E, 0x1C, 0x93, 0xF8, 0x20, + 0x6E, 0x8A, 0xDB, 0x3C, 0xE0, 0x08, 0x4C, 0x70, 0xE3, 0xCB, 0x0F, 0x21, + 0xC0, 0x8E, 0xBD, 0x18, 0x75, 0xAA, 0x61, 0x36, 0xD0, 0x8D, 0x37, 0x20, + 0x44, 0x70, 0xA0, 0x37, 0xB3, 0xBB, 0x75, 0x68, 0xDF, 0xDC, 0xD5, 0x26, + 0xF5, 0x23, 0x76, 0x8B, 0x09, 0x60, 0xAC, 0x6B, 0x7B, 0x40, 0x18, 0x79, + 0xE7, 0xB3, 0x84, 0xF9, 0xE0, 0x8D, 0xF5, 0x04, 0x63, 0x46, 0x49, 0x96, + 0x70, 0x84, 0x20, 0xF8, 0x30, 0xA6, 0xC4, 0x0E, 0x81, 0x6D, 0x30, 0xD6, + 0x46, 0x0A, 0x40, 0xEF, 0x43, 0xDD, 0xA9, 0xBA, 0xD7, 0x9C, 0x12, 0x65, + 0x5D, 0xAF, 0x87, 0x7E, 0xBD, 0xC6, 0xFA, 0xA1, 0xB3, 0xD9, 0x50, 0x8B, + 0x84, 0x94, 0xB1, 0xCB, 0x46, 0x22, 0x14, 0xAB, 0x98, 0x91, 0x87, 0xD0, + 0x2A, 0x33, 0xCE, 0x93, 0x54, 0xD0, 0x5E, 0x19, 0xC1, 0xA8, 0x60, 0x60, + 0xAC, 0x73, 0xDE, 0x67, 0x09, 0x47, 0x00, 0x08, 0x41, 0xC2, 0x69, 0xC2, + 0x99, 0xE0, 0xD4, 0x79, 0x6F, 0x8C, 0xE5, 0x9C, 0x71, 0x4E, 0x63, 0x87, + 0x6D, 0x21, 0x18, 0x63, 0x6C, 0xBB, 0xA4, 0x76, 0xD1, 0xE7, 0x96, 0x9E, + 0x0F, 0x77, 0x8E, 0x5D, 0x15, 0xFA, 0xEE, 0xB1, 0xB5, 0x1F, 0x77, 0xDF, + 0xFB, 0xA1, 0xF3, 0x12, 0x21, 0x04, 0xC6, 0xD8, 0xD5, 0xBA, 0xA3, 0x94, + 0x3C, 0x7B, 0xFE, 0x4E, 0x1B, 0xC7, 0x00, 0x5B, 0xEB, 0x82, 0x77, 0x21, + 0x0C, 0x71, 0x52, 0x2E, 0x04, 0x00, 0xEA, 0x7B, 0xC9, 0x18, 0x65, 0x8C, + 0xE5, 0x79, 0x1A, 0x3C, 0x9C, 0x1C, 0x1F, 0x69, 0xE3, 0xBA, 0x5E, 0xA6, + 0x49, 0xA2, 0x95, 0xA6, 0x94, 0x16, 0x79, 0xEE, 0x83, 0x4F, 0x53, 0x51, + 0x96, 0x79, 0x5D, 0xB7, 0x4A, 0xD9, 0xB6, 0x93, 0xCE, 0x59, 0xA5, 0x34, + 0x82, 0x58, 0x24, 0xE4, 0xBD, 0xF7, 0x94, 0xD2, 0x34, 0x4D, 0x93, 0x24, + 0x41, 0x98, 0x74, 0x9D, 0x7C, 0xFF, 0xFE, 0xD2, 0x39, 0xA7, 0x8D, 0x05, + 0x80, 0xFD, 0xBD, 0x71, 0x9A, 0xF0, 0xE0, 0x43, 0x92, 0x88, 0x3C, 0x13, + 0xEB, 0xE5, 0x8A, 0x11, 0x98, 0x94, 0xE2, 0xF9, 0xBB, 0x59, 0x02, 0x28, + 0xCF, 0x12, 0x4A, 0x69, 0xA4, 0x39, 0xC9, 0xF3, 0x0C, 0xBC, 0xFB, 0xFE, + 0xC5, 0xDB, 0xA2, 0x28, 0xCA, 0x3C, 0xD3, 0xDA, 0x60, 0x8C, 0x94, 0xD4, + 0xD1, 0xFB, 0x1E, 0xEF, 0x8E, 0x52, 0xDA, 0x75, 0xDD, 0xFB, 0xF7, 0x57, + 0x5C, 0xF0, 0x2C, 0x4B, 0x7D, 0x08, 0x3F, 0xFE, 0xD1, 0x67, 0x9C, 0x51, + 0xCE, 0x99, 0x31, 0xC6, 0xFB, 0x40, 0x30, 0xA6, 0x84, 0x78, 0xEF, 0x10, + 0x84, 0x17, 0xAF, 0xCE, 0xA4, 0x76, 0x08, 0x41, 0x51, 0xE6, 0x5F, 0x7D, + 0xF5, 0xBD, 0x52, 0xFA, 0xDE, 0xD1, 0xC1, 0xF1, 0xC9, 0xB1, 0x35, 0x66, + 0xB5, 0x5A, 0x27, 0x69, 0xCA, 0x39, 0x77, 0xCE, 0xD5, 0x75, 0xA3, 0x94, + 0xA2, 0x84, 0x68, 0xEB, 0xBC, 0x0F, 0x22, 0xE1, 0x21, 0x04, 0xA5, 0x14, + 0xE3, 0x0C, 0x21, 0x34, 0xAA, 0x8A, 0xD5, 0x62, 0x3D, 0x9B, 0xCD, 0x63, + 0xA1, 0x55, 0xDF, 0x4B, 0xEF, 0xC3, 0x93, 0x47, 0x27, 0x94, 0xD0, 0xA6, + 0x6D, 0x93, 0x44, 0x3C, 0x7E, 0x70, 0xD8, 0x75, 0xFD, 0xCB, 0x37, 0xE7, + 0x52, 0x2A, 0xA5, 0x94, 0x0F, 0xE1, 0x12, 0xC3, 0xEB, 0x77, 0x97, 0x0F, + 0x4F, 0x0E, 0xB6, 0xBC, 0x3E, 0x3B, 0x14, 0xAF, 0xBB, 0xD2, 0x0B, 0x9B, + 0x33, 0x5B, 0x2D, 0x23, 0x0C, 0x14, 0x78, 0xDB, 0x6C, 0xFB, 0x8F, 0xC5, + 0x28, 0x3F, 0x2A, 0xA2, 0xB7, 0x24, 0xFC, 0xAE, 0x5D, 0xB9, 0x2B, 0x61, + 0x21, 0x04, 0x42, 0xF0, 0xD5, 0x6C, 0xB5, 0x58, 0xF7, 0xDE, 0xBB, 0x4F, + 0x9F, 0x3C, 0xCA, 0xB3, 0x34, 0x9A, 0x2F, 0x6D, 0x2F, 0x39, 0xE7, 0x52, + 0xF6, 0x4A, 0xFB, 0xA8, 0xFA, 0xC5, 0x72, 0xFD, 0xB6, 0x6D, 0xC5, 0xC9, + 0xC1, 0xD5, 0x7C, 0x15, 0x53, 0xEA, 0xBC, 0x0F, 0xD8, 0xE3, 0x48, 0x25, + 0xCF, 0x28, 0x01, 0x8C, 0xD7, 0x75, 0x9B, 0x25, 0x02, 0x63, 0xDC, 0xF5, + 0x72, 0x55, 0x37, 0xC6, 0x58, 0xC1, 0x39, 0x40, 0x28, 0xF2, 0x6C, 0x3A, + 0xA9, 0xAA, 0xB2, 0x90, 0x52, 0xCE, 0xE6, 0xCB, 0xBF, 0xFE, 0x2F, 0xCF, + 0xAA, 0x3C, 0x39, 0x9C, 0x56, 0x77, 0x68, 0x17, 0x3F, 0x00, 0xA9, 0xBB, + 0xD2, 0x71, 0x6B, 0xE7, 0xDE, 0x8E, 0xC6, 0xEE, 0xFD, 0xEE, 0xA8, 0x70, + 0xE8, 0x77, 0x8D, 0x06, 0x25, 0x68, 0x5B, 0xFC, 0xEC, 0x42, 0x88, 0x08, + 0x10, 0x36, 0x76, 0x93, 0xF3, 0x37, 0xD9, 0x7F, 0xDB, 0x4C, 0xB4, 0x48, + 0x3E, 0xBA, 0xD5, 0xD0, 0xA2, 0xDE, 0x1C, 0x67, 0x86, 0xFC, 0xF7, 0x3F, + 0xFB, 0x4B, 0xB4, 0x63, 0xCC, 0xDF, 0x1C, 0x9B, 0x2F, 0x8C, 0xDF, 0xEA, + 0x43, 0x88, 0x15, 0x48, 0xC6, 0x07, 0x63, 0x1C, 0x42, 0x80, 0x30, 0x12, + 0x8C, 0xE6, 0x09, 0x4B, 0x13, 0x5E, 0x15, 0x69, 0x22, 0x98, 0xB5, 0x8E, + 0x90, 0xD8, 0x99, 0xD5, 0x39, 0x17, 0x22, 0x2B, 0x5E, 0xDB, 0x9B, 0x75, + 0x2B, 0x67, 0xEB, 0xBE, 0x95, 0xD6, 0x07, 0x68, 0xA5, 0xD1, 0x26, 0xF6, + 0xD8, 0x06, 0xB4, 0xA1, 0xF3, 0x8A, 0xBD, 0x46, 0xAD, 0xF3, 0xAD, 0x34, + 0x52, 0x5B, 0x63, 0x9D, 0x32, 0x3E, 0x78, 0x40, 0x08, 0x79, 0x17, 0x18, + 0x25, 0xB1, 0x1B, 0x2E, 0xA7, 0xD4, 0x38, 0xEF, 0xBD, 0xA7, 0x04, 0xA7, + 0x82, 0x55, 0x59, 0x92, 0x67, 0x9C, 0x20, 0x44, 0x30, 0xE2, 0x8C, 0x62, + 0x8C, 0x28, 0x21, 0x9C, 0x33, 0x3A, 0x24, 0xD3, 0xC7, 0x58, 0x3F, 0xD9, + 0x2E, 0xC1, 0x8F, 0x42, 0xD2, 0xAD, 0x75, 0xF6, 0xB1, 0x01, 0xB8, 0x79, + 0xBC, 0xFB, 0x39, 0xDB, 0xB9, 0xD9, 0x51, 0xA4, 0x6F, 0x59, 0x19, 0x81, + 0x32, 0xFA, 0xE5, 0x97, 0xDF, 0xFD, 0xE2, 0xEF, 0x7E, 0xFB, 0xF2, 0xF5, + 0x99, 0x54, 0xD6, 0x58, 0x17, 0x02, 0x68, 0xAD, 0x63, 0x6D, 0x43, 0x64, + 0x41, 0x91, 0x4A, 0x1B, 0x63, 0xAC, 0xB5, 0x1B, 0x68, 0x0B, 0x75, 0xDB, + 0x5A, 0xEB, 0xF6, 0xF6, 0xA6, 0x01, 0xA0, 0xA9, 0x1B, 0xC6, 0x58, 0x92, + 0x0A, 0x00, 0xA8, 0xAA, 0x72, 0xB9, 0x5C, 0x1B, 0x63, 0x4F, 0x4E, 0x0E, + 0x39, 0xE7, 0xD7, 0xF3, 0x85, 0xE0, 0x9C, 0x73, 0x86, 0x10, 0x08, 0xC1, + 0x8D, 0xB1, 0x08, 0x80, 0x50, 0x0A, 0x08, 0xE5, 0x59, 0xEA, 0x9D, 0xBB, + 0x9E, 0xCD, 0xFB, 0x5E, 0x1E, 0x1D, 0xEE, 0x1F, 0xDD, 0xDB, 0xCF, 0xF3, + 0x74, 0x3C, 0x2A, 0x30, 0xC2, 0x69, 0x9A, 0x20, 0x08, 0xF5, 0x7A, 0x2D, + 0xFB, 0xF6, 0xE9, 0xFD, 0xBD, 0xA6, 0xED, 0xE7, 0xB5, 0x41, 0x08, 0x4B, + 0xA9, 0x62, 0x54, 0xC4, 0x6A, 0x53, 0xA6, 0xE4, 0x6F, 0xFF, 0xCB, 0xB7, + 0x9D, 0x34, 0x8C, 0xD1, 0x34, 0x49, 0x10, 0xC6, 0x84, 0x52, 0xCE, 0x18, + 0x65, 0x0C, 0x00, 0x08, 0x46, 0x4A, 0xE9, 0xB7, 0xA7, 0x17, 0xD7, 0xB3, + 0x65, 0x2F, 0x65, 0x9A, 0x26, 0x65, 0x9E, 0xE7, 0x59, 0x36, 0x9B, 0x2F, + 0x8D, 0x31, 0xB1, 0x89, 0xDA, 0x62, 0xB1, 0x6E, 0xDB, 0xCE, 0x39, 0xDB, + 0x36, 0xDD, 0xE5, 0xF5, 0x62, 0xDD, 0xCA, 0xA2, 0x48, 0xD3, 0x24, 0x61, + 0x94, 0x54, 0x65, 0x21, 0x38, 0x5B, 0xD7, 0xAD, 0x75, 0x2E, 0xCB, 0xB2, + 0xA6, 0xED, 0xFA, 0xAE, 0xAF, 0x46, 0x55, 0x1C, 0x62, 0x6D, 0x8C, 0xF7, + 0x9E, 0x12, 0xC2, 0x38, 0xB3, 0xD6, 0xC8, 0x5E, 0x85, 0x21, 0xE8, 0x1C, + 0x9C, 0xF3, 0x75, 0xD3, 0x52, 0x82, 0x9D, 0xF5, 0x22, 0x11, 0x4A, 0x1B, + 0xAD, 0x75, 0xAF, 0x14, 0xE3, 0x6C, 0x5C, 0x95, 0x89, 0x10, 0x75, 0xDD, + 0x26, 0x9C, 0x72, 0x46, 0x97, 0xAB, 0xA6, 0xED, 0xFA, 0x32, 0xCF, 0x9C, + 0x73, 0xDA, 0xBA, 0x51, 0x99, 0xEF, 0x4F, 0x2B, 0xEB, 0xFC, 0xC6, 0x9D, + 0x8D, 0x60, 0x83, 0x5F, 0xBB, 0x02, 0xBA, 0x9D, 0xFF, 0x4D, 0x60, 0x6D, + 0x57, 0x9F, 0xFA, 0xC8, 0xDA, 0xB9, 0xF9, 0xA8, 0x9D, 0x15, 0x72, 0x6B, + 0x09, 0x6D, 0x7D, 0xD2, 0xBB, 0x3E, 0xA0, 0xDD, 0x25, 0x46, 0x08, 0x11, + 0x8C, 0xBE, 0x3F, 0x7B, 0x4F, 0x93, 0xF4, 0x93, 0xC7, 0xF7, 0xE7, 0x8B, + 0xF5, 0xF3, 0x57, 0x67, 0x00, 0x20, 0xB5, 0xE9, 0xA5, 0x52, 0x4A, 0x03, + 0xA0, 0xAB, 0xEB, 0x05, 0x8A, 0x61, 0x0A, 0x88, 0x89, 0x9E, 0xF8, 0x57, + 0xBF, 0xFD, 0x9E, 0x52, 0xFA, 0xC5, 0x67, 0x0F, 0x31, 0xA6, 0xDA, 0x98, + 0x34, 0x4D, 0xB4, 0x36, 0x9C, 0xD3, 0xE9, 0x74, 0x2C, 0x95, 0x0E, 0x01, + 0xA4, 0x92, 0xC9, 0xC6, 0x97, 0x7F, 0xB8, 0xBF, 0xD7, 0x76, 0x12, 0x01, + 0x34, 0x6D, 0x4F, 0x08, 0x19, 0x55, 0x45, 0x96, 0xA5, 0x55, 0x99, 0x21, + 0x84, 0xE6, 0xAB, 0xFA, 0x8B, 0x27, 0xC7, 0x1B, 0x52, 0xFB, 0x81, 0x10, + 0x0F, 0x3E, 0xC4, 0xDC, 0x5B, 0x72, 0x71, 0x57, 0x10, 0xB6, 0x2F, 0xC7, + 0x18, 0xCB, 0x60, 0x78, 0x0E, 0xEF, 0x8A, 0xB7, 0x8F, 0x10, 0x8A, 0x09, + 0x98, 0x08, 0x00, 0x61, 0x82, 0xD1, 0x86, 0x29, 0x2F, 0x86, 0x3D, 0x10, + 0x42, 0x3E, 0x00, 0xD9, 0xF9, 0x8A, 0x98, 0x1A, 0x11, 0x86, 0xEE, 0x9C, + 0x1B, 0x01, 0x43, 0x00, 0x80, 0x36, 0x59, 0xC9, 0xBB, 0x62, 0x8B, 0x00, + 0x62, 0x5F, 0xCB, 0xC1, 0x02, 0x82, 0xAD, 0xCB, 0x73, 0x7B, 0x72, 0xFB, + 0xBB, 0xE3, 0x49, 0xEB, 0x01, 0xA1, 0x90, 0x8A, 0x48, 0x4E, 0xED, 0x18, + 0x25, 0xE3, 0x32, 0x4D, 0x05, 0x27, 0x04, 0x3B, 0xE7, 0x68, 0x91, 0x42, + 0xE4, 0x75, 0x00, 0x58, 0x0D, 0x59, 0xE8, 0xA1, 0xE9, 0x4D, 0xEC, 0x7A, + 0x88, 0x00, 0x9C, 0xF3, 0xD6, 0x7B, 0xE7, 0x43, 0x64, 0x90, 0xF6, 0x00, + 0x04, 0x0D, 0xE3, 0x37, 0x54, 0xFE, 0x6D, 0x7E, 0x1E, 0x46, 0xE0, 0x42, + 0x40, 0x10, 0x52, 0x4E, 0x26, 0x65, 0x82, 0x10, 0x5A, 0x36, 0x32, 0x84, + 0xC0, 0x29, 0xBD, 0xB7, 0x57, 0x01, 0x04, 0xE7, 0x7D, 0x96, 0x08, 0x4A, + 0xB0, 0xE3, 0x6C, 0x93, 0xDC, 0x1F, 0x21, 0x6C, 0xA8, 0xA4, 0xDF, 0xC6, + 0xD1, 0xD1, 0xC6, 0x12, 0x8C, 0xD0, 0xB3, 0x55, 0xA3, 0xB6, 0x1E, 0x90, + 0xDD, 0x69, 0xBB, 0x65, 0x38, 0xDC, 0x3A, 0xB9, 0x7D, 0xE9, 0x16, 0x72, + 0xED, 0x22, 0x9A, 0x1F, 0xA8, 0x1C, 0x03, 0x42, 0x60, 0xB5, 0x3D, 0x3B, + 0xBF, 0xC6, 0x84, 0x84, 0x00, 0xCA, 0x18, 0x84, 0x70, 0xD7, 0xF5, 0xDE, + 0x7B, 0xE3, 0x86, 0x5C, 0x41, 0x42, 0x29, 0x13, 0x3C, 0x36, 0x2E, 0xAA, + 0xD7, 0x4D, 0x59, 0x15, 0xCE, 0x7B, 0x6B, 0x6D, 0xDF, 0xEB, 0x75, 0xD3, + 0x71, 0x46, 0x19, 0x67, 0x5D, 0xDF, 0x63, 0x8C, 0x38, 0xE7, 0x8B, 0xC5, + 0x32, 0x49, 0x04, 0xE7, 0x3C, 0xCF, 0xB2, 0xB6, 0xEB, 0x47, 0x65, 0x69, + 0xAC, 0xD3, 0x5A, 0x53, 0x82, 0x39, 0xE3, 0xD3, 0xE9, 0xC4, 0x3B, 0xB7, + 0x5C, 0xD5, 0x4A, 0xE9, 0xF9, 0x7C, 0xC5, 0x39, 0xE5, 0x8C, 0xFD, 0xD1, + 0x1F, 0xFE, 0xB8, 0x1A, 0x15, 0x8C, 0xB1, 0xAA, 0x48, 0x29, 0x25, 0xEF, + 0x4E, 0xCF, 0xBB, 0xAE, 0x37, 0x5A, 0x1F, 0x1F, 0xED, 0x09, 0xC6, 0x01, + 0x82, 0x0F, 0xE0, 0x9C, 0x6B, 0x9A, 0xA6, 0x2C, 0x4B, 0xE7, 0xFC, 0x6A, + 0xDD, 0xFE, 0xF4, 0xF3, 0xFB, 0xD7, 0xD7, 0x8B, 0xAE, 0x37, 0x7B, 0x7B, + 0x93, 0x24, 0x4D, 0x18, 0x63, 0x1E, 0x82, 0xDD, 0x54, 0xC5, 0x53, 0x82, + 0xB5, 0xB1, 0x67, 0x17, 0xB3, 0xA6, 0xE9, 0x0F, 0x0F, 0xC6, 0xD3, 0xC9, + 0x28, 0xF8, 0xB0, 0xAE, 0x9B, 0xEB, 0xF9, 0xD2, 0x7B, 0x57, 0xAF, 0xEB, + 0x35, 0x67, 0x59, 0x96, 0xF6, 0x52, 0x11, 0x8C, 0xD2, 0x84, 0x33, 0x46, + 0xD2, 0x44, 0x7C, 0xF6, 0xE4, 0xA4, 0x28, 0x72, 0x4A, 0x99, 0x32, 0x7A, + 0x5C, 0x95, 0x10, 0xFC, 0xB3, 0xE7, 0xAF, 0xFA, 0x5E, 0x1B, 0xAD, 0xAD, + 0x35, 0x55, 0x55, 0xAE, 0x56, 0x35, 0xE7, 0x8C, 0x03, 0xC4, 0xD2, 0x6E, + 0x91, 0x20, 0xAD, 0x14, 0xA5, 0xD4, 0x18, 0x13, 0x4B, 0xDC, 0x31, 0xC6, + 0xDE, 0xB9, 0xE0, 0xBD, 0xD6, 0x06, 0xE3, 0x7E, 0x3E, 0x5B, 0xEE, 0x1F, + 0x4C, 0xD3, 0x3C, 0x6B, 0x9A, 0x56, 0x6B, 0xBB, 0x26, 0xED, 0x83, 0x7B, + 0x07, 0xF7, 0x0E, 0xF7, 0xCF, 0xCE, 0x2F, 0x0E, 0xF6, 0x46, 0x82, 0xD3, + 0xFF, 0xED, 0xFF, 0xFC, 0x45, 0x96, 0x25, 0x45, 0x9E, 0x52, 0x4A, 0xBF, + 0x7F, 0x79, 0xF6, 0xF4, 0xF1, 0x31, 0xC6, 0x43, 0xD8, 0xEA, 0x96, 0xBA, + 0xB1, 0xB3, 0xFD, 0x0C, 0xFF, 0x6F, 0x9D, 0x44, 0x9B, 0x93, 0xBF, 0xCF, + 0xAF, 0xBF, 0x9D, 0xFA, 0xBB, 0x92, 0xBF, 0xBB, 0x8A, 0x3E, 0xDC, 0x17, + 0x21, 0x04, 0x08, 0x01, 0x28, 0x25, 0x01, 0xE0, 0xAB, 0xEF, 0x5E, 0x4C, + 0x0A, 0xFE, 0xDD, 0xE9, 0xF2, 0xFD, 0x8B, 0x53, 0x67, 0x5D, 0x9E, 0x25, + 0x01, 0xC0, 0x79, 0xDF, 0xB4, 0xBD, 0xE0, 0x2C, 0xCA, 0x7F, 0xEC, 0x44, + 0xB7, 0x5A, 0x37, 0x5D, 0xAF, 0x8A, 0x3C, 0x2D, 0xF2, 0x8C, 0x60, 0xF2, + 0xED, 0xB3, 0x37, 0x07, 0x7B, 0x93, 0x3C, 0x4B, 0xCE, 0xAF, 0xE6, 0xCB, + 0x55, 0xAD, 0xB4, 0x39, 0xBE, 0x77, 0x50, 0xB7, 0x1D, 0x63, 0x90, 0x26, + 0x55, 0x5D, 0xD7, 0x00, 0x28, 0x4B, 0x53, 0x8C, 0xA0, 0x97, 0x12, 0x21, + 0xE8, 0x7A, 0x99, 0x24, 0xC9, 0x7A, 0xDD, 0x74, 0x52, 0xE5, 0x59, 0x72, + 0x74, 0x30, 0x2D, 0xF2, 0xC4, 0xFA, 0x20, 0x04, 0x57, 0x5A, 0xA3, 0x8D, + 0x23, 0xE9, 0xF7, 0x40, 0xF6, 0xEF, 0xBC, 0x7D, 0x84, 0xC8, 0x0E, 0xF7, + 0x51, 0x74, 0x79, 0x7B, 0x80, 0xD8, 0xCD, 0x0E, 0xA1, 0x6D, 0x1E, 0x52, + 0xCC, 0x36, 0x0D, 0x91, 0x02, 0x74, 0x83, 0xF5, 0x28, 0x04, 0x44, 0x36, + 0x64, 0x30, 0x36, 0xDA, 0x4C, 0x61, 0x20, 0x6A, 0xC3, 0x18, 0xBC, 0x1F, + 0x8C, 0x43, 0xB4, 0x09, 0x3C, 0xEE, 0xFE, 0x9E, 0xAD, 0x43, 0x93, 0xFC, + 0x77, 0x3F, 0xFB, 0x4B, 0xD8, 0x69, 0x93, 0x31, 0xBC, 0xBC, 0xBD, 0x9B, + 0xCD, 0xC9, 0xED, 0x9B, 0x09, 0x46, 0xD3, 0x2A, 0x49, 0x05, 0x65, 0x94, + 0xE4, 0x29, 0x67, 0x84, 0x84, 0x10, 0x22, 0xA5, 0xA8, 0xB5, 0x56, 0x5B, + 0xA7, 0xB4, 0xA9, 0x3B, 0xD5, 0xF4, 0xAA, 0x91, 0xA6, 0x93, 0xC6, 0xB8, + 0x81, 0xF6, 0x7B, 0x48, 0x81, 0x40, 0x10, 0x5B, 0x03, 0xC4, 0xE9, 0xF7, + 0x1B, 0x12, 0x93, 0xDD, 0xD1, 0x43, 0x68, 0x68, 0x9E, 0xC6, 0x19, 0xC9, + 0x05, 0x25, 0x78, 0x20, 0xC0, 0xA1, 0x94, 0x94, 0x19, 0x4F, 0xF8, 0xA6, + 0xE8, 0x87, 0x12, 0xCE, 0xA9, 0x10, 0x4C, 0x08, 0x16, 0x49, 0x1D, 0x76, + 0xB6, 0x87, 0xE1, 0xC1, 0x6E, 0xEC, 0xFC, 0xD6, 0xAE, 0x72, 0x7B, 0x73, + 0xFC, 0xBD, 0xC7, 0x5D, 0x2C, 0x43, 0x1F, 0xEE, 0xB4, 0xBB, 0x97, 0x79, + 0xEF, 0x19, 0x25, 0x49, 0x9A, 0x5C, 0xCF, 0x16, 0xCF, 0x5F, 0x9C, 0x51, + 0x4A, 0x01, 0x01, 0x26, 0x14, 0x42, 0x70, 0xCE, 0x01, 0xC2, 0x8C, 0x32, + 0x4A, 0x29, 0x60, 0xEC, 0x9C, 0xC3, 0x04, 0x77, 0x4D, 0xAF, 0x94, 0x56, + 0x4A, 0x1B, 0x6B, 0xFB, 0x4E, 0xD6, 0x75, 0x17, 0x00, 0xEA, 0xB6, 0xBD, + 0xBA, 0x9C, 0xA5, 0x89, 0x78, 0xF4, 0xF0, 0x24, 0x4B, 0xD3, 0x5E, 0xAA, + 0x34, 0x4D, 0x26, 0x93, 0x71, 0x55, 0x95, 0x4A, 0xE9, 0xE9, 0xA4, 0xF2, + 0xC1, 0x5F, 0x5C, 0x5D, 0x37, 0x6D, 0xDF, 0x77, 0x52, 0x5B, 0xCB, 0x18, + 0xCB, 0xB2, 0x2C, 0xCB, 0x32, 0x84, 0x50, 0xDB, 0x76, 0x56, 0x9B, 0xFD, + 0xFD, 0xE9, 0x78, 0x32, 0xB2, 0xCE, 0xED, 0x4F, 0xAB, 0x44, 0x70, 0x6B, + 0xEC, 0x6A, 0xB5, 0xB6, 0xC6, 0xEC, 0x4D, 0x27, 0x45, 0x59, 0x74, 0x9D, + 0xC4, 0x18, 0x5B, 0x1F, 0x2E, 0xAE, 0x57, 0x65, 0x99, 0x73, 0xCE, 0x11, + 0x42, 0x0F, 0x8E, 0x27, 0xA3, 0x22, 0x99, 0x37, 0x16, 0x61, 0x92, 0x24, + 0x49, 0x59, 0xE6, 0xEB, 0xA6, 0x75, 0x3E, 0x10, 0x42, 0x9C, 0xF3, 0x01, + 0xC2, 0x72, 0x55, 0xBF, 0x7C, 0xFD, 0xFE, 0xE5, 0xAB, 0x53, 0x6D, 0x8C, + 0x75, 0x3E, 0x4D, 0x04, 0x67, 0xDC, 0x79, 0xAF, 0x8D, 0x51, 0x4A, 0x03, + 0x40, 0x27, 0x55, 0xDF, 0x4B, 0x8C, 0x31, 0xA3, 0x94, 0x12, 0xDC, 0xB6, + 0x5D, 0xDD, 0x4A, 0x8C, 0xD1, 0xCB, 0x57, 0x6F, 0x38, 0xA5, 0x59, 0x96, + 0xCD, 0x17, 0xAB, 0x67, 0xCF, 0x5E, 0xCD, 0x66, 0x0B, 0xC6, 0x98, 0x94, + 0x32, 0xCB, 0x33, 0x42, 0x68, 0xD3, 0x76, 0x00, 0x9E, 0x52, 0x62, 0xAC, + 0x0B, 0x10, 0x62, 0x37, 0xB3, 0xC8, 0xE8, 0xCA, 0x39, 0xF7, 0xCE, 0x13, + 0x4A, 0x9D, 0x77, 0x7D, 0x27, 0xAD, 0x73, 0x04, 0x63, 0xA9, 0x0C, 0x21, + 0xA4, 0x2A, 0x0B, 0x4A, 0x49, 0xD3, 0x76, 0x18, 0x63, 0xE7, 0x7D, 0x91, + 0xA5, 0xE3, 0x51, 0x39, 0x19, 0x97, 0x82, 0xF3, 0xAA, 0x2C, 0x9C, 0x47, + 0x00, 0xB0, 0x37, 0xAE, 0x10, 0xC1, 0x08, 0xC1, 0xD1, 0xFE, 0x18, 0x63, + 0xE4, 0xBD, 0xDF, 0xA6, 0xD2, 0xEF, 0xCC, 0x2E, 0x0C, 0x62, 0xBC, 0xB3, + 0xE8, 0x77, 0x96, 0x04, 0xDA, 0xC1, 0xB5, 0x1B, 0xA5, 0xFB, 0xD6, 0xA4, + 0xDF, 0x5A, 0x1B, 0xBB, 0x6B, 0x6F, 0x5B, 0x70, 0x82, 0x36, 0x26, 0x2E, + 0x21, 0x38, 0x11, 0x0C, 0x63, 0xBC, 0x98, 0xAF, 0xBE, 0x7B, 0xF1, 0xEE, + 0xE9, 0xC3, 0xA3, 0x57, 0x67, 0xCB, 0xA6, 0x55, 0x52, 0x69, 0xC6, 0xD9, + 0xC1, 0x74, 0x4C, 0x08, 0xC9, 0xB3, 0x84, 0x51, 0x8A, 0x10, 0xEA, 0xA5, + 0x92, 0x52, 0xC5, 0xB5, 0x96, 0xE7, 0x59, 0x8C, 0xB4, 0x24, 0x82, 0x13, + 0x42, 0x7A, 0xA9, 0xF3, 0x3C, 0x7B, 0xFC, 0xE0, 0xF0, 0xB3, 0xA7, 0x0F, + 0x8F, 0x8F, 0xF6, 0x9C, 0x0F, 0xFB, 0xD3, 0x71, 0x22, 0x44, 0xDB, 0x76, + 0x88, 0x60, 0xE7, 0xFC, 0x62, 0xB9, 0x3A, 0xD8, 0x9F, 0xD6, 0x4D, 0xDB, + 0xB4, 0x5D, 0xAC, 0x4F, 0x6A, 0xDA, 0xAE, 0x97, 0xF2, 0xE2, 0x72, 0x16, + 0x42, 0x98, 0x8C, 0x4B, 0x84, 0x30, 0x04, 0x5F, 0x64, 0xA9, 0xBB, 0xC9, + 0x84, 0x08, 0xBB, 0x72, 0x84, 0x76, 0x9C, 0x86, 0x77, 0xA5, 0x06, 0xA1, + 0x4D, 0x3A, 0xEF, 0x4E, 0xB5, 0x0C, 0x0C, 0x24, 0x57, 0x78, 0x3B, 0x90, + 0x68, 0xC8, 0x2A, 0x47, 0x74, 0xD3, 0xA2, 0xF8, 0x96, 0x60, 0x62, 0x3C, + 0xA4, 0x04, 0x3B, 0xEF, 0x11, 0x42, 0xDE, 0x07, 0x17, 0x1D, 0x5E, 0x37, + 0xE1, 0xDD, 0x6D, 0xF7, 0x89, 0x2D, 0x1B, 0xE5, 0x0D, 0x6C, 0x84, 0x10, + 0x06, 0xF6, 0x8B, 0x6D, 0x70, 0x74, 0x7B, 0x0F, 0x1B, 0xA3, 0x14, 0x60, + 0xC3, 0xD4, 0x1C, 0x6D, 0xD7, 0x10, 0x42, 0xEC, 0xAA, 0x8B, 0x00, 0xF9, + 0x5E, 0x77, 0x52, 0x63, 0x8C, 0x7C, 0x08, 0xC1, 0x83, 0xB1, 0x4E, 0x1B, + 0x67, 0x9D, 0xB7, 0x3E, 0x68, 0xEB, 0xAD, 0xFB, 0xA0, 0xCC, 0x09, 0x45, + 0xC6, 0x41, 0x8A, 0xAD, 0xF3, 0xC6, 0x3A, 0x40, 0x40, 0x29, 0xF1, 0x01, + 0xC2, 0xD0, 0x47, 0xD2, 0x6F, 0x94, 0xEF, 0x9B, 0xEB, 0xAD, 0xF3, 0x75, + 0xEF, 0xB1, 0x34, 0x94, 0x62, 0x8C, 0xC0, 0x5A, 0x47, 0x30, 0x76, 0x3E, + 0x60, 0x04, 0x42, 0xB0, 0x44, 0xB0, 0x48, 0x45, 0xB0, 0x63, 0x81, 0xC3, + 0xD6, 0x26, 0xDF, 0x1D, 0xFD, 0xDD, 0x75, 0x19, 0xBF, 0xE3, 0xA3, 0x9A, + 0xD7, 0x47, 0x8F, 0xBB, 0x46, 0xC5, 0x76, 0x70, 0x77, 0x3F, 0x7C, 0xBB, + 0xC3, 0x1B, 0x63, 0x42, 0x80, 0xBF, 0xFF, 0xF5, 0xB7, 0x9C, 0xF1, 0x77, + 0xA7, 0x97, 0x52, 0x69, 0x00, 0xC0, 0x88, 0x60, 0x0A, 0x52, 0x2A, 0xCA, + 0xA8, 0x07, 0x30, 0xDA, 0x79, 0xEF, 0xB5, 0x52, 0xB1, 0xDD, 0x45, 0x96, + 0xA5, 0x8B, 0xD5, 0xDA, 0x58, 0xA7, 0x74, 0x6B, 0x9D, 0x0F, 0x1E, 0x9A, + 0x5E, 0x8E, 0x46, 0xC5, 0xC1, 0xE3, 0xE9, 0x64, 0x5C, 0x95, 0x65, 0x91, + 0xA6, 0xA2, 0x28, 0xB2, 0xD9, 0x7C, 0xB5, 0x5E, 0x37, 0x94, 0xD1, 0xAE, + 0xEB, 0xCF, 0x2F, 0xAE, 0xAA, 0xB2, 0x38, 0xD8, 0x9B, 0xCE, 0xE6, 0x4B, + 0xCE, 0xE8, 0x0F, 0x3E, 0x7F, 0x42, 0x19, 0xF7, 0xDE, 0x1B, 0x63, 0xF6, + 0xF7, 0xC7, 0x5A, 0xEB, 0xB2, 0xC8, 0x30, 0xC6, 0x4D, 0x2B, 0x29, 0xC1, + 0xBF, 0xFD, 0xEA, 0x7B, 0xC6, 0xD9, 0x78, 0x5C, 0x71, 0x21, 0x44, 0x22, + 0xD2, 0x2C, 0xC5, 0x08, 0x23, 0x04, 0xB3, 0x95, 0x44, 0x94, 0x5A, 0x1F, + 0x3C, 0x20, 0xED, 0xFC, 0xB4, 0x4A, 0x19, 0xF2, 0x8B, 0x75, 0xAF, 0xB4, + 0x49, 0xB3, 0x54, 0x70, 0xAE, 0x94, 0x16, 0x82, 0x33, 0xC6, 0xBC, 0x0F, + 0x94, 0x91, 0x3C, 0x49, 0xBE, 0xFC, 0xF2, 0xEB, 0x5F, 0x7F, 0xF5, 0xBC, + 0x6F, 0xFB, 0xFD, 0xFD, 0xC9, 0x0F, 0xBF, 0xF8, 0x04, 0x21, 0xD4, 0x2B, + 0x95, 0xA6, 0x49, 0x91, 0x67, 0x21, 0x04, 0x46, 0xC9, 0x72, 0x5D, 0x4B, + 0xA5, 0x39, 0xA3, 0x3C, 0xB6, 0xFE, 0xF3, 0xE0, 0x42, 0xB0, 0xCE, 0xEF, + 0xEF, 0xEF, 0x37, 0x5D, 0xDF, 0x69, 0xF3, 0xFA, 0xF5, 0xBB, 0x7A, 0x55, + 0xC7, 0x5C, 0x36, 0x2E, 0xB8, 0x54, 0x8A, 0x51, 0x57, 0x16, 0x59, 0x88, + 0x06, 0x4E, 0x08, 0x18, 0xA1, 0xA6, 0xEB, 0x38, 0xA5, 0x20, 0x06, 0xFA, + 0x04, 0xEB, 0x3D, 0x58, 0xDB, 0xB6, 0xB2, 0xE9, 0x55, 0xE4, 0xBC, 0xF5, + 0x60, 0x67, 0xF3, 0x65, 0x9A, 0x26, 0x79, 0x9E, 0x25, 0x42, 0x2C, 0x17, + 0x6B, 0xCE, 0xE8, 0xB2, 0x6E, 0xF2, 0x2C, 0x25, 0x04, 0x55, 0x65, 0xFE, + 0xCF, 0xFF, 0xE4, 0xA7, 0xEB, 0xA6, 0xFF, 0xD5, 0x6F, 0x9F, 0x29, 0x6D, + 0x70, 0x40, 0x67, 0x97, 0x8B, 0x75, 0xD3, 0x4D, 0x46, 0xC5, 0xE3, 0x07, + 0x87, 0xDA, 0x58, 0xB4, 0x33, 0x71, 0xB0, 0x71, 0x10, 0x47, 0x77, 0xD8, + 0xDD, 0x10, 0xE5, 0x5D, 0x6D, 0xEB, 0xF7, 0xA0, 0x18, 0xEC, 0xEC, 0xA3, + 0x9B, 0xEB, 0x3F, 0xB8, 0x38, 0x40, 0xA0, 0x84, 0x28, 0xA5, 0x7E, 0xFD, + 0xF5, 0xCB, 0xCB, 0xD9, 0xBA, 0x69, 0x5A, 0x46, 0xC8, 0x77, 0xCF, 0x4E, + 0x4F, 0x2F, 0xAE, 0xB5, 0x76, 0xDA, 0x58, 0xA9, 0xF4, 0xBA, 0x69, 0x39, + 0x67, 0x14, 0x63, 0xE5, 0x07, 0xBA, 0x17, 0x00, 0x08, 0x01, 0x30, 0x82, + 0x34, 0x15, 0x07, 0xFB, 0x53, 0x00, 0x78, 0x77, 0x7A, 0x5E, 0x14, 0x79, + 0xEC, 0x09, 0x3D, 0xAA, 0xB2, 0xD3, 0xF7, 0x57, 0x9F, 0x3E, 0xBE, 0x5F, + 0x15, 0xBA, 0x93, 0x3A, 0x00, 0x58, 0x6F, 0x31, 0xC2, 0x57, 0xD7, 0xF3, + 0x75, 0x6D, 0xD7, 0x75, 0x2B, 0x38, 0x9F, 0x8E, 0x47, 0x5C, 0xF0, 0x37, + 0x6F, 0xCF, 0x9C, 0xF7, 0xA3, 0xAA, 0x3C, 0xDC, 0x9B, 0xFA, 0xE0, 0xDF, + 0x9F, 0xCF, 0x16, 0xCB, 0x3A, 0x04, 0xFF, 0xDF, 0xFC, 0xD3, 0x9F, 0x1E, + 0xEC, 0x8F, 0x42, 0x08, 0xC6, 0x58, 0x8C, 0xB0, 0x75, 0xEE, 0xAE, 0xD4, + 0x84, 0x0F, 0xC3, 0x94, 0x7E, 0x6B, 0xED, 0x01, 0xDC, 0x80, 0x06, 0x00, + 0x00, 0xC4, 0xE6, 0xE1, 0x04, 0xC7, 0x6B, 0x6E, 0x64, 0x73, 0x9B, 0x34, + 0xBA, 0x75, 0x72, 0xDD, 0x7C, 0x26, 0x42, 0x01, 0xBC, 0xF7, 0xB0, 0x2D, + 0x1B, 0x88, 0xAC, 0xF0, 0x68, 0x53, 0x33, 0xB3, 0xFB, 0x03, 0x36, 0xAD, + 0x59, 0x87, 0xED, 0x67, 0xD8, 0x1B, 0xFE, 0x87, 0x7F, 0xF3, 0xF3, 0x68, + 0xAA, 0x6E, 0x10, 0x6D, 0xD8, 0x37, 0x36, 0x5D, 0x3E, 0xA2, 0x37, 0x0C, + 0x36, 0x70, 0x18, 0x10, 0x02, 0xE7, 0x83, 0x52, 0x4E, 0x19, 0xA3, 0xAD, + 0xD3, 0xD6, 0x77, 0x52, 0x6B, 0xE3, 0x7B, 0x6D, 0xEB, 0x5E, 0x77, 0xCA, + 0x6A, 0x1B, 0x8C, 0xF5, 0x6E, 0x33, 0xC1, 0x18, 0x23, 0xC1, 0x08, 0x25, + 0x84, 0x51, 0xCC, 0x08, 0x8A, 0x2D, 0xC8, 0x10, 0xC2, 0x82, 0x91, 0x84, + 0x92, 0x8C, 0x53, 0x41, 0x49, 0x9A, 0x30, 0x46, 0x49, 0xCC, 0x64, 0xDF, + 0x2D, 0x58, 0x65, 0x04, 0x73, 0x8A, 0x83, 0x0F, 0x82, 0x91, 0x22, 0xE1, + 0x55, 0x9E, 0x14, 0x19, 0xDF, 0x50, 0x4D, 0x0C, 0x99, 0xAB, 0x30, 0x14, + 0x60, 0x92, 0x5B, 0x18, 0x7F, 0xCB, 0x9F, 0x75, 0x33, 0x0A, 0x1F, 0xEA, + 0xFC, 0xBB, 0xAF, 0xEE, 0x1E, 0x77, 0x4F, 0xDE, 0xFA, 0x84, 0xBB, 0x2F, + 0x45, 0xE8, 0xA4, 0x84, 0xF4, 0x52, 0xFD, 0xD5, 0x5F, 0xFF, 0xEA, 0xE5, + 0xAB, 0xF7, 0x3E, 0x00, 0x13, 0x22, 0x04, 0xE8, 0xA5, 0x0A, 0x01, 0x28, + 0xA3, 0x3E, 0x84, 0x34, 0x49, 0x9C, 0x77, 0x4A, 0x69, 0x42, 0x69, 0x96, + 0x67, 0x42, 0x24, 0x94, 0xD0, 0xA6, 0x69, 0xB5, 0x31, 0x08, 0x21, 0xEB, + 0x3C, 0x22, 0xF8, 0xF0, 0x70, 0xFF, 0xC1, 0xC9, 0xBD, 0xE9, 0x64, 0x24, + 0x7B, 0xA9, 0xB4, 0x06, 0xC0, 0x84, 0x90, 0x22, 0xCF, 0x16, 0xAB, 0x75, + 0x0C, 0x08, 0x08, 0xCE, 0x92, 0x44, 0xA4, 0x69, 0x7A, 0x70, 0x30, 0x3D, + 0x39, 0x39, 0x4C, 0xD3, 0x24, 0x9E, 0x11, 0x9C, 0x67, 0x69, 0x72, 0x78, + 0x30, 0x5D, 0x2E, 0x56, 0x9D, 0x54, 0x00, 0xC1, 0x18, 0xBB, 0xBF, 0x3F, + 0x1D, 0x8F, 0x2A, 0xAD, 0x0D, 0x00, 0x20, 0x84, 0xB3, 0x44, 0xBC, 0x7A, + 0xF3, 0x96, 0x32, 0xE1, 0x03, 0x08, 0x21, 0xAA, 0xF1, 0x48, 0x08, 0xB1, + 0x58, 0xD6, 0x2F, 0x5F, 0xBD, 0x4B, 0x12, 0x41, 0x28, 0x3F, 0xBF, 0x5A, + 0x46, 0x1A, 0xD2, 0x3C, 0xCB, 0x38, 0x67, 0x94, 0xD2, 0x10, 0xBC, 0x73, + 0xAE, 0x69, 0xDA, 0xEF, 0x9F, 0xBF, 0xBE, 0x9A, 0x2D, 0xB2, 0x2C, 0xFD, + 0xEC, 0xD3, 0x27, 0xD6, 0xFA, 0xB6, 0xED, 0x28, 0xA3, 0x21, 0x00, 0xA3, + 0xC4, 0x39, 0x8F, 0x30, 0x9E, 0x2F, 0xD7, 0x9C, 0xB3, 0xAA, 0xCC, 0x0E, + 0x0E, 0x26, 0x17, 0x57, 0x8B, 0xF3, 0xCB, 0xB9, 0x51, 0xA6, 0x2C, 0x8B, + 0xC9, 0xB8, 0x0A, 0x00, 0x9C, 0xF3, 0x7B, 0x47, 0x07, 0x4D, 0xDD, 0xCC, + 0x67, 0x73, 0x63, 0x2C, 0xE7, 0xDC, 0x39, 0x0F, 0x10, 0xAA, 0xAA, 0xEC, + 0xBA, 0x1E, 0x23, 0xA4, 0x8C, 0x61, 0x94, 0x71, 0xC6, 0x03, 0x0A, 0x9C, + 0x71, 0xCE, 0x39, 0x26, 0xD8, 0xF9, 0x80, 0x10, 0x76, 0xDE, 0x6B, 0x65, + 0x42, 0x08, 0x89, 0x60, 0xDA, 0x58, 0x40, 0x48, 0x69, 0xEB, 0x83, 0xCF, + 0xB3, 0x74, 0xB9, 0xAA, 0x9B, 0xA6, 0x4B, 0x84, 0xA8, 0xCA, 0x0C, 0x61, + 0x6C, 0x7D, 0xB0, 0xD6, 0xE5, 0x29, 0x7F, 0x78, 0x72, 0x10, 0x02, 0x9C, + 0x5F, 0xCE, 0xBB, 0x4E, 0x9D, 0x5F, 0x2D, 0xBD, 0xF7, 0x9F, 0x3E, 0x3E, + 0xC6, 0x9B, 0xE6, 0x35, 0x71, 0x4B, 0xBF, 0x35, 0x9B, 0xB7, 0x9E, 0x7E, + 0xD4, 0xAF, 0xFA, 0xD1, 0xF5, 0x70, 0x6B, 0x63, 0xDB, 0x39, 0x89, 0xB6, + 0x2A, 0x60, 0x22, 0x18, 0x67, 0x4C, 0x70, 0xFA, 0x7F, 0xFD, 0xD5, 0x2F, + 0xBF, 0x7B, 0x33, 0xE3, 0x5C, 0xD4, 0x8D, 0xCC, 0xF2, 0xB4, 0x28, 0x32, + 0x65, 0x43, 0x9E, 0xA7, 0x75, 0xD3, 0x2D, 0x16, 0xAB, 0xBA, 0x6E, 0xAF, + 0xAF, 0x97, 0xB3, 0xC5, 0xDA, 0x18, 0x13, 0xF3, 0x7B, 0xBB, 0xAE, 0x8F, + 0x9A, 0x48, 0xD3, 0xB6, 0x98, 0x50, 0x4A, 0x49, 0x9E, 0xA5, 0x4A, 0xE9, + 0xD5, 0xAA, 0xF6, 0xDE, 0xFF, 0xE4, 0x87, 0x4F, 0xD7, 0x75, 0xFB, 0xFE, + 0x62, 0x3E, 0x19, 0x15, 0x9C, 0xD1, 0x2F, 0xBF, 0xFA, 0xDE, 0xFB, 0x60, + 0xAC, 0x09, 0x00, 0x94, 0x50, 0x21, 0x38, 0x21, 0x84, 0x52, 0x12, 0xB7, + 0xA5, 0xC7, 0x0F, 0xEF, 0xFD, 0xE8, 0xF3, 0x27, 0x4F, 0x1F, 0x1F, 0xFF, + 0xE0, 0xE9, 0x23, 0x21, 0xD8, 0xDB, 0xD3, 0x0B, 0x8C, 0xE9, 0x8B, 0x77, + 0x97, 0xB3, 0xC5, 0x3A, 0x11, 0x8C, 0x51, 0xAA, 0xB4, 0x11, 0x82, 0x6D, + 0xE3, 0x58, 0x77, 0x55, 0xB0, 0xED, 0x9D, 0xC6, 0xDA, 0xD0, 0x8D, 0x63, + 0x0A, 0x6D, 0xEF, 0x76, 0x23, 0x0E, 0x68, 0x53, 0x05, 0x84, 0xB6, 0x96, + 0x0B, 0xD9, 0x9E, 0xDC, 0x0E, 0xE3, 0x66, 0xB8, 0xFC, 0xD6, 0x68, 0xDB, + 0x98, 0xF9, 0x61, 0x9B, 0x09, 0x86, 0x80, 0x10, 0x1C, 0xC3, 0x2F, 0x18, + 0x63, 0x1A, 0x89, 0x1B, 0x08, 0xA1, 0x04, 0x93, 0xA8, 0xCB, 0x61, 0x44, + 0xFE, 0xEC, 0xDF, 0xFE, 0x7C, 0xE0, 0xBA, 0xD8, 0xFC, 0x6A, 0xB8, 0x81, + 0xB3, 0xAD, 0x0E, 0x3E, 0x78, 0xAF, 0x86, 0x60, 0x34, 0x02, 0x18, 0xBA, + 0xD7, 0x06, 0xEB, 0xBC, 0xF7, 0xE0, 0x7C, 0x90, 0xC6, 0x86, 0x9D, 0x4A, + 0xCE, 0x0D, 0xA8, 0x44, 0xBD, 0x1E, 0x08, 0x46, 0x45, 0x42, 0x47, 0x45, + 0x82, 0x11, 0x4A, 0x39, 0x2B, 0x52, 0x36, 0x2E, 0x93, 0x2C, 0x61, 0x65, + 0xC6, 0xAB, 0x3C, 0x19, 0xE5, 0xA2, 0xCA, 0x45, 0xCA, 0x29, 0xC1, 0x28, + 0xE5, 0x94, 0x52, 0x8C, 0x11, 0x4A, 0x38, 0x2D, 0x32, 0x9E, 0x30, 0xC2, + 0x28, 0x26, 0x18, 0x15, 0xA9, 0x60, 0x14, 0x53, 0x4A, 0xD2, 0x84, 0x73, + 0x36, 0xC4, 0xCE, 0xA2, 0x46, 0xB6, 0x9B, 0x85, 0x7F, 0x0B, 0x80, 0x76, + 0xB7, 0xD0, 0x0F, 0xC2, 0xEA, 0xFF, 0xB0, 0x95, 0xFA, 0x81, 0x53, 0xF3, + 0x0E, 0x84, 0xED, 0x3A, 0xC5, 0xC2, 0x26, 0x4D, 0xD9, 0x39, 0xF7, 0x1F, + 0xFF, 0xEA, 0xEF, 0xAF, 0xAE, 0x97, 0x1B, 0xE2, 0x2A, 0x9F, 0xA6, 0x22, + 0x11, 0xC2, 0x38, 0x87, 0x31, 0x4A, 0xD2, 0x24, 0x56, 0x51, 0x31, 0x21, + 0x08, 0x21, 0x5D, 0xD7, 0xAD, 0x96, 0xEB, 0xBA, 0xE9, 0x22, 0x9D, 0x86, + 0x71, 0xCE, 0xFB, 0x90, 0x67, 0x39, 0xA5, 0xF4, 0xF4, 0xF4, 0x7C, 0xB9, + 0x58, 0x4A, 0x29, 0xB9, 0x10, 0x75, 0xDB, 0xD5, 0x75, 0x83, 0x20, 0x94, + 0x65, 0x21, 0x8D, 0x49, 0x13, 0xF1, 0xE0, 0xFE, 0xBD, 0xC3, 0x83, 0x29, + 0x65, 0x84, 0x52, 0x4A, 0x29, 0x8D, 0x3D, 0x65, 0xD1, 0x50, 0x5B, 0xEB, + 0x8C, 0x56, 0xEB, 0x55, 0x3D, 0x9E, 0x8C, 0x27, 0x93, 0x51, 0x9A, 0xA6, + 0x6D, 0xDB, 0x2D, 0xAF, 0xAF, 0xAA, 0x51, 0x39, 0x99, 0x8E, 0xB5, 0x92, + 0x5F, 0x7E, 0xF9, 0x55, 0x9A, 0x15, 0xAB, 0xBA, 0x33, 0xD6, 0x63, 0x42, + 0xAE, 0x67, 0x4B, 0xA5, 0xF5, 0x62, 0xBE, 0xAC, 0x46, 0x65, 0x9A, 0x66, + 0xA7, 0x17, 0x73, 0xCA, 0x68, 0xEC, 0xE5, 0x1E, 0x2D, 0x3B, 0x29, 0xD5, + 0xC5, 0xE5, 0xEC, 0xF2, 0x72, 0x21, 0xFB, 0x0E, 0x10, 0xFE, 0xA3, 0x3F, + 0xFC, 0x49, 0x51, 0xE6, 0x17, 0x97, 0xD7, 0x67, 0x67, 0x17, 0x9F, 0x3C, + 0x79, 0xB8, 0x37, 0x1D, 0x71, 0x4A, 0x66, 0xB3, 0xF9, 0xEB, 0x77, 0x67, + 0x75, 0xD3, 0xC6, 0x84, 0x7B, 0x8C, 0xA0, 0x69, 0x3A, 0x00, 0x22, 0x04, + 0x17, 0x82, 0x53, 0x4A, 0x8D, 0xB5, 0x80, 0x50, 0x5C, 0x7F, 0xF3, 0xC5, + 0x72, 0x3E, 0x5B, 0xA2, 0x8D, 0x61, 0x1E, 0x20, 0x3C, 0x7D, 0xFA, 0x88, + 0x31, 0xB6, 0x5A, 0xAD, 0x31, 0xC2, 0x91, 0x6E, 0x87, 0x52, 0x1A, 0xBC, + 0x67, 0x8C, 0x61, 0x84, 0x8D, 0x35, 0x9C, 0x33, 0x08, 0x28, 0xB2, 0xA4, + 0xA4, 0x82, 0x19, 0xEB, 0x63, 0x13, 0x12, 0x82, 0xF1, 0x64, 0x5C, 0x11, + 0x82, 0xE7, 0xCB, 0x75, 0x00, 0x60, 0x94, 0x55, 0x65, 0x1E, 0x69, 0xAC, + 0x8D, 0x75, 0x08, 0xD0, 0xD1, 0xC1, 0x78, 0x32, 0x2A, 0xDF, 0x5F, 0xCC, + 0x4E, 0xCF, 0xAF, 0xAA, 0xAA, 0x08, 0x01, 0x94, 0xD2, 0x08, 0xA1, 0x24, + 0xE1, 0x5B, 0xFF, 0xC9, 0x1D, 0x2C, 0xFB, 0x5D, 0x2B, 0xE2, 0x83, 0xA9, + 0xDF, 0x7D, 0xEF, 0xF6, 0xEF, 0x5D, 0x69, 0x8F, 0x7A, 0x0A, 0x21, 0x84, + 0x31, 0xF2, 0xFA, 0xDD, 0x65, 0xDB, 0xAB, 0x5F, 0xFD, 0xF6, 0xF9, 0xAF, + 0xBE, 0x79, 0xB7, 0x37, 0x19, 0x31, 0x4A, 0xBF, 0xF8, 0xEC, 0xE1, 0xF1, + 0xE1, 0xB4, 0xED, 0xFA, 0x55, 0xDD, 0xAF, 0x9B, 0x1E, 0x21, 0xD4, 0x76, + 0x92, 0x11, 0x1A, 0xE9, 0x43, 0xB4, 0x36, 0xA3, 0xAA, 0x28, 0xF2, 0xAC, + 0xEB, 0xA5, 0x52, 0x86, 0x10, 0xE2, 0x3D, 0x20, 0x08, 0xB1, 0x5B, 0x4A, + 0x5D, 0xB7, 0xB3, 0xC5, 0x0A, 0x00, 0x3D, 0x79, 0x78, 0x4C, 0x30, 0xFE, + 0xF4, 0xC9, 0x49, 0x9A, 0xF0, 0xF9, 0xB2, 0x16, 0x42, 0xAC, 0xD6, 0xCD, + 0x62, 0x59, 0x53, 0x42, 0xE3, 0x9D, 0x86, 0xC1, 0x9D, 0x83, 0x4E, 0x8E, + 0x0F, 0x8E, 0x0F, 0xA7, 0x51, 0x7C, 0x12, 0xC1, 0x28, 0x25, 0x65, 0x59, + 0x4C, 0x46, 0xA5, 0x10, 0xBC, 0x57, 0xE6, 0xEB, 0x67, 0xEF, 0x5E, 0xBD, + 0xB9, 0x78, 0x75, 0x7A, 0xBD, 0x37, 0x29, 0xAB, 0x22, 0x8D, 0xF7, 0xB3, + 0xF1, 0x5C, 0xA3, 0xBB, 0xF7, 0xB8, 0x7D, 0x42, 0x36, 0x29, 0xAA, 0x18, + 0x63, 0xB2, 0xF5, 0xEA, 0x23, 0x84, 0x36, 0x98, 0x85, 0x37, 0x4A, 0x11, + 0xDE, 0x49, 0xFA, 0xDF, 0xCD, 0xD1, 0x8F, 0x1F, 0x17, 0x36, 0x3D, 0xA1, + 0x01, 0x00, 0x93, 0xE1, 0x63, 0x08, 0x41, 0x94, 0x10, 0x46, 0x09, 0xC1, + 0x08, 0x63, 0x4C, 0x28, 0x8A, 0x84, 0xD1, 0x18, 0x63, 0x8A, 0x11, 0xC5, + 0x38, 0xA6, 0x3B, 0x50, 0x08, 0x00, 0x78, 0xD0, 0x12, 0x69, 0xAC, 0x08, + 0x05, 0xB4, 0xA5, 0xC0, 0xBD, 0x99, 0x8C, 0x0D, 0xCA, 0x02, 0x6C, 0xBD, + 0x9F, 0xB1, 0xDB, 0xFB, 0xF0, 0x9C, 0x20, 0x1C, 0x10, 0xEC, 0x5E, 0x16, + 0x95, 0xE1, 0x58, 0x4B, 0x8F, 0x11, 0xB2, 0x3E, 0x2C, 0x1B, 0x09, 0x00, + 0x8C, 0x62, 0xE4, 0x07, 0x2F, 0x9D, 0xC6, 0x37, 0xB7, 0xCA, 0x28, 0xCE, + 0x13, 0x86, 0x11, 0x8A, 0x36, 0xA3, 0xB5, 0x4E, 0x1B, 0x8B, 0x11, 0xE6, + 0x9C, 0x72, 0x46, 0x04, 0xA3, 0x9B, 0xCC, 0x11, 0xD8, 0x0C, 0xD4, 0xF0, + 0x21, 0xB7, 0xAA, 0xB1, 0x60, 0x87, 0xA3, 0x02, 0x86, 0x08, 0x37, 0xF9, + 0x28, 0x42, 0xDD, 0x5D, 0x9D, 0xBB, 0xFA, 0xF3, 0xDD, 0x57, 0x3F, 0x7A, + 0x7E, 0xFB, 0xAA, 0x52, 0x9A, 0x52, 0xFC, 0xE6, 0xCD, 0xF9, 0x8B, 0x97, + 0xA7, 0x94, 0x32, 0xCA, 0x18, 0xA5, 0x04, 0x42, 0xB0, 0x46, 0xC7, 0xD8, + 0xAB, 0x0F, 0xC1, 0x6A, 0xDB, 0x1B, 0xEB, 0x43, 0x90, 0x4A, 0x4B, 0x29, + 0x05, 0xE7, 0x8C, 0x73, 0x41, 0x30, 0xC1, 0xC4, 0x87, 0x9E, 0x0A, 0x4E, + 0x08, 0xEB, 0xBB, 0xBE, 0xAE, 0x9B, 0x24, 0x49, 0x26, 0xE3, 0x32, 0x4D, + 0x44, 0x51, 0xE4, 0x57, 0xF3, 0xA5, 0xEA, 0xE5, 0x74, 0x32, 0x9A, 0x8C, + 0x2B, 0xA9, 0x6D, 0x59, 0x16, 0x9C, 0xD2, 0x5E, 0x2A, 0x21, 0x78, 0xF0, + 0xE0, 0xBD, 0xC7, 0x6C, 0xC8, 0xA9, 0xA9, 0xEB, 0x0E, 0x82, 0x9B, 0x4E, + 0xC6, 0x9F, 0x7D, 0xFE, 0x89, 0xF7, 0xE1, 0xFC, 0x6A, 0xAE, 0xFA, 0xEE, + 0x60, 0x5C, 0xB0, 0xC9, 0x31, 0x65, 0xA2, 0x5E, 0xAF, 0xE7, 0x8B, 0x55, + 0x9E, 0x65, 0x47, 0x07, 0x13, 0x69, 0x9C, 0x73, 0xE1, 0xE8, 0x70, 0x4F, + 0x08, 0x1E, 0x13, 0x7E, 0xA4, 0x52, 0x17, 0x57, 0x2B, 0x4C, 0x10, 0x84, + 0x60, 0x8D, 0xC3, 0x80, 0x2D, 0xD8, 0x77, 0x67, 0x17, 0x7D, 0xAF, 0x30, + 0x42, 0x18, 0xA3, 0xD9, 0x62, 0x75, 0x7E, 0x39, 0x37, 0x2E, 0x3C, 0x7D, + 0xF2, 0x60, 0x5C, 0x15, 0xD6, 0xDA, 0xC8, 0x69, 0xE2, 0x9C, 0xB3, 0xCE, + 0x1F, 0xDF, 0x3B, 0xD2, 0xC6, 0x54, 0x65, 0x91, 0x08, 0x4E, 0x30, 0x5A, + 0x2C, 0xD7, 0x3E, 0x04, 0x82, 0xB1, 0x74, 0x3E, 0x11, 0xA8, 0xEB, 0xA5, + 0xB1, 0x7E, 0x54, 0xE5, 0xB3, 0xF9, 0x72, 0x31, 0x5F, 0x32, 0x4A, 0xF3, + 0x2C, 0xF3, 0xC1, 0x87, 0x10, 0x18, 0x63, 0xC6, 0xD8, 0xE9, 0x64, 0xBC, + 0x5C, 0xAE, 0xD6, 0xEB, 0x26, 0x62, 0x3A, 0x42, 0x48, 0x1B, 0x8B, 0x7A, + 0x29, 0x38, 0x23, 0x08, 0xF7, 0xBD, 0xF2, 0x21, 0x60, 0x32, 0x30, 0x62, + 0x12, 0x82, 0x9C, 0x73, 0x5A, 0xEB, 0xE5, 0xCA, 0x4F, 0x27, 0x15, 0x67, + 0x6C, 0x6F, 0x6F, 0x02, 0x3E, 0x5C, 0xCD, 0x96, 0x84, 0x92, 0xB2, 0x48, + 0xDB, 0xA6, 0x2F, 0x8B, 0x5C, 0x59, 0x67, 0x3A, 0x7F, 0xB8, 0x3F, 0xFE, + 0x57, 0xFF, 0xED, 0x9F, 0x7E, 0xF9, 0xCD, 0x8B, 0xAB, 0xEB, 0xD5, 0xF9, + 0xD5, 0x62, 0xBD, 0xEE, 0x04, 0x27, 0xFF, 0xD5, 0x3F, 0xFB, 0x43, 0x8C, + 0x90, 0xBB, 0x93, 0x67, 0xB0, 0xBB, 0x34, 0xEE, 0x7A, 0xC4, 0x76, 0x97, + 0xCD, 0xEF, 0x59, 0x0F, 0xDB, 0x55, 0x14, 0x42, 0xC0, 0x18, 0xA5, 0x82, + 0x2F, 0x16, 0xEB, 0xBF, 0xF9, 0xFB, 0xAF, 0x67, 0x8D, 0x9E, 0x8E, 0x47, + 0x5F, 0x7F, 0xFB, 0x2A, 0x40, 0x70, 0xCE, 0x4D, 0xC6, 0xE5, 0x8B, 0xD7, + 0xEF, 0xEB, 0xA6, 0xBB, 0xB7, 0x3F, 0xFE, 0xEE, 0xC5, 0xDB, 0x34, 0x4D, + 0x47, 0xA3, 0x72, 0x3A, 0x1E, 0x35, 0x5D, 0xEF, 0x9C, 0xE7, 0x9C, 0x4D, + 0x27, 0x23, 0x00, 0xB4, 0x5C, 0xAE, 0xFC, 0xE0, 0x7B, 0x0D, 0x08, 0xA1, + 0xBA, 0xE9, 0xD2, 0x44, 0x18, 0xEB, 0xB3, 0x2C, 0xDD, 0xDF, 0x1B, 0xBF, + 0x7C, 0xFD, 0x7E, 0xB1, 0x6A, 0x9E, 0x3C, 0x38, 0x44, 0x18, 0x25, 0x82, + 0x9F, 0x1C, 0xED, 0x7D, 0xFA, 0xE8, 0xDE, 0x9F, 0xFE, 0xF1, 0x0F, 0xDF, + 0xBD, 0xBF, 0x8E, 0x36, 0x8B, 0xD2, 0x3A, 0x04, 0x78, 0xF9, 0xF6, 0xBC, + 0xCC, 0xD3, 0x83, 0xBD, 0x11, 0xE7, 0xEC, 0xFC, 0x72, 0xE6, 0x7D, 0x58, + 0xAE, 0x5E, 0xE5, 0x69, 0x72, 0x72, 0x7C, 0xC0, 0x28, 0x29, 0x8B, 0xD4, + 0x5A, 0x47, 0x30, 0x7A, 0xF9, 0xFA, 0xEC, 0xD1, 0x83, 0xE3, 0xFF, 0xE7, + 0x17, 0x5F, 0x3D, 0x7D, 0x74, 0xF4, 0x93, 0x1F, 0x3C, 0xD4, 0xDA, 0x64, + 0x69, 0x12, 0xCB, 0x78, 0x00, 0x3E, 0xC2, 0xC3, 0x0C, 0x3B, 0xBE, 0x1A, + 0x34, 0x40, 0x12, 0x10, 0x00, 0xEF, 0x6F, 0x18, 0x90, 0xA2, 0xEC, 0xED, + 0xF4, 0xDA, 0x89, 0xB1, 0x8E, 0x41, 0x4E, 0x23, 0x3C, 0x6E, 0x3F, 0x3C, + 0x0C, 0x1C, 0xA3, 0x88, 0x62, 0x8C, 0x10, 0x84, 0x10, 0xC8, 0xB6, 0xDA, + 0x09, 0x80, 0xD0, 0xAD, 0xBE, 0x32, 0x78, 0xFD, 0x01, 0xA2, 0x52, 0x85, + 0xC8, 0xFF, 0xF8, 0xE7, 0x7F, 0x39, 0x7C, 0x56, 0x18, 0x3C, 0x65, 0x18, + 0x03, 0x46, 0xF1, 0x1F, 0xC6, 0x68, 0x50, 0xA9, 0x10, 0x42, 0x64, 0xAB, + 0x19, 0x02, 0x8A, 0x54, 0xF5, 0x61, 0xB3, 0xE1, 0x6C, 0xBC, 0x0C, 0x5B, + 0x47, 0xD5, 0xE6, 0x19, 0x02, 0x00, 0xA0, 0x08, 0xFB, 0x00, 0x31, 0x03, + 0x56, 0x30, 0x9A, 0x30, 0xCA, 0x39, 0xE1, 0x8C, 0x6A, 0xE3, 0x00, 0x21, + 0x82, 0x71, 0x95, 0x27, 0x69, 0xC2, 0x11, 0x42, 0x82, 0xB3, 0x2C, 0xE1, + 0x59, 0xC2, 0x53, 0xC1, 0x04, 0x67, 0x31, 0x9E, 0x10, 0xCB, 0x86, 0x19, + 0xA3, 0x94, 0x12, 0x4A, 0x09, 0xE7, 0x2C, 0x3E, 0xDE, 0xE1, 0xFF, 0xC2, + 0xDB, 0x92, 0xA3, 0xBB, 0x0E, 0xF8, 0x8F, 0xAE, 0xB3, 0xED, 0x71, 0x77, + 0x56, 0x6E, 0x5D, 0xB0, 0x3D, 0x3E, 0x4A, 0x0D, 0xF4, 0xE1, 0xE2, 0x0E, + 0x9C, 0xD1, 0x57, 0x6F, 0xDE, 0xBF, 0x7B, 0x77, 0x89, 0x10, 0x22, 0x04, + 0x0B, 0xC1, 0xB3, 0x2C, 0x21, 0x18, 0xD5, 0x4D, 0xDB, 0x77, 0x7D, 0xDF, + 0xAB, 0xC5, 0xB2, 0x46, 0x84, 0xF8, 0x10, 0x16, 0xCB, 0x35, 0x42, 0x78, + 0xDD, 0x74, 0x4A, 0x99, 0xD8, 0x4F, 0xBB, 0x57, 0x4A, 0x49, 0xED, 0x9D, + 0xA7, 0x94, 0x72, 0xCE, 0x93, 0x54, 0x64, 0x79, 0xC6, 0x39, 0x93, 0xCA, + 0xB4, 0x6D, 0x57, 0xE4, 0xE9, 0x78, 0x54, 0x16, 0x45, 0xD6, 0x74, 0xFD, + 0xD9, 0xF9, 0x35, 0x02, 0x34, 0x19, 0x57, 0xF1, 0xC7, 0x30, 0x4E, 0x95, + 0x54, 0x00, 0xA0, 0x8D, 0xEE, 0x7B, 0x99, 0x66, 0x69, 0x96, 0x65, 0x5A, + 0xEB, 0xF9, 0x62, 0x55, 0xA6, 0xF4, 0x07, 0x4F, 0x8E, 0x9F, 0x3C, 0x3E, + 0x4E, 0x13, 0x71, 0x39, 0x5B, 0xB9, 0x00, 0x1E, 0xE0, 0x87, 0x5F, 0x7C, + 0x96, 0x17, 0x05, 0x67, 0x3C, 0x4D, 0x45, 0xDB, 0xF6, 0x6D, 0xDB, 0xC7, + 0x6E, 0x20, 0x8C, 0x31, 0xA5, 0x14, 0x42, 0xA8, 0xEF, 0xD5, 0x6C, 0xB1, + 0x94, 0xBD, 0x8A, 0xCC, 0x22, 0x59, 0x9A, 0x4C, 0x26, 0x15, 0x04, 0x47, + 0x08, 0xA9, 0x9B, 0x46, 0x24, 0xFC, 0x70, 0x7F, 0x82, 0x09, 0x2A, 0xF2, + 0x6C, 0x3C, 0xAA, 0x10, 0x40, 0xDB, 0xF5, 0x88, 0x60, 0xCE, 0x18, 0xA5, + 0x94, 0x51, 0xEA, 0xBC, 0xB7, 0xCE, 0x17, 0x45, 0x2E, 0xA5, 0xAC, 0x9B, + 0x2E, 0x4B, 0x85, 0x73, 0x2E, 0x20, 0x5C, 0xD7, 0xCD, 0xCB, 0x97, 0x6F, + 0x7C, 0x08, 0xCB, 0xC5, 0xAA, 0xEF, 0x3A, 0x9E, 0x24, 0x18, 0xA1, 0x34, + 0x4B, 0x17, 0xCB, 0x65, 0x59, 0x96, 0xCB, 0x55, 0xED, 0x9D, 0x1B, 0x32, + 0x13, 0x09, 0xA1, 0x34, 0x5A, 0x94, 0x1B, 0x9E, 0x3C, 0x8C, 0x8C, 0x75, + 0x10, 0xC0, 0x5A, 0x87, 0x09, 0x8E, 0xAE, 0x6E, 0x80, 0xC8, 0x1C, 0xE5, + 0xAD, 0x75, 0x55, 0x91, 0x3D, 0x79, 0x74, 0xA2, 0xB4, 0xAE, 0xEB, 0x0E, + 0x01, 0xF8, 0x10, 0x16, 0xCB, 0x3A, 0x4B, 0x13, 0xA5, 0xCD, 0x6C, 0x51, + 0xBF, 0x3B, 0xBB, 0x7C, 0x74, 0xFF, 0xE8, 0xD3, 0x4F, 0x4E, 0x30, 0xC2, + 0xDE, 0x87, 0x5E, 0xEA, 0x5E, 0x2A, 0x82, 0x71, 0x59, 0x64, 0x3B, 0x74, + 0x34, 0xC3, 0x12, 0xB8, 0x05, 0x61, 0xB7, 0xD6, 0xC6, 0xDD, 0x63, 0x57, + 0xEB, 0xBF, 0xA5, 0xA0, 0x15, 0x79, 0x3A, 0x5F, 0xD4, 0xEF, 0xCE, 0x67, + 0x6F, 0xDE, 0x5E, 0xFC, 0x1F, 0x7F, 0xF5, 0x65, 0x9E, 0xE7, 0x69, 0x2A, + 0x02, 0x40, 0xD7, 0x6B, 0xAD, 0x4D, 0x51, 0x64, 0xDF, 0x3C, 0x7B, 0xED, + 0x5C, 0xE8, 0x95, 0x09, 0x80, 0x08, 0xC1, 0x10, 0x60, 0xBE, 0x5C, 0xC7, + 0x37, 0x22, 0x8C, 0xA4, 0x54, 0x6D, 0xD7, 0xD5, 0x75, 0x6B, 0x8C, 0xDD, + 0xEE, 0xD9, 0xDE, 0x87, 0xCF, 0x9E, 0x3E, 0xFC, 0xC1, 0x67, 0x8F, 0xBE, + 0xFB, 0xFE, 0x4D, 0x55, 0x15, 0x59, 0x9A, 0xE4, 0x59, 0xF2, 0xF8, 0xE1, + 0x11, 0x02, 0xE8, 0xA4, 0x66, 0x94, 0xC4, 0xF4, 0xA3, 0xA3, 0xFD, 0x2A, + 0xCF, 0x12, 0x82, 0x91, 0x0F, 0x70, 0xEF, 0x70, 0x7A, 0x74, 0x30, 0xA1, + 0x14, 0x5F, 0xCF, 0x57, 0xE7, 0x97, 0xF3, 0xF3, 0xAB, 0xF9, 0x62, 0xBE, + 0xBA, 0x9E, 0xAF, 0xB4, 0xB1, 0x07, 0x7B, 0xE3, 0x44, 0xF0, 0x3C, 0x4B, + 0xD6, 0x75, 0x9B, 0x26, 0x22, 0xCB, 0xD2, 0xD3, 0xF7, 0x57, 0x17, 0x57, + 0xF3, 0xD3, 0x8B, 0xF9, 0xDB, 0xF7, 0xB3, 0xD3, 0xF3, 0xF9, 0xD3, 0x47, + 0xF7, 0xA2, 0xDB, 0x86, 0x73, 0xB6, 0xAB, 0x8E, 0x6D, 0xE5, 0x6E, 0x93, + 0x62, 0x82, 0x76, 0xC9, 0x16, 0xB6, 0xC6, 0x63, 0xD4, 0x28, 0xA2, 0x11, + 0x8A, 0x76, 0x7A, 0x3C, 0xDF, 0x52, 0x26, 0x76, 0xDF, 0x48, 0x30, 0x22, + 0x43, 0x72, 0xC6, 0xED, 0x92, 0xE7, 0x6D, 0xB4, 0x64, 0xF3, 0x60, 0x6B, + 0x8A, 0x06, 0xF2, 0x67, 0xFF, 0xEE, 0xE7, 0xE8, 0xC6, 0x56, 0x84, 0xAD, + 0xAC, 0x22, 0x14, 0xFB, 0x9B, 0x0D, 0xFF, 0xC8, 0xF0, 0x74, 0x03, 0xA0, + 0x9B, 0x7E, 0x8A, 0x9B, 0xD8, 0x42, 0x08, 0x80, 0xC2, 0x86, 0xD2, 0x88, + 0x11, 0x1C, 0x0B, 0x8F, 0x62, 0x8E, 0x6B, 0xF0, 0x21, 0xE1, 0x74, 0x7F, + 0x9C, 0x1D, 0xEF, 0x95, 0xD3, 0x51, 0x36, 0xA9, 0xB2, 0x71, 0x99, 0x96, + 0x79, 0x72, 0x30, 0xAD, 0xF6, 0x46, 0xD9, 0xB8, 0xCA, 0xAA, 0x32, 0x4D, + 0x04, 0xE3, 0x94, 0x08, 0xCE, 0x28, 0xC1, 0x3A, 0x26, 0x6E, 0x84, 0x20, + 0x38, 0x4D, 0x12, 0x46, 0x29, 0xDD, 0x80, 0x17, 0x8D, 0x89, 0x2A, 0xDB, + 0x41, 0x8C, 0xC7, 0x4E, 0x78, 0xE8, 0x76, 0xB6, 0xCE, 0x76, 0x39, 0x6E, + 0xD7, 0xD6, 0xEE, 0xB8, 0x6C, 0x2D, 0x47, 0x3F, 0x34, 0x9A, 0x8E, 0xE4, + 0xEE, 0xC3, 0xC3, 0x2D, 0x91, 0xDB, 0xF6, 0xAF, 0xDF, 0xD0, 0xC9, 0xFA, + 0x48, 0xAB, 0x1A, 0x00, 0x00, 0x86, 0x7A, 0x43, 0x6B, 0x31, 0xC6, 0xCF, + 0x5F, 0xBE, 0xFB, 0xC5, 0xDF, 0xFE, 0x06, 0x00, 0x62, 0xB9, 0xB5, 0xB3, + 0x06, 0x01, 0x30, 0xCE, 0x11, 0xC6, 0x52, 0x5B, 0x6D, 0x2C, 0x65, 0x2C, + 0x49, 0x44, 0x6C, 0x3B, 0xD4, 0xF5, 0xAA, 0xD7, 0xCA, 0xFB, 0x80, 0x09, + 0x31, 0xCE, 0xF5, 0x9D, 0x74, 0xCE, 0xA5, 0x59, 0x9A, 0x24, 0x22, 0x78, + 0xBF, 0x5C, 0xAE, 0xDB, 0xA6, 0x47, 0x08, 0xF5, 0x7D, 0xAF, 0x8D, 0x55, + 0xCA, 0x54, 0x65, 0xBE, 0x58, 0x35, 0x79, 0x96, 0x0A, 0xC1, 0x8B, 0x3C, + 0xAB, 0x46, 0x39, 0xC6, 0x08, 0x82, 0x7F, 0xF1, 0xFC, 0xE5, 0xF9, 0xE5, + 0xB5, 0xD4, 0xBA, 0xC8, 0xF3, 0x22, 0xCF, 0x93, 0x84, 0x23, 0x00, 0x8C, + 0xE1, 0xC9, 0x83, 0xBD, 0x83, 0xBD, 0x51, 0x9A, 0x66, 0xB3, 0xF9, 0xEA, + 0xAB, 0xEF, 0xDF, 0x68, 0xE3, 0x11, 0x42, 0x45, 0x9E, 0x53, 0xC6, 0x7A, + 0xA9, 0x00, 0xA1, 0xC5, 0xAA, 0x6E, 0xDA, 0x2E, 0x3A, 0x20, 0x52, 0xC1, + 0x57, 0xCB, 0xBA, 0xEB, 0x5A, 0x8C, 0xF1, 0xDE, 0xDE, 0x94, 0x31, 0xAA, + 0x94, 0xC6, 0x88, 0xD4, 0x75, 0x4B, 0x28, 0x31, 0xC6, 0x5C, 0xCF, 0x16, + 0x8C, 0xB3, 0xC3, 0x83, 0x29, 0xE7, 0x94, 0x10, 0x32, 0x19, 0x8F, 0x84, + 0x60, 0x14, 0xE3, 0xD9, 0x6C, 0xC9, 0x04, 0xCF, 0xB2, 0x14, 0x63, 0xC4, + 0x28, 0x33, 0xC6, 0xFA, 0xE0, 0x09, 0xC6, 0x6D, 0xD7, 0x1A, 0x6D, 0x12, + 0xC1, 0x72, 0x41, 0xCE, 0xCE, 0xE7, 0x67, 0xE7, 0xD7, 0xB3, 0xEB, 0xD9, + 0xDB, 0x77, 0xE7, 0x7D, 0x2F, 0xBB, 0xAE, 0xC5, 0x98, 0x68, 0xAD, 0xBB, + 0xBE, 0x77, 0xCE, 0x69, 0x65, 0xEA, 0xA6, 0x45, 0x08, 0xC5, 0xBD, 0xC9, + 0x18, 0x0B, 0x18, 0xA5, 0x89, 0x18, 0x5C, 0x6F, 0xD6, 0x51, 0x46, 0x8D, + 0x75, 0xC6, 0x38, 0x4C, 0x48, 0xEC, 0xA5, 0x24, 0x95, 0xF6, 0x01, 0x18, + 0xA3, 0x42, 0x88, 0xF5, 0xAA, 0x3E, 0xD8, 0x9F, 0xBC, 0xBF, 0xB8, 0xB6, + 0xCE, 0xDE, 0x3F, 0x3E, 0x04, 0x14, 0xAE, 0xAE, 0x17, 0x94, 0x92, 0xA6, + 0xED, 0x67, 0x8B, 0xB5, 0xB5, 0xF6, 0xF2, 0x6A, 0xF1, 0xEC, 0xC5, 0x9B, + 0xB7, 0xA7, 0x57, 0x00, 0xE8, 0xE1, 0xC9, 0x41, 0x59, 0xA4, 0xEB, 0xBA, + 0xBB, 0x9A, 0xAD, 0x2E, 0xAF, 0x17, 0x47, 0x07, 0x13, 0x21, 0xF8, 0x87, + 0xEA, 0xF9, 0xC7, 0x5D, 0x0D, 0xBF, 0x4B, 0x55, 0xDF, 0xAE, 0xAB, 0xAD, + 0xC8, 0x6D, 0xD7, 0x18, 0x46, 0xE8, 0xFB, 0x97, 0xEF, 0xFE, 0xEE, 0xD7, + 0xCF, 0xFF, 0xEE, 0xD7, 0xCF, 0x5E, 0x9F, 0x5E, 0x01, 0x20, 0x65, 0xCC, + 0xD9, 0xF9, 0x2C, 0x46, 0x66, 0x7B, 0xA5, 0xE7, 0x8B, 0xF5, 0x62, 0xB1, + 0xEE, 0xA5, 0x8C, 0x49, 0xCB, 0x52, 0x6A, 0x19, 0x2B, 0x90, 0xB4, 0x69, + 0x9A, 0x5E, 0x6B, 0xAD, 0xB5, 0xED, 0xFB, 0x3E, 0x56, 0x9B, 0x6E, 0x81, + 0xD2, 0x5A, 0x57, 0x16, 0xD9, 0xE1, 0xE1, 0xF4, 0x7A, 0xB6, 0x9A, 0xCD, + 0x16, 0x59, 0x96, 0x44, 0x91, 0xEF, 0xA5, 0x9A, 0x8E, 0x8B, 0x24, 0xE1, + 0x10, 0x02, 0x63, 0xD4, 0x59, 0x17, 0x20, 0x68, 0xE3, 0x7E, 0xF3, 0xCD, + 0x8B, 0x57, 0xEF, 0xCE, 0xAB, 0x32, 0xC7, 0x18, 0xA7, 0x09, 0x1F, 0x57, + 0xB9, 0xD6, 0xF6, 0xF4, 0xFD, 0x95, 0x36, 0x9A, 0x12, 0xCA, 0x39, 0x8B, + 0x11, 0x41, 0x65, 0xCC, 0xC5, 0xD5, 0xC2, 0x7B, 0xDF, 0x75, 0xBD, 0xF7, + 0xA1, 0xEF, 0xFA, 0x2F, 0x7F, 0xF3, 0x9D, 0xB6, 0xF0, 0xF0, 0xE4, 0xE0, + 0xE4, 0x68, 0x1C, 0x02, 0x74, 0xBD, 0x8A, 0x51, 0xD4, 0xDB, 0x07, 0x1E, + 0xE8, 0x70, 0xD0, 0x06, 0x5F, 0x30, 0xC6, 0x80, 0x20, 0x26, 0x45, 0x21, + 0x1C, 0xB3, 0x28, 0xB6, 0x8E, 0x2B, 0x84, 0x76, 0xDC, 0xF6, 0xBB, 0x26, + 0xD4, 0x16, 0xF8, 0xB6, 0x66, 0xEC, 0xAE, 0x63, 0x67, 0x67, 0xB4, 0x6F, + 0x4E, 0xB8, 0x10, 0xA2, 0x67, 0xCD, 0x87, 0x40, 0x7E, 0xF6, 0x17, 0xFF, + 0x7E, 0x77, 0xF4, 0xEF, 0xFE, 0x1D, 0x1E, 0x6C, 0x00, 0x2C, 0x6C, 0xA0, + 0x31, 0x3E, 0xDE, 0x60, 0xEB, 0x76, 0x82, 0x43, 0x08, 0x90, 0x09, 0xB6, + 0x69, 0x02, 0x04, 0x21, 0x04, 0xC1, 0xC9, 0xA7, 0x0F, 0xF6, 0xF6, 0x27, + 0x45, 0x9E, 0xA5, 0x69, 0xC2, 0x63, 0x27, 0x1E, 0xBA, 0xE1, 0x77, 0x8D, + 0x71, 0x99, 0x98, 0x9B, 0xAE, 0x8D, 0xD5, 0xDA, 0x52, 0x4A, 0xB2, 0x94, + 0x27, 0x82, 0x0B, 0x21, 0x22, 0x80, 0xFD, 0x03, 0x95, 0xAC, 0x5B, 0xB7, + 0xBD, 0x7B, 0x66, 0x7B, 0x47, 0xB7, 0x9E, 0xA2, 0x0D, 0x67, 0x9B, 0xB5, + 0xCE, 0x18, 0xAB, 0xF5, 0x50, 0xED, 0xB1, 0x25, 0x56, 0xDC, 0x5E, 0x13, + 0x0F, 0x63, 0x06, 0xA8, 0x8B, 0x57, 0xC6, 0xE5, 0xE5, 0x9C, 0xEB, 0x7B, + 0xED, 0x3C, 0xFC, 0xED, 0xDF, 0x7D, 0x39, 0x9B, 0xAD, 0x18, 0x67, 0x7B, + 0xE3, 0xF2, 0xE4, 0x68, 0xDF, 0x3A, 0xAF, 0xE3, 0x61, 0xBD, 0x0B, 0x80, + 0x31, 0x71, 0xD6, 0x35, 0x4D, 0x2B, 0xA5, 0x46, 0x08, 0x8B, 0x44, 0x88, + 0x24, 0x09, 0x80, 0xAC, 0xF5, 0xD6, 0xBA, 0x00, 0x41, 0x24, 0xE9, 0x74, + 0x32, 0x4A, 0x12, 0x6E, 0x8D, 0xCD, 0xF3, 0x2C, 0x04, 0x9F, 0xA4, 0x89, + 0xD2, 0x86, 0x51, 0xAA, 0xB5, 0xE5, 0x9C, 0x55, 0x65, 0x51, 0x16, 0xF9, + 0xC1, 0xFE, 0x64, 0x34, 0x2A, 0x10, 0x0A, 0xC6, 0xB8, 0xBE, 0x69, 0x5E, + 0xBF, 0x79, 0x4B, 0xB9, 0xD8, 0xDF, 0x1B, 0x57, 0x45, 0xEA, 0x62, 0xA3, + 0x13, 0x4A, 0x20, 0xF8, 0xE0, 0xC3, 0x62, 0xDD, 0xBD, 0x7B, 0x7F, 0xF9, + 0xE2, 0xCD, 0x79, 0xD7, 0x47, 0xCE, 0x58, 0x0C, 0x00, 0xCE, 0x39, 0xA5, + 0xB4, 0x73, 0xBE, 0xED, 0xFA, 0x24, 0x49, 0x30, 0x42, 0x6D, 0xDB, 0x5D, + 0x5E, 0xCE, 0xD6, 0xEB, 0xBA, 0xEF, 0xA5, 0x73, 0x9E, 0x0B, 0xBE, 0x5E, + 0xAD, 0x03, 0x20, 0xA5, 0xE4, 0xF9, 0xF9, 0xA5, 0xF7, 0x60, 0x8C, 0x41, + 0x08, 0xB2, 0x2C, 0x59, 0xAD, 0x6B, 0x63, 0x1C, 0xC2, 0xA8, 0xA9, 0x9B, + 0xAE, 0xED, 0xBC, 0x55, 0x97, 0xD7, 0x8B, 0x80, 0x50, 0x9E, 0xA5, 0xAB, + 0x75, 0xCD, 0x39, 0x8F, 0x2E, 0x58, 0xE7, 0xDC, 0xC0, 0x45, 0x69, 0x35, + 0x20, 0xD4, 0x4A, 0xDB, 0xC9, 0x5E, 0x08, 0xF1, 0xFE, 0xEC, 0xE2, 0xF0, + 0x60, 0x0F, 0x21, 0xE4, 0xBD, 0x4F, 0xD3, 0x84, 0xD0, 0x4D, 0x12, 0x75, + 0x08, 0x08, 0x81, 0xF7, 0x0E, 0x13, 0xAC, 0xAC, 0xC5, 0x08, 0x59, 0x63, + 0x01, 0xBC, 0xF5, 0x9E, 0x12, 0x6C, 0xAD, 0xF5, 0x01, 0xBA, 0x5E, 0x32, + 0xC6, 0x30, 0x8E, 0x1D, 0x33, 0x8D, 0xB5, 0x4E, 0x08, 0x56, 0x96, 0x19, + 0x21, 0xC4, 0x39, 0x37, 0xAA, 0x8A, 0xE5, 0xBA, 0x89, 0xE9, 0x3C, 0x65, + 0x96, 0xAE, 0xD7, 0x2D, 0xC6, 0xB8, 0xED, 0xE5, 0xBA, 0x6E, 0x95, 0xD4, + 0xCA, 0x18, 0x67, 0xED, 0xF5, 0x7C, 0x75, 0x3D, 0x5F, 0xDD, 0x3B, 0x98, + 0x1E, 0x1F, 0x4D, 0x85, 0xE0, 0x8B, 0xE5, 0x9A, 0x60, 0x7C, 0xB8, 0x3F, + 0x76, 0x1F, 0x92, 0x64, 0xFD, 0x43, 0x8E, 0xED, 0x32, 0xDB, 0x15, 0x9C, + 0x1D, 0x41, 0x05, 0xCE, 0xD9, 0xE9, 0xFB, 0xAB, 0xFF, 0xE5, 0x7F, 0xFD, + 0x8F, 0xAB, 0x5A, 0xA6, 0x69, 0x7A, 0x71, 0x39, 0x8F, 0x85, 0xE9, 0xD3, + 0xC9, 0x38, 0x49, 0xF8, 0xBA, 0x6E, 0x0E, 0xF6, 0x26, 0xD6, 0xB8, 0x75, + 0xDD, 0x72, 0x4E, 0x03, 0x42, 0x46, 0x0F, 0x3A, 0x97, 0xB5, 0xF6, 0xDE, + 0xD1, 0xDE, 0xC3, 0xFB, 0x47, 0x79, 0x91, 0x49, 0xA9, 0xA5, 0x54, 0xDE, + 0x7B, 0xEF, 0x1D, 0x1E, 0x3A, 0xE1, 0x41, 0x34, 0x57, 0xF7, 0xA7, 0xE3, + 0x8B, 0xD9, 0xD2, 0x5A, 0x77, 0xB8, 0x3F, 0x7D, 0xFC, 0xE8, 0xDE, 0x72, + 0xD5, 0x2C, 0xEB, 0x46, 0x2A, 0x7D, 0xB8, 0x3F, 0x71, 0xD6, 0x1B, 0x63, + 0xA2, 0xBB, 0x2A, 0x6E, 0xFF, 0x8B, 0x65, 0x93, 0xE7, 0x29, 0xC6, 0x68, + 0x3A, 0x2A, 0xB3, 0x2C, 0x89, 0xED, 0xD5, 0x29, 0xA5, 0x5D, 0xDF, 0xA7, + 0x69, 0x92, 0x08, 0x2E, 0x95, 0xFE, 0xCD, 0xD7, 0xCF, 0x01, 0xD0, 0x7C, + 0xB9, 0x92, 0x52, 0x1D, 0x1D, 0xEE, 0x8F, 0xAA, 0xB2, 0x6D, 0x3B, 0x6D, + 0x4D, 0x27, 0xAD, 0x10, 0x6C, 0xB1, 0x58, 0xFF, 0x87, 0xBF, 0xFD, 0xAA, + 0xED, 0xD4, 0x83, 0xA3, 0x3D, 0xB4, 0x93, 0x5E, 0x70, 0xA3, 0x1F, 0x0D, + 0xE8, 0xB3, 0xD5, 0x81, 0x30, 0xC1, 0x98, 0xC4, 0xA4, 0x8A, 0xBB, 0xCE, + 0xB5, 0x1B, 0xFD, 0x37, 0x36, 0xF4, 0x0E, 0x37, 0xF1, 0xCF, 0x38, 0xB6, + 0xE1, 0x03, 0x7C, 0x96, 0x71, 0x76, 0x00, 0x00, 0x20, 0x00, 0x49, 0x44, + 0x41, 0x54, 0x41, 0xDE, 0x0E, 0xF5, 0x16, 0x79, 0x7C, 0x08, 0x76, 0xCB, + 0x0C, 0x17, 0x50, 0x08, 0x40, 0xFE, 0xFC, 0x2F, 0x7E, 0xBE, 0x89, 0x53, + 0xDE, 0xD6, 0x59, 0x76, 0x31, 0x77, 0x5B, 0x88, 0xB5, 0x73, 0x7E, 0x08, + 0x39, 0x0C, 0x9D, 0x4A, 0x10, 0x50, 0x12, 0x6B, 0x27, 0x11, 0xA3, 0x18, + 0x01, 0x0A, 0x01, 0x8A, 0x94, 0x1F, 0x4E, 0x8B, 0xFB, 0x87, 0xA3, 0x51, + 0x99, 0x31, 0xCE, 0x76, 0x55, 0xA7, 0xCD, 0x0E, 0xB6, 0xD5, 0xA1, 0x60, + 0xB0, 0xC5, 0xD2, 0x24, 0xCF, 0x53, 0x21, 0x44, 0x44, 0xB0, 0x8F, 0xE2, + 0xD7, 0x47, 0x31, 0xEB, 0xCE, 0x4E, 0xF1, 0x11, 0x15, 0x6C, 0xF7, 0xFA, + 0x98, 0x64, 0xE8, 0x87, 0xC3, 0x45, 0xCB, 0x3C, 0xC6, 0x77, 0x36, 0xA6, + 0x2B, 0xD9, 0x5E, 0x1C, 0x06, 0x37, 0x64, 0xB0, 0xD6, 0x19, 0xE3, 0xAC, + 0xF5, 0x03, 0x03, 0xB3, 0xF7, 0x00, 0x21, 0x36, 0x12, 0x63, 0x8C, 0xBE, + 0x7D, 0xF7, 0x5E, 0x4A, 0x95, 0x67, 0xC9, 0x83, 0x93, 0x83, 0xAC, 0x28, + 0x18, 0x63, 0xBD, 0xD2, 0xDE, 0x03, 0x67, 0xC4, 0xF9, 0xA0, 0x8D, 0x75, + 0x37, 0x4E, 0x3D, 0x6C, 0xAC, 0x35, 0xC6, 0x6A, 0x6B, 0xAD, 0x75, 0x52, + 0xE9, 0xAA, 0x2A, 0xC7, 0xA3, 0x2A, 0xBA, 0xD5, 0x00, 0x21, 0x9E, 0xF0, + 0x7B, 0x87, 0xFB, 0x3E, 0xF8, 0xAE, 0x57, 0x08, 0x61, 0x21, 0xF8, 0xFE, + 0xDE, 0xA4, 0x28, 0x32, 0xE3, 0x5C, 0x91, 0xA7, 0xC1, 0x87, 0xCB, 0xCB, + 0xF9, 0x7A, 0x5D, 0x9F, 0x9F, 0x9F, 0x53, 0x26, 0xF2, 0x22, 0xCF, 0xB3, + 0xD4, 0x68, 0x93, 0x67, 0x82, 0x52, 0xE2, 0xAC, 0x9D, 0x5D, 0x2F, 0x09, + 0xA5, 0x9C, 0xB3, 0xEB, 0xF9, 0xAA, 0xC8, 0xF3, 0x51, 0x55, 0x22, 0x04, + 0xA3, 0x51, 0x21, 0x38, 0x73, 0x6E, 0x48, 0xDF, 0x93, 0x52, 0xF5, 0xBD, + 0xBC, 0x38, 0xBF, 0xEA, 0x9A, 0x6E, 0x5D, 0xAF, 0x23, 0x05, 0x93, 0xB3, + 0xCE, 0x79, 0x5F, 0xD7, 0xCD, 0x64, 0x3C, 0x3A, 0x3B, 0x3B, 0xB7, 0xD6, + 0x7A, 0x6F, 0x01, 0xC2, 0xE1, 0xE1, 0xBE, 0x54, 0xBA, 0x28, 0xF2, 0xE3, + 0x7B, 0x07, 0xB2, 0x97, 0x21, 0x84, 0xBE, 0x97, 0xFD, 0x6A, 0x55, 0xAF, + 0x9B, 0x41, 0x1D, 0x63, 0xDC, 0x59, 0x8B, 0x31, 0xB6, 0xD6, 0x19, 0xAD, + 0xB3, 0x24, 0xE9, 0x65, 0x0F, 0xDE, 0xFE, 0xFA, 0xB7, 0xCF, 0x7A, 0xA5, + 0x21, 0x04, 0x63, 0xED, 0xC5, 0xE5, 0xE5, 0xFD, 0x93, 0x63, 0x6B, 0xAD, + 0x52, 0xCA, 0xFB, 0x00, 0x08, 0x23, 0x84, 0xAC, 0x73, 0x08, 0x21, 0x4A, + 0x08, 0x00, 0x20, 0x8C, 0x43, 0xF0, 0x28, 0x0C, 0x2C, 0xBB, 0x21, 0x04, + 0x42, 0xB0, 0x0F, 0x40, 0x08, 0xC5, 0x84, 0x58, 0x63, 0xCB, 0x22, 0x03, + 0x08, 0x52, 0x69, 0x42, 0x48, 0x88, 0xA9, 0x8B, 0xDA, 0xF4, 0xBD, 0x2C, + 0xF2, 0xD4, 0x79, 0xA7, 0x8D, 0x19, 0x55, 0x45, 0xD3, 0xF5, 0x79, 0x9E, + 0x21, 0x04, 0x18, 0x21, 0x6B, 0xED, 0xBA, 0x6E, 0xA5, 0x54, 0xCE, 0x39, + 0x65, 0xF4, 0xBA, 0x6E, 0xAF, 0xE7, 0x2B, 0x6B, 0x5D, 0x91, 0xA7, 0x55, + 0x91, 0xBB, 0xE0, 0xF3, 0x2C, 0xE1, 0x8C, 0x7D, 0x48, 0xF8, 0x77, 0xDB, + 0xAE, 0xFC, 0x5D, 0xEE, 0xB0, 0xBB, 0x4B, 0x6E, 0x2B, 0x6C, 0x8C, 0xD1, + 0xEF, 0x9F, 0xBD, 0xBD, 0x9A, 0xD5, 0xCA, 0xFA, 0xE8, 0x12, 0x35, 0xD6, + 0x1D, 0xEC, 0x4F, 0x38, 0xA7, 0x04, 0xE3, 0xCF, 0x3E, 0x79, 0xC8, 0x39, + 0xCD, 0xF3, 0x1C, 0x10, 0x72, 0x9B, 0x1D, 0x14, 0x63, 0x44, 0x28, 0xF9, + 0xD1, 0x17, 0x9F, 0x3C, 0xBE, 0x7F, 0xEF, 0xE2, 0x6A, 0x7E, 0x7A, 0x76, + 0xA9, 0xB5, 0x89, 0xB4, 0x3F, 0x5A, 0xDB, 0x58, 0x14, 0x19, 0x07, 0xAA, + 0x97, 0x2A, 0x49, 0x92, 0x4F, 0x1E, 0x9D, 0x1C, 0x1D, 0x4C, 0x46, 0x55, + 0xF9, 0xF8, 0xFE, 0x61, 0x9A, 0xF2, 0x87, 0xF7, 0x0F, 0x0F, 0xA7, 0x23, + 0xAD, 0xAD, 0x87, 0x30, 0x5B, 0xAC, 0x7B, 0xA9, 0x00, 0x23, 0x8C, 0x10, + 0xE7, 0x8C, 0x32, 0xB2, 0x5A, 0x37, 0x00, 0x50, 0xB7, 0xDD, 0x62, 0xD5, + 0xAC, 0xEB, 0xF6, 0xF2, 0x7A, 0xDE, 0xF7, 0x6A, 0x3A, 0x19, 0x39, 0xE7, + 0xEA, 0xA6, 0x5B, 0xAF, 0x5B, 0x6B, 0x5D, 0x55, 0xE5, 0x93, 0x71, 0x75, + 0x7E, 0x31, 0xFF, 0xE6, 0xBB, 0xE7, 0xBD, 0x54, 0x45, 0x59, 0x94, 0x65, + 0x1E, 0x00, 0x5D, 0x2F, 0xEA, 0x67, 0xAF, 0xCE, 0xDB, 0x4E, 0x37, 0xAD, + 0x2C, 0xF3, 0x74, 0x3A, 0x29, 0xB6, 0x01, 0x2E, 0xB4, 0xC9, 0x92, 0xDB, + 0x75, 0x9F, 0x45, 0xD9, 0x26, 0x18, 0x6D, 0x20, 0xEE, 0x06, 0x86, 0x76, + 0x04, 0x0A, 0xC2, 0xD0, 0x42, 0x29, 0xA0, 0xAD, 0xAB, 0x6C, 0x73, 0x4D, + 0x6C, 0xA9, 0xBA, 0x3B, 0xA4, 0xDB, 0x89, 0xD9, 0xF2, 0x54, 0x47, 0xF0, + 0x8B, 0x30, 0x84, 0x10, 0x90, 0x3F, 0xFF, 0x77, 0xFF, 0x33, 0xFA, 0x70, + 0xDA, 0x76, 0xE7, 0x29, 0xFE, 0x87, 0xE1, 0xA6, 0x5E, 0xF3, 0xC3, 0x19, + 0x1D, 0xD2, 0x49, 0x00, 0x01, 0x41, 0x38, 0x4B, 0x68, 0x36, 0xF4, 0xD3, + 0x05, 0x4A, 0xF1, 0xFE, 0x38, 0xBF, 0xB7, 0x5F, 0x8D, 0x8A, 0x24, 0x49, + 0x38, 0x26, 0xF4, 0xB6, 0xD5, 0xB7, 0x73, 0x60, 0x8C, 0xA3, 0xD9, 0x18, + 0x11, 0x64, 0x83, 0xD9, 0x77, 0x7F, 0xD1, 0x0D, 0xAC, 0xDC, 0xFA, 0x25, + 0x1F, 0x35, 0x2A, 0x77, 0x1F, 0x7C, 0x30, 0x4C, 0x9B, 0x8A, 0xEE, 0x08, + 0x67, 0x7E, 0xD3, 0xCE, 0x0B, 0x0F, 0x9D, 0xC4, 0x21, 0x6A, 0x88, 0xD6, + 0x3A, 0xE7, 0xBC, 0xDB, 0x34, 0x3C, 0x8C, 0x6D, 0x5D, 0x43, 0x18, 0x62, + 0x17, 0x64, 0x08, 0xA9, 0x60, 0xC6, 0x28, 0x21, 0x98, 0x33, 0x9A, 0x08, + 0x7E, 0x71, 0x7E, 0xB5, 0x5C, 0xD6, 0xC7, 0xC7, 0x87, 0xBD, 0x09, 0xCE, + 0x03, 0xE5, 0x9C, 0x50, 0x1A, 0x00, 0x78, 0x92, 0x78, 0x80, 0x10, 0x42, + 0x92, 0x88, 0xB2, 0xCC, 0x4F, 0x4E, 0x8E, 0x4E, 0x4E, 0xEE, 0x9D, 0x1C, + 0x1F, 0x1D, 0xDF, 0x3B, 0x3C, 0x3A, 0xDC, 0xA7, 0x8C, 0xF7, 0x52, 0xE5, + 0x59, 0xDA, 0xB6, 0x5D, 0x92, 0xF0, 0xC3, 0x83, 0xE9, 0xA3, 0x07, 0xC7, + 0xDE, 0x07, 0xCE, 0x68, 0x59, 0x64, 0x07, 0xFB, 0x7B, 0x69, 0x96, 0x60, + 0x8C, 0xEE, 0x1D, 0xED, 0x51, 0xCA, 0xB2, 0x34, 0xE9, 0xFB, 0xFE, 0xDD, + 0xBB, 0xB3, 0xC5, 0x7C, 0x31, 0x9B, 0xCD, 0xD6, 0xEB, 0x9A, 0x52, 0x3A, + 0x19, 0x8F, 0x94, 0x94, 0x84, 0xD0, 0x84, 0xB3, 0x2C, 0x65, 0xCE, 0xB9, + 0x34, 0xE1, 0x4A, 0x1B, 0x91, 0xA6, 0xD6, 0xBA, 0xC5, 0x62, 0x8D, 0x10, + 0x92, 0x52, 0x36, 0x4D, 0x47, 0x29, 0x2B, 0x8A, 0x8C, 0x60, 0x82, 0x00, + 0x54, 0xDF, 0x9D, 0x9D, 0xBE, 0xBF, 0xB8, 0xBC, 0x8E, 0x6D, 0xD3, 0xFA, + 0x5E, 0x36, 0x4D, 0xEB, 0x82, 0x47, 0x80, 0xB4, 0x31, 0x84, 0xD2, 0xA6, + 0x69, 0xB9, 0xE0, 0x18, 0xC2, 0x74, 0x3A, 0x49, 0xB3, 0x34, 0xCF, 0xD2, + 0x24, 0xE1, 0x08, 0xA1, 0x44, 0x08, 0xA5, 0xCD, 0xFE, 0xA4, 0x34, 0x5A, + 0x23, 0x42, 0xC7, 0xA3, 0xD2, 0x18, 0x6B, 0xAC, 0x15, 0x42, 0xF4, 0xBD, + 0xEC, 0xBB, 0x16, 0x03, 0x64, 0x99, 0x48, 0x19, 0x79, 0xFD, 0xFA, 0xEC, + 0xF4, 0xFC, 0x2A, 0x38, 0xBB, 0x5C, 0xAC, 0xFA, 0x5E, 0x6A, 0x65, 0x8A, + 0xAA, 0x40, 0x28, 0x2C, 0x16, 0x2B, 0xC6, 0x58, 0xCC, 0xBD, 0x20, 0x84, + 0x94, 0x65, 0x11, 0xBD, 0xA5, 0x10, 0x02, 0x63, 0x2C, 0xC4, 0xA8, 0x65, + 0x08, 0x18, 0x21, 0xE7, 0x3C, 0x84, 0xE0, 0x21, 0x10, 0x42, 0xA4, 0xD4, + 0x80, 0x60, 0x3A, 0x19, 0x5B, 0xEB, 0x7A, 0x29, 0x29, 0xA1, 0x18, 0x23, + 0x40, 0xE0, 0x7D, 0xE8, 0xA5, 0x64, 0x8C, 0x2F, 0x16, 0x2B, 0xEB, 0x86, + 0xFE, 0x50, 0x9C, 0x51, 0xA5, 0x4D, 0xDD, 0xF4, 0x11, 0x73, 0x21, 0x84, + 0xAA, 0xC8, 0x23, 0x7D, 0xC8, 0xAA, 0x6E, 0x19, 0x65, 0x08, 0xC0, 0x6A, + 0xEB, 0x9D, 0xDD, 0x9F, 0x8C, 0x8C, 0xB5, 0x1B, 0x37, 0xEF, 0x76, 0xA9, + 0xFC, 0x4E, 0x03, 0x65, 0xBB, 0xFC, 0x76, 0x9D, 0xB3, 0x5B, 0x08, 0x8B, + 0xFF, 0x84, 0xE0, 0x2F, 0x5E, 0x9D, 0xBE, 0x78, 0x75, 0x76, 0xEF, 0xDE, + 0xE1, 0xBA, 0x69, 0x37, 0x9D, 0x07, 0x7C, 0x96, 0x25, 0x00, 0x08, 0x23, + 0x20, 0x04, 0xAF, 0x9A, 0x2E, 0xCF, 0xD3, 0xAE, 0x57, 0xD1, 0x78, 0x4C, + 0x12, 0x91, 0x65, 0x49, 0x9A, 0x8A, 0x67, 0xCF, 0xDF, 0x5E, 0x5C, 0xCD, + 0xE2, 0xA4, 0x00, 0x80, 0x0F, 0x70, 0xEF, 0xDE, 0xFE, 0xF1, 0xD1, 0x9E, + 0xF7, 0xA1, 0x69, 0x3A, 0xCE, 0x99, 0x10, 0xBC, 0x97, 0xEA, 0x8B, 0xCF, + 0x1F, 0xFD, 0xF3, 0x7F, 0xF2, 0xE3, 0xE3, 0xA3, 0xA9, 0xE0, 0x74, 0x7F, + 0x3A, 0x8A, 0x3E, 0x17, 0xA9, 0x74, 0x96, 0xF2, 0x32, 0xCF, 0x92, 0x84, + 0x6B, 0x6D, 0xFB, 0x5E, 0x67, 0x99, 0xC8, 0xD3, 0xC4, 0xFB, 0x30, 0x5B, + 0xAC, 0x16, 0xAB, 0xFA, 0x6A, 0xB6, 0x7A, 0xF6, 0xE2, 0x8D, 0x73, 0xA1, + 0x2A, 0x8A, 0xF9, 0x72, 0x75, 0x71, 0x35, 0x33, 0xC6, 0xF6, 0x4A, 0x69, + 0x6B, 0xA7, 0x93, 0x31, 0x21, 0xF8, 0xD3, 0x4F, 0x1E, 0x00, 0x20, 0xCE, + 0xF9, 0x8F, 0xBF, 0x78, 0xF2, 0xF4, 0xC9, 0xFD, 0x44, 0xF0, 0xD7, 0x6F, + 0xCF, 0x26, 0xE3, 0xD1, 0x6C, 0xBE, 0x5C, 0xAC, 0xEA, 0x5E, 0xDB, 0x37, + 0x67, 0x57, 0x52, 0xEA, 0xE3, 0xC3, 0x89, 0x31, 0x36, 0x00, 0x6C, 0x52, + 0x55, 0x3F, 0x64, 0x2D, 0x45, 0x08, 0x62, 0x2A, 0xD8, 0x16, 0x6C, 0x76, + 0x24, 0xD7, 0x0F, 0x74, 0x1D, 0x38, 0xAA, 0x0E, 0xE4, 0xE6, 0xED, 0x1B, + 0xB1, 0x05, 0xC0, 0x3B, 0xF6, 0x10, 0x6C, 0xF6, 0x96, 0x8D, 0x39, 0x88, + 0x00, 0x20, 0x32, 0x98, 0x6F, 0x02, 0x80, 0x88, 0x0E, 0x90, 0x16, 0x36, + 0xAD, 0x4D, 0x76, 0x0A, 0xA1, 0xC3, 0x8E, 0xE7, 0x73, 0x1B, 0x23, 0xD8, + 0x30, 0x97, 0x05, 0x08, 0x38, 0xB6, 0x3F, 0x8B, 0x5F, 0x99, 0x70, 0xC2, + 0x29, 0x29, 0x33, 0x8E, 0x10, 0xE2, 0x8C, 0x0A, 0x4E, 0xA3, 0x76, 0xE0, + 0x7D, 0x00, 0xC0, 0xBB, 0xE0, 0xF7, 0xBB, 0x8E, 0xF0, 0xBB, 0xA0, 0xEB, + 0xC3, 0xE3, 0x16, 0x48, 0xC3, 0x6D, 0x6C, 0xFD, 0x88, 0x75, 0x09, 0x3B, + 0x46, 0xE5, 0xF6, 0xF1, 0x76, 0x1C, 0x07, 0x95, 0x6C, 0x70, 0x8D, 0x05, + 0xEF, 0x7D, 0x6C, 0x09, 0x6E, 0xAC, 0x1D, 0x66, 0x68, 0xF3, 0x17, 0x13, + 0x44, 0x30, 0x12, 0x2C, 0x26, 0xE2, 0x7E, 0x40, 0xAA, 0x17, 0x07, 0x34, + 0xE1, 0x54, 0x70, 0x76, 0x79, 0xBD, 0x14, 0xC9, 0xE0, 0xB9, 0x10, 0x69, + 0x96, 0x16, 0x65, 0xF0, 0xBE, 0x1A, 0xB9, 0x00, 0xA0, 0xB5, 0x11, 0x89, + 0x40, 0x08, 0x19, 0x6D, 0x8D, 0x75, 0xC6, 0x1A, 0x6D, 0x6C, 0x92, 0xF0, + 0x3C, 0x4B, 0x8B, 0x3C, 0xA3, 0x94, 0x64, 0x69, 0x96, 0x67, 0x59, 0x24, + 0x05, 0x4D, 0xB3, 0x84, 0x32, 0x1A, 0x42, 0x10, 0x9D, 0xDC, 0x9B, 0x8C, + 0x00, 0xD0, 0x6A, 0xB5, 0x5A, 0xCC, 0xE6, 0x4D, 0xDD, 0x04, 0x08, 0x18, + 0xA1, 0xB6, 0xEB, 0xB3, 0x2C, 0x25, 0x04, 0xCF, 0xE7, 0x0B, 0xCE, 0x79, + 0x08, 0x90, 0x70, 0x22, 0x04, 0x43, 0x10, 0xAE, 0xE7, 0x0B, 0x9E, 0x64, + 0xCE, 0x39, 0xCE, 0x69, 0x55, 0x15, 0xCE, 0xB9, 0xD5, 0xAA, 0xC1, 0x18, + 0x5B, 0x1B, 0x9A, 0xAE, 0xA7, 0x94, 0xCE, 0x67, 0x73, 0x8A, 0xC3, 0x4F, + 0x3E, 0x7F, 0xF4, 0xAE, 0xCC, 0x16, 0xAB, 0x66, 0xBE, 0x58, 0x21, 0x8C, + 0x09, 0x25, 0x84, 0x50, 0x8C, 0x71, 0x9A, 0xA6, 0x7D, 0x2F, 0xA3, 0x9D, + 0x3D, 0x1D, 0x17, 0xEB, 0x55, 0xED, 0x9C, 0x7F, 0xFA, 0xF4, 0x51, 0xAC, + 0x02, 0x6B, 0xBB, 0xBE, 0x2C, 0xB2, 0x3C, 0x21, 0xAF, 0xD6, 0x0D, 0x65, + 0x1C, 0x13, 0x52, 0x8D, 0x72, 0xE7, 0x43, 0xDB, 0xF7, 0x2F, 0x5E, 0xBC, + 0xC9, 0xD2, 0xF4, 0x07, 0x9F, 0x3D, 0x5E, 0xAF, 0x56, 0xF5, 0xBA, 0x99, + 0xAD, 0x7B, 0x6D, 0xDD, 0x34, 0x11, 0x84, 0xE0, 0x75, 0xD3, 0x27, 0x89, + 0x58, 0xAD, 0xEA, 0xA2, 0x48, 0xAB, 0xAA, 0x0C, 0x21, 0x70, 0xCA, 0xE2, + 0xD8, 0xB7, 0x7D, 0x2F, 0x18, 0x63, 0x94, 0x69, 0x63, 0xA2, 0xE3, 0xD7, + 0x18, 0x83, 0x31, 0xA1, 0x94, 0x00, 0x80, 0x31, 0x06, 0x01, 0x20, 0xC2, + 0xCA, 0x32, 0x6B, 0xDA, 0xBE, 0x6E, 0xBA, 0xA3, 0xC3, 0xFD, 0xC8, 0xCE, + 0x58, 0x95, 0x79, 0x8C, 0x86, 0xA9, 0x60, 0x99, 0x94, 0x80, 0xD0, 0xFB, + 0xF3, 0xAB, 0xB2, 0xC8, 0x55, 0x9E, 0xAB, 0x54, 0x07, 0x80, 0xBE, 0x97, + 0x5D, 0xD7, 0x91, 0xC8, 0x80, 0xEE, 0x7D, 0x9E, 0xA7, 0x79, 0x96, 0x12, + 0x4A, 0x67, 0xCB, 0x5A, 0x70, 0x56, 0x16, 0x29, 0x89, 0x19, 0x70, 0x28, + 0x76, 0x98, 0xDE, 0xF5, 0x3F, 0xC4, 0xAD, 0xEE, 0x23, 0x0B, 0x6C, 0x77, + 0x1D, 0x6E, 0xDD, 0xCF, 0xB7, 0x2E, 0x8B, 0x42, 0x21, 0x18, 0x4E, 0x05, + 0x0F, 0x01, 0x84, 0xE0, 0x82, 0xF3, 0xBA, 0x69, 0x28, 0x63, 0xD3, 0x49, + 0xB5, 0x5C, 0x37, 0xE7, 0x17, 0xB3, 0x3C, 0x4F, 0x9F, 0x3C, 0xBE, 0x1F, + 0x97, 0x1D, 0xA5, 0xA4, 0x69, 0x3A, 0x4A, 0xC9, 0xAB, 0xD7, 0xA7, 0x08, + 0xA1, 0xC9, 0x64, 0x34, 0x9F, 0x2F, 0xB5, 0x36, 0xD3, 0xBD, 0xF1, 0xE7, + 0x4F, 0x1F, 0xFE, 0xE0, 0xD3, 0xFB, 0xE3, 0xB2, 0xA8, 0xDB, 0xFE, 0x17, + 0xFF, 0xE9, 0xAB, 0xD3, 0xF7, 0x57, 0x8B, 0xE5, 0xAA, 0x28, 0xD2, 0xF7, + 0x17, 0x73, 0x6B, 0xCC, 0x9F, 0xFC, 0xD1, 0x0F, 0x97, 0x6B, 0xE5, 0xC3, + 0xD0, 0x4F, 0x76, 0x3C, 0x2A, 0x00, 0xC0, 0x59, 0xC7, 0x08, 0xC1, 0x18, + 0x4B, 0xDD, 0xAB, 0x6B, 0x3D, 0x1E, 0x95, 0xD6, 0xD9, 0xE9, 0xA4, 0xDA, + 0x9F, 0x8E, 0xA5, 0xD2, 0x9F, 0x3F, 0x7D, 0x50, 0x16, 0x39, 0x40, 0x58, + 0xAE, 0x1A, 0x84, 0x20, 0x4B, 0x92, 0xF9, 0xAA, 0xA6, 0x94, 0xD0, 0xA1, + 0x31, 0x68, 0x72, 0xEF, 0x70, 0x02, 0x00, 0xC6, 0xD8, 0xB3, 0x8B, 0xEB, + 0x2C, 0x4B, 0x9E, 0x3C, 0x3A, 0xE9, 0x7B, 0xB5, 0xBF, 0x37, 0x3E, 0xBF, + 0x9C, 0x5D, 0x5C, 0x2D, 0x10, 0x26, 0xA7, 0x97, 0xAB, 0xC3, 0xBD, 0xC5, + 0xFE, 0xB4, 0x8A, 0xEE, 0x15, 0x82, 0x71, 0xA4, 0xEA, 0x44, 0x9B, 0x12, + 0xC0, 0x10, 0x36, 0xFC, 0xE2, 0x68, 0x70, 0xA2, 0x6F, 0x94, 0x38, 0x70, + 0x3B, 0xD9, 0xB6, 0xDB, 0xDE, 0x7A, 0x9B, 0xA1, 0x1B, 0x14, 0x8C, 0xA8, + 0x68, 0x44, 0x5B, 0xDA, 0x7F, 0x28, 0xD2, 0x3E, 0x04, 0x3F, 0x10, 0xE1, + 0x45, 0xFD, 0x23, 0x76, 0xC3, 0x02, 0x3A, 0xC8, 0x61, 0x84, 0x4C, 0x40, + 0x68, 0xD7, 0x03, 0x77, 0x93, 0x68, 0x81, 0x00, 0x6E, 0xCE, 0xDF, 0x44, + 0x4C, 0x01, 0x30, 0xC6, 0xB1, 0x31, 0x65, 0x00, 0x60, 0x04, 0x11, 0x82, + 0x8B, 0x2C, 0x89, 0x8D, 0x8E, 0x28, 0x25, 0x00, 0x88, 0x90, 0xDF, 0x69, + 0xDF, 0x7D, 0x14, 0x7A, 0x76, 0x17, 0xCA, 0xFF, 0xEF, 0x35, 0xDB, 0x97, + 0x76, 0x71, 0xEA, 0xEE, 0xF5, 0xBB, 0x36, 0xC2, 0xF6, 0xFA, 0xED, 0x83, + 0x6D, 0xB8, 0x20, 0x04, 0x1B, 0x9D, 0x11, 0x04, 0xB6, 0x05, 0x9B, 0x01, + 0xE3, 0x4D, 0x03, 0x4A, 0x8C, 0x49, 0xC0, 0x81, 0x00, 0x80, 0xF3, 0xDE, + 0x6F, 0x34, 0xEA, 0x9B, 0x8D, 0x48, 0x4A, 0xD5, 0x75, 0xFD, 0xC3, 0xFB, + 0x07, 0xD5, 0x78, 0xFC, 0xED, 0xF3, 0x77, 0x52, 0xA9, 0xD1, 0xA8, 0x92, + 0x4A, 0xD7, 0x4D, 0x1F, 0x20, 0xE4, 0x59, 0xDA, 0xD4, 0x6D, 0xD7, 0x2B, + 0x79, 0x31, 0xC3, 0x18, 0x4B, 0xA9, 0x1C, 0x04, 0x00, 0x54, 0xE4, 0x39, + 0x25, 0xE4, 0xF3, 0x4F, 0x1F, 0x31, 0x4A, 0xCE, 0xCF, 0xAF, 0x20, 0x38, + 0x84, 0x20, 0x72, 0x78, 0x20, 0x84, 0xAE, 0xAF, 0xE7, 0x46, 0xEB, 0xE0, + 0xBD, 0x94, 0xAA, 0x6D, 0x9A, 0xA6, 0x6D, 0xBA, 0xA6, 0x2B, 0xF3, 0x1C, + 0x61, 0xC8, 0x8B, 0xEC, 0x93, 0x27, 0x0F, 0x8A, 0x8C, 0xCF, 0x56, 0x1D, + 0x84, 0x30, 0x1E, 0x95, 0x0F, 0xEF, 0xEF, 0x43, 0x08, 0xCE, 0x3A, 0xD9, + 0xF5, 0xDA, 0x38, 0xEB, 0xFB, 0x2C, 0xCF, 0x13, 0x21, 0x08, 0x21, 0xA7, + 0x67, 0x17, 0x52, 0x2A, 0x84, 0x91, 0x10, 0xBC, 0xAA, 0x8A, 0x7A, 0xDD, + 0xCC, 0x66, 0x0B, 0x63, 0x34, 0xC5, 0x68, 0x6F, 0x52, 0x51, 0x4A, 0xF6, + 0x26, 0xD5, 0xBA, 0xEE, 0xD7, 0x4D, 0x9B, 0x66, 0x19, 0x20, 0x84, 0x31, + 0x89, 0x15, 0xCB, 0x45, 0x9E, 0x60, 0x42, 0xFA, 0x4E, 0x1D, 0x57, 0x65, + 0x08, 0x41, 0x4A, 0x59, 0x64, 0xA9, 0x0F, 0x21, 0x17, 0xE4, 0xE5, 0x9B, + 0xF7, 0x69, 0x5E, 0x8C, 0xC7, 0xE3, 0x2C, 0xCF, 0x95, 0xD6, 0xDE, 0x87, + 0x6F, 0xBE, 0x7D, 0x71, 0x79, 0x71, 0xA9, 0xB4, 0x91, 0x4A, 0x2A, 0x29, + 0x39, 0x67, 0x82, 0x93, 0x87, 0x27, 0x07, 0x10, 0x10, 0x26, 0xB8, 0x93, + 0xAA, 0xEB, 0x65, 0x00, 0x24, 0x04, 0xCF, 0xF2, 0x22, 0x78, 0x27, 0x95, + 0x46, 0x08, 0x71, 0xCE, 0xBB, 0x5E, 0xC6, 0xED, 0xD8, 0x7B, 0xAF, 0x95, + 0xE6, 0x9C, 0x11, 0x42, 0xAC, 0xF7, 0x04, 0x30, 0x21, 0x38, 0x04, 0xAA, + 0xB4, 0x35, 0xB6, 0x17, 0x82, 0x13, 0x8C, 0xA5, 0x54, 0x94, 0xE0, 0x87, + 0x0F, 0x8E, 0xA7, 0x93, 0xF1, 0xAB, 0x37, 0xA7, 0x91, 0x3A, 0x8D, 0x73, + 0xE6, 0x5C, 0x10, 0x9C, 0xAF, 0xD6, 0x2D, 0x21, 0xC4, 0x87, 0xD0, 0xB4, + 0x6D, 0x08, 0xD0, 0xB6, 0x7D, 0xDF, 0xF7, 0x79, 0xCA, 0x29, 0xC2, 0x4D, + 0xD3, 0xDA, 0x10, 0x18, 0xA3, 0x93, 0x34, 0xBD, 0xBC, 0x9E, 0xDF, 0x3B, + 0x98, 0xBC, 0x3B, 0xBD, 0x58, 0xAE, 0x56, 0xC7, 0xFF, 0xEA, 0x5F, 0x10, + 0x3C, 0xF4, 0xB8, 0x0A, 0x1B, 0x3E, 0x2B, 0xB4, 0x93, 0x53, 0xBE, 0xD5, + 0xC8, 0x6E, 0xF9, 0x34, 0x36, 0x5C, 0xAF, 0x03, 0x59, 0xE3, 0x56, 0x61, + 0x23, 0x94, 0xB6, 0x4D, 0xBD, 0x9A, 0x5D, 0xFD, 0x93, 0x1F, 0x3F, 0x5A, + 0x6A, 0x18, 0x55, 0xB9, 0xE0, 0x7C, 0xBE, 0x58, 0xAF, 0xEB, 0x3A, 0x4E, + 0xEE, 0xE9, 0xD9, 0x65, 0x54, 0xF0, 0xDF, 0xBE, 0x3B, 0x47, 0x08, 0xAC, + 0xB5, 0xA3, 0xAA, 0x9C, 0x8C, 0x2B, 0x6B, 0x0D, 0x00, 0xC1, 0x84, 0xC4, + 0x9E, 0x7E, 0xD3, 0x69, 0xFA, 0x93, 0x2F, 0x9E, 0xFC, 0xC1, 0x0F, 0x3F, + 0x41, 0x18, 0x29, 0x65, 0x00, 0xC2, 0xBF, 0xFE, 0x97, 0xFF, 0xF4, 0x3F, + 0x7F, 0xF9, 0xFD, 0x7F, 0xF8, 0x7F, 0x7F, 0xC9, 0x28, 0x65, 0x84, 0xFC, + 0xEA, 0xB7, 0xCF, 0xBC, 0x0F, 0x08, 0x63, 0xEF, 0x83, 0xD6, 0xBA, 0x2C, + 0xD2, 0xAE, 0x57, 0x4F, 0x1F, 0x1D, 0x4F, 0xC6, 0x65, 0x08, 0x21, 0x4F, + 0x85, 0xF7, 0xE1, 0xEB, 0xEF, 0xDF, 0xBC, 0x7D, 0x7F, 0xFD, 0x93, 0x2F, + 0x9E, 0x08, 0xCE, 0x10, 0x40, 0x96, 0x70, 0xE7, 0xDC, 0x72, 0x55, 0xEF, + 0x4F, 0xAB, 0xCF, 0x9F, 0xDE, 0x8F, 0xB5, 0x89, 0x47, 0x07, 0x63, 0x65, + 0x0C, 0x46, 0x98, 0x33, 0xB2, 0x6E, 0xBA, 0x10, 0x60, 0x32, 0xCA, 0x25, + 0x46, 0xE3, 0xAA, 0xB4, 0xCE, 0x8D, 0xAA, 0x02, 0x00, 0x0E, 0xF6, 0x27, + 0x6F, 0x4F, 0xCF, 0x09, 0xC9, 0xBF, 0xFC, 0xED, 0xB7, 0xC7, 0xF7, 0x0E, + 0x47, 0x79, 0x72, 0xB0, 0x57, 0x59, 0xE7, 0xB1, 0x07, 0x87, 0xDC, 0x90, + 0x14, 0x86, 0x90, 0xDF, 0xD0, 0x44, 0xDF, 0x68, 0x3C, 0xB0, 0xDD, 0x18, + 0x6E, 0x14, 0xDB, 0x4D, 0xB6, 0xD9, 0x80, 0x62, 0xC3, 0x90, 0x6E, 0x7C, + 0x65, 0x61, 0x03, 0x85, 0xDB, 0xB7, 0xA1, 0x1D, 0x3F, 0x75, 0x6C, 0x8B, + 0xB5, 0x09, 0xE3, 0x02, 0x42, 0x9E, 0x52, 0x4A, 0x7E, 0xF6, 0x17, 0x3F, + 0xDF, 0x7E, 0x7A, 0xF8, 0xC0, 0x2F, 0xB6, 0xCD, 0xFA, 0xD8, 0xC5, 0x94, + 0x4D, 0x84, 0x02, 0x21, 0x00, 0x20, 0x18, 0xC5, 0xA2, 0xCB, 0x28, 0xF6, + 0x89, 0xA0, 0x55, 0x96, 0x46, 0x45, 0x8C, 0x52, 0x8A, 0xEE, 0xE8, 0x9C, + 0xFF, 0x40, 0x60, 0x1A, 0xBE, 0xE9, 0x43, 0xB2, 0xC3, 0x3B, 0xEF, 0x8A, + 0x3F, 0x6D, 0x73, 0x76, 0xB3, 0xC2, 0x6E, 0x61, 0xD6, 0xDD, 0x2F, 0xBA, + 0xF5, 0x69, 0xDB, 0x63, 0xB3, 0x5E, 0xB7, 0xDA, 0xAF, 0x47, 0x80, 0x08, + 0xC6, 0x08, 0xC0, 0x6F, 0x78, 0x95, 0x62, 0xDB, 0x37, 0xE7, 0xBC, 0xF3, + 0xDE, 0x5A, 0x07, 0x01, 0x22, 0x06, 0x0E, 0xBF, 0xD3, 0x39, 0x6B, 0x75, + 0xDB, 0x4A, 0xA5, 0x8C, 0xD4, 0x06, 0x05, 0xAF, 0x95, 0xAA, 0xEB, 0x7A, + 0x36, 0x5F, 0xAC, 0x57, 0x75, 0x00, 0x58, 0x2E, 0xD7, 0x08, 0xA1, 0xAE, + 0x93, 0x59, 0x96, 0x3A, 0x1F, 0xD6, 0xAB, 0x3A, 0x78, 0x67, 0x95, 0x6C, + 0xD7, 0xAB, 0x7A, 0xB5, 0xBC, 0x78, 0x7F, 0xD1, 0xAE, 0xD7, 0x7D, 0xDF, + 0xAF, 0x16, 0xCB, 0x34, 0x4D, 0xA4, 0x94, 0x6F, 0x5E, 0xBF, 0x5D, 0xCC, + 0xE6, 0xF3, 0xD9, 0x7C, 0x76, 0x3D, 0x5B, 0x2C, 0x56, 0x4A, 0x4A, 0x8C, + 0x50, 0x59, 0xE6, 0x71, 0xA1, 0x9C, 0xDC, 0x9B, 0xEE, 0x4F, 0x8A, 0xE9, + 0xB8, 0x40, 0xC1, 0x23, 0x44, 0x1E, 0xDD, 0x3F, 0xA2, 0x18, 0xAE, 0xE7, + 0xAB, 0xBE, 0xEF, 0x09, 0xC1, 0x9D, 0x34, 0x93, 0xC9, 0x78, 0xBD, 0xAE, + 0x57, 0xAB, 0x35, 0xA5, 0x24, 0x66, 0x45, 0x40, 0x40, 0xCE, 0x39, 0x42, + 0xC8, 0x9B, 0xD7, 0x6F, 0x11, 0x42, 0xCE, 0xFB, 0x5E, 0xE9, 0x00, 0xD0, + 0x75, 0x2A, 0x49, 0x78, 0x55, 0xE6, 0xDA, 0x86, 0x58, 0xD6, 0x1E, 0xA3, + 0x96, 0x94, 0x62, 0x04, 0xC1, 0x3B, 0x4F, 0x29, 0x56, 0x4A, 0x47, 0x0F, + 0x7D, 0xAF, 0xB4, 0xD5, 0xAA, 0xEB, 0xFA, 0xD1, 0x78, 0xFC, 0xE8, 0xD1, + 0x7D, 0xCA, 0xD8, 0x6A, 0xB1, 0xBC, 0x5E, 0xAC, 0x94, 0x0D, 0xCB, 0xE5, + 0x9A, 0x12, 0xE4, 0xBD, 0x6B, 0x3B, 0x55, 0x55, 0x25, 0x42, 0x70, 0xB4, + 0x3F, 0xF9, 0xD1, 0x67, 0x8F, 0x04, 0xA3, 0xCB, 0x55, 0x53, 0x37, 0x7D, + 0xD3, 0x74, 0x5C, 0x08, 0x80, 0x50, 0xD7, 0x0D, 0xE3, 0x02, 0x42, 0x88, + 0x29, 0x92, 0xD1, 0x4C, 0x60, 0x8C, 0x1A, 0x63, 0x11, 0xC2, 0x84, 0x31, + 0x8C, 0x91, 0x71, 0x8E, 0x10, 0x6A, 0x94, 0x89, 0xED, 0xC4, 0x11, 0x42, + 0x91, 0x0B, 0xD7, 0x58, 0xCB, 0x18, 0xEF, 0x7B, 0x59, 0x56, 0xF9, 0xC1, + 0xFE, 0x84, 0x51, 0x5A, 0x37, 0x1D, 0x42, 0x98, 0x10, 0x9C, 0x08, 0xC1, + 0x18, 0x51, 0xDA, 0x08, 0xCE, 0x10, 0xC2, 0x4D, 0xD3, 0x75, 0x5D, 0xDF, + 0x2B, 0xED, 0x9C, 0x8F, 0xA9, 0x70, 0x8C, 0x33, 0x08, 0x60, 0xBD, 0x93, + 0x52, 0xC5, 0x15, 0x70, 0x79, 0x35, 0xFF, 0xE3, 0x3F, 0xFC, 0x8C, 0xD3, + 0xB8, 0xA3, 0xE3, 0xC8, 0x24, 0xB3, 0xE3, 0x32, 0x86, 0x0F, 0xC5, 0x6F, + 0x23, 0x1D, 0x78, 0x48, 0xEE, 0xC5, 0x18, 0x03, 0xC2, 0x78, 0x68, 0x7E, + 0x34, 0x88, 0x46, 0x08, 0xF0, 0xE6, 0xD5, 0xEB, 0x8B, 0xAB, 0xD9, 0xF3, + 0x77, 0xF3, 0x5E, 0x2A, 0xEF, 0x43, 0x22, 0xD8, 0x68, 0x54, 0x18, 0xE3, + 0x92, 0x84, 0x9F, 0x1C, 0x1F, 0x22, 0x00, 0xA9, 0x4C, 0x55, 0xE6, 0x75, + 0xDB, 0xFA, 0xE0, 0x31, 0xC2, 0xD6, 0x3A, 0xCE, 0x58, 0xF4, 0xF7, 0xB5, + 0x6D, 0x37, 0x99, 0x8C, 0xFE, 0xE5, 0x7F, 0xFD, 0x27, 0x7F, 0xFA, 0xC7, + 0x3F, 0xDC, 0x9F, 0x8E, 0xD6, 0x4D, 0xBB, 0x58, 0x35, 0x59, 0x22, 0xAC, + 0x73, 0x2F, 0xDF, 0x9C, 0xAF, 0xEB, 0xAE, 0x69, 0x7A, 0x8C, 0xD1, 0xE9, + 0xFB, 0x8B, 0x4F, 0x9F, 0x3E, 0xFA, 0xEC, 0xC9, 0x7D, 0xA5, 0x4D, 0x9A, + 0x8A, 0xE9, 0xA8, 0xC4, 0x98, 0x3C, 0x7F, 0x75, 0x8A, 0x30, 0xDE, 0x9B, + 0x8C, 0xE2, 0x1D, 0x30, 0x46, 0xEE, 0x1D, 0x4C, 0xAD, 0x73, 0xBD, 0x34, + 0x75, 0xD3, 0xF5, 0xBD, 0x5C, 0xAC, 0xEA, 0xAE, 0x57, 0x42, 0xF0, 0xBD, + 0x49, 0xA5, 0x94, 0xEE, 0x7A, 0x55, 0xD7, 0x9D, 0xF5, 0x2E, 0xD6, 0x07, + 0x49, 0x6D, 0xA4, 0x34, 0xBD, 0x54, 0x3E, 0x80, 0x31, 0x16, 0x20, 0x68, + 0x6D, 0x04, 0xE3, 0xD6, 0x7B, 0xC1, 0x19, 0xE7, 0xDC, 0x58, 0x77, 0x7C, + 0xEF, 0xE0, 0xE2, 0x72, 0x5E, 0x56, 0xC5, 0x83, 0xE3, 0xBD, 0xA8, 0x52, + 0xA1, 0x8D, 0x03, 0x3D, 0x06, 0x34, 0x30, 0xC2, 0x10, 0xC0, 0x3A, 0x17, + 0xB3, 0x0F, 0xB6, 0x8D, 0x80, 0x7D, 0xF0, 0x11, 0xF8, 0x63, 0x3A, 0x7E, + 0xD8, 0x49, 0x7F, 0x85, 0x8D, 0xE0, 0x85, 0x81, 0x11, 0x07, 0x85, 0x00, + 0x3E, 0x84, 0x4D, 0x09, 0x79, 0xD4, 0x7C, 0x21, 0x04, 0xD8, 0xC6, 0x70, + 0x77, 0x73, 0x45, 0x01, 0x80, 0xFC, 0xD9, 0xBF, 0xFD, 0xF9, 0x0D, 0x78, + 0x01, 0x44, 0x05, 0x75, 0x37, 0x79, 0x63, 0x98, 0xD1, 0xA8, 0x7F, 0x6D, + 0x42, 0xAC, 0xDB, 0xD7, 0xBC, 0x0F, 0xDA, 0x39, 0xE7, 0x03, 0xA7, 0x24, + 0x76, 0xA7, 0x65, 0x1B, 0x27, 0x57, 0x3C, 0xB6, 0x46, 0xEC, 0xEF, 0x01, + 0xAF, 0xED, 0x8E, 0xF7, 0xFB, 0x75, 0xB7, 0x1B, 0x6C, 0x1A, 0x86, 0xCD, + 0x0F, 0xA9, 0x75, 0x71, 0x08, 0x37, 0x23, 0xF6, 0x7B, 0xBE, 0x68, 0xD0, + 0x28, 0x3F, 0x84, 0xB1, 0x0F, 0x49, 0xC4, 0x00, 0xA1, 0xC1, 0xE3, 0x46, + 0x07, 0xFF, 0x17, 0x11, 0x9C, 0x09, 0x4E, 0x23, 0x9F, 0x04, 0xDF, 0x78, + 0xF1, 0x18, 0x8D, 0xE4, 0xEB, 0x71, 0xFD, 0x86, 0xBE, 0xAD, 0x9B, 0xBA, + 0x9E, 0xCF, 0xD7, 0x8B, 0xBA, 0xEB, 0x7A, 0xE5, 0xAC, 0xB5, 0xD6, 0xB6, + 0x6D, 0x1B, 0xBC, 0x43, 0xCE, 0x3A, 0x6B, 0x30, 0xC6, 0x21, 0x76, 0x54, + 0x49, 0x92, 0xB6, 0x6D, 0x57, 0x8B, 0x85, 0x37, 0xBA, 0xAD, 0x6B, 0x6B, + 0x8C, 0x35, 0xC6, 0x69, 0x13, 0x13, 0x0B, 0x10, 0x80, 0x56, 0x7A, 0xB9, + 0x58, 0x5C, 0xBC, 0xBF, 0xEC, 0x7A, 0x19, 0x21, 0x95, 0x10, 0x92, 0x24, + 0x1C, 0x63, 0x4C, 0x28, 0x49, 0xD3, 0x54, 0x6B, 0x3B, 0xAA, 0xD2, 0x1F, + 0x7D, 0x7A, 0x9C, 0x08, 0x51, 0x15, 0xC9, 0xE5, 0xF5, 0xBA, 0xD7, 0x6E, + 0x3C, 0x2A, 0x00, 0xFC, 0xC5, 0xD5, 0x72, 0x5C, 0x15, 0x9D, 0x72, 0x1E, + 0x60, 0x34, 0x2E, 0x27, 0xA3, 0xAA, 0xAA, 0x8A, 0xD5, 0xBA, 0x51, 0x4A, + 0x8F, 0xC7, 0x95, 0xD6, 0x4A, 0x6B, 0x13, 0x00, 0x2D, 0x56, 0xAB, 0x34, + 0x4D, 0xAB, 0xAA, 0x94, 0xBD, 0xB4, 0xD6, 0xF9, 0x00, 0xB3, 0xC5, 0x9A, + 0x53, 0x6A, 0xAC, 0xA5, 0x8C, 0x1F, 0x1D, 0x1E, 0xC4, 0xEB, 0x19, 0x25, + 0x84, 0xD0, 0xB2, 0x2C, 0xF7, 0x0F, 0xF6, 0x00, 0xA0, 0xA9, 0x3B, 0x1F, + 0x42, 0x55, 0x16, 0x87, 0x7B, 0x85, 0x0B, 0x98, 0x31, 0xE6, 0xAC, 0x31, + 0x4A, 0x73, 0x4E, 0x5F, 0x9F, 0x5D, 0xD5, 0x75, 0xBB, 0x5A, 0x2E, 0x8D, + 0x31, 0x89, 0x48, 0xEB, 0xB6, 0xFF, 0xE4, 0x93, 0x27, 0xD6, 0xB9, 0x54, + 0xF0, 0xAB, 0xD9, 0x32, 0x49, 0xC4, 0x8B, 0x37, 0xEF, 0xD7, 0x75, 0x8F, + 0x09, 0x4D, 0x92, 0x84, 0x52, 0xB2, 0x5A, 0x37, 0x3E, 0x78, 0xC6, 0x58, + 0xA4, 0x76, 0xC0, 0x08, 0x69, 0x6B, 0x39, 0xA5, 0x01, 0x42, 0xCC, 0xDD, + 0x8E, 0x0E, 0xC9, 0x3C, 0xCB, 0x94, 0xD6, 0x4A, 0x19, 0x6D, 0x6D, 0x92, + 0x08, 0xCE, 0x99, 0x94, 0x8A, 0x31, 0x0E, 0x00, 0x08, 0xA3, 0x58, 0xD4, + 0x35, 0x1E, 0x95, 0x82, 0xB3, 0x4E, 0xAA, 0xC8, 0xEB, 0x9F, 0x26, 0x7C, + 0xB9, 0x6A, 0xBC, 0x0F, 0x94, 0x90, 0xB6, 0xEB, 0x7B, 0x29, 0xAD, 0xF5, + 0x94, 0x92, 0xA6, 0x93, 0xCB, 0x75, 0x97, 0xA7, 0x82, 0x33, 0x16, 0x00, + 0x01, 0xC6, 0xAB, 0x75, 0x0D, 0x10, 0x8A, 0x3C, 0x7F, 0xF2, 0xE0, 0x30, + 0xCF, 0x13, 0x1F, 0xFC, 0xD6, 0xCB, 0xB2, 0x5D, 0x96, 0x9B, 0x6C, 0x80, + 0x21, 0xC7, 0x7B, 0xAB, 0xBF, 0x0F, 0x79, 0x3F, 0x83, 0xD4, 0xDC, 0x88, + 0x04, 0x42, 0x28, 0xC6, 0x55, 0xBF, 0xFE, 0xFA, 0x3B, 0x4A, 0x69, 0xA7, + 0x5D, 0x22, 0x78, 0xA7, 0x74, 0xDB, 0xF5, 0x10, 0xFC, 0x3F, 0xFA, 0xE9, + 0x0F, 0x38, 0xE3, 0x8B, 0xE5, 0x4A, 0x24, 0x1C, 0x21, 0xE8, 0x7B, 0xD9, + 0xF7, 0x52, 0x6A, 0x65, 0x8C, 0xDD, 0xDF, 0x9B, 0x3A, 0xEF, 0x9A, 0xB6, + 0x75, 0xD6, 0x8D, 0x46, 0xD5, 0x1F, 0xFC, 0xF8, 0xE9, 0xE3, 0xFB, 0x87, + 0x00, 0xE1, 0xEB, 0xEF, 0xDF, 0x7C, 0xFB, 0xEC, 0xCD, 0x2F, 0x7F, 0xF3, + 0x5C, 0x2A, 0xFD, 0xC3, 0xCF, 0x1E, 0xBD, 0x7C, 0xF3, 0xDE, 0xFB, 0x70, + 0x7E, 0x71, 0xBD, 0x58, 0xAE, 0x7F, 0xF0, 0xD9, 0x93, 0x7F, 0xF1, 0xCF, + 0xFE, 0x51, 0x5C, 0xBE, 0x9C, 0xB3, 0xE9, 0xA8, 0x20, 0x18, 0xF7, 0x52, + 0x35, 0xAD, 0x3C, 0x3E, 0xDA, 0x8B, 0x05, 0x49, 0xDE, 0x79, 0x4A, 0xC9, + 0xD1, 0xFE, 0xA4, 0x2C, 0xD2, 0x5E, 0xEA, 0x37, 0xA7, 0x97, 0xCF, 0x5E, + 0x9D, 0xCE, 0x97, 0xCD, 0xDE, 0xA4, 0x9A, 0x4E, 0x4A, 0x6D, 0xEC, 0x9B, + 0xD3, 0x4B, 0x91, 0xF0, 0x22, 0x4B, 0x47, 0x45, 0x86, 0x10, 0xD2, 0xDA, + 0x72, 0x41, 0xA5, 0xD2, 0x4D, 0xDB, 0x07, 0x1F, 0xA4, 0x32, 0xFB, 0x93, + 0x51, 0x2F, 0x15, 0xA5, 0xA4, 0x6E, 0x3B, 0xE7, 0x7C, 0x9E, 0x25, 0xFB, + 0x7B, 0x93, 0xD9, 0x62, 0xF9, 0xCD, 0x77, 0xAF, 0xF7, 0xA7, 0xE3, 0x87, + 0x27, 0xFB, 0x31, 0x56, 0x83, 0xB6, 0x1B, 0xC0, 0xB0, 0xF7, 0x7B, 0xEB, + 0xBD, 0x73, 0x03, 0xE2, 0xC4, 0x32, 0xEF, 0x0D, 0xA0, 0x41, 0x80, 0x60, + 0x7D, 0xD8, 0xF4, 0x7D, 0x8F, 0xFD, 0x92, 0x83, 0xF3, 0x10, 0x39, 0xF4, + 0xB7, 0x6D, 0x37, 0x7C, 0x24, 0x95, 0xD8, 0x58, 0xF7, 0x1B, 0x08, 0xBB, + 0x1D, 0x63, 0x19, 0xE6, 0xE5, 0x67, 0x7F, 0xF1, 0xF3, 0x1B, 0xA5, 0x69, + 0x13, 0x4F, 0xDC, 0xB2, 0xC9, 0x6D, 0x41, 0x6D, 0xF7, 0x8D, 0x68, 0x70, + 0x0F, 0x6D, 0x95, 0x38, 0x20, 0x08, 0x31, 0x46, 0x63, 0x19, 0x41, 0xA4, + 0xD2, 0xDF, 0x45, 0xA8, 0x2D, 0x68, 0xDC, 0x05, 0xA9, 0xDD, 0x9F, 0x72, + 0x1B, 0xAD, 0x3E, 0x06, 0x46, 0x1B, 0x6C, 0x1F, 0xEE, 0x38, 0x26, 0x7B, + 0x85, 0xE0, 0xE1, 0x66, 0x88, 0x6E, 0x22, 0xB9, 0xB7, 0xBE, 0x6E, 0x07, + 0xE6, 0x06, 0x38, 0xDC, 0x68, 0xAA, 0xEE, 0xD6, 0x05, 0x68, 0x53, 0x1F, + 0x46, 0x29, 0xA6, 0x94, 0x30, 0x46, 0x18, 0xDB, 0x66, 0xE4, 0x6E, 0xB6, + 0x94, 0x4D, 0x74, 0x46, 0x75, 0xED, 0x6A, 0xB1, 0x38, 0x3F, 0xBF, 0x7E, + 0xF5, 0xFA, 0x7D, 0x08, 0xC8, 0xB9, 0xD0, 0x74, 0x7D, 0x64, 0x2B, 0x51, + 0x5A, 0xB7, 0x6D, 0xDF, 0xB4, 0xBD, 0x07, 0x64, 0xB4, 0xE9, 0xBA, 0x4E, + 0x49, 0xD9, 0xB5, 0x5D, 0x53, 0xD7, 0x7D, 0xD7, 0x6F, 0x39, 0xC8, 0x10, + 0x40, 0xF0, 0x10, 0xA7, 0x09, 0x21, 0x10, 0xA9, 0x00, 0x40, 0x80, 0x11, + 0xE7, 0x8C, 0x60, 0x4C, 0x09, 0x8E, 0xED, 0x1E, 0xFA, 0x5E, 0x45, 0x1B, + 0xD8, 0x3A, 0xF7, 0xE0, 0x68, 0xFC, 0xF4, 0xD1, 0xE1, 0xAB, 0xD3, 0xEB, + 0x97, 0x6F, 0x2F, 0xB3, 0x34, 0xAD, 0x8A, 0xEC, 0xA7, 0x5F, 0x3C, 0xFA, + 0xE6, 0xBB, 0x37, 0x55, 0x95, 0x2B, 0x6D, 0x94, 0x75, 0xE3, 0xF1, 0x08, + 0x42, 0xC8, 0xB2, 0x34, 0x4D, 0x13, 0x9E, 0x08, 0xCE, 0x98, 0x94, 0x7A, + 0x3C, 0x2A, 0xA7, 0xD3, 0x49, 0x92, 0x70, 0x42, 0x68, 0xDF, 0xAB, 0xB6, + 0x6B, 0xB7, 0x8A, 0xBA, 0x73, 0x8E, 0x32, 0x36, 0x9E, 0x8C, 0xF7, 0xF7, + 0xA7, 0xDE, 0x07, 0xCE, 0x59, 0x91, 0x25, 0x22, 0xE1, 0xA3, 0xAA, 0x64, + 0x14, 0x73, 0xCE, 0x0E, 0x0F, 0xF6, 0xA4, 0xD2, 0xFB, 0x7B, 0xE3, 0x7B, + 0x07, 0xA3, 0xF3, 0xCB, 0x65, 0xD7, 0x75, 0x6D, 0x5D, 0x63, 0xF0, 0x4D, + 0xD7, 0x4B, 0xE3, 0xE6, 0xF3, 0xD5, 0xF5, 0x6C, 0xEE, 0x9D, 0x53, 0x4A, + 0x3F, 0x78, 0xF4, 0xD0, 0x68, 0xDD, 0x76, 0x9D, 0xB3, 0x36, 0xCD, 0xD2, + 0xE7, 0xAF, 0xCF, 0x4E, 0x2F, 0x16, 0x4A, 0x5B, 0xC6, 0x98, 0x31, 0xA6, + 0x97, 0x0A, 0x61, 0x24, 0xB5, 0x19, 0x8D, 0x46, 0xD6, 0x58, 0x8C, 0x09, + 0x02, 0xF0, 0x21, 0x20, 0x8C, 0x13, 0x21, 0x62, 0x38, 0x25, 0xC6, 0xBE, + 0x39, 0xE7, 0x94, 0x52, 0x40, 0xA8, 0x97, 0x1A, 0x61, 0x1C, 0x22, 0x3F, + 0x4C, 0x08, 0xBD, 0xD4, 0xD1, 0xAF, 0x84, 0x31, 0xB2, 0xCE, 0xB5, 0x6D, + 0x87, 0x30, 0xDA, 0x9B, 0x8E, 0x21, 0x80, 0x52, 0x9A, 0x33, 0xAA, 0xAD, + 0xED, 0x3A, 0x85, 0x11, 0x52, 0xDA, 0x86, 0x10, 0xA2, 0x9D, 0x9E, 0x24, + 0xC2, 0x05, 0xA8, 0x9B, 0x2E, 0x4F, 0x45, 0x96, 0x25, 0x7D, 0xAF, 0xD6, + 0x75, 0x23, 0x95, 0xD1, 0xC6, 0x7E, 0xF2, 0xE8, 0x68, 0x3A, 0x2E, 0x23, + 0xEF, 0xF3, 0x4D, 0x9E, 0xD1, 0xCE, 0xC6, 0x7A, 0xB3, 0xD3, 0xE3, 0xA1, + 0x2E, 0x39, 0xAE, 0x01, 0xBC, 0xAD, 0x42, 0xDE, 0xAE, 0xE1, 0x00, 0x18, + 0xE3, 0xE0, 0xCC, 0x2F, 0xBF, 0xFC, 0x86, 0x31, 0xDE, 0x49, 0xD3, 0x4A, + 0xC5, 0x18, 0xF3, 0x01, 0x59, 0x6B, 0xAD, 0x35, 0x9C, 0xD1, 0xD9, 0x62, + 0x8D, 0x00, 0x08, 0x02, 0x29, 0x7B, 0x42, 0x48, 0x22, 0x84, 0xF7, 0x2E, + 0xCB, 0x12, 0xEF, 0x82, 0xEC, 0x65, 0x80, 0x90, 0xA4, 0xC9, 0xDE, 0x64, + 0x34, 0x1E, 0xE5, 0x57, 0xD7, 0xCB, 0xFF, 0xFD, 0xFF, 0xFE, 0x4F, 0xE7, + 0x17, 0x73, 0x8A, 0xD1, 0xE5, 0xF5, 0x02, 0x61, 0xFC, 0xC3, 0xCF, 0x1F, + 0x59, 0xE7, 0x47, 0xE3, 0xEA, 0xF4, 0xEC, 0x32, 0x2A, 0xAA, 0x59, 0x9A, + 0xFC, 0xFD, 0xAF, 0xBF, 0xA1, 0x8C, 0x65, 0x59, 0xF2, 0xEC, 0xD5, 0xE9, + 0x6C, 0xBE, 0x6E, 0xDA, 0xF6, 0x60, 0x6F, 0xEA, 0xBC, 0x43, 0x08, 0x25, + 0x9C, 0x3B, 0xE7, 0x8C, 0xB3, 0x09, 0xE7, 0x65, 0x91, 0xC6, 0x52, 0x10, + 0x4A, 0xC9, 0xBB, 0xB3, 0xCB, 0xC5, 0xAA, 0x0E, 0x1E, 0x0E, 0x0F, 0xC6, + 0x47, 0x7B, 0xE3, 0x24, 0x61, 0x75, 0xDB, 0x3B, 0xEB, 0xAA, 0x2A, 0x8F, + 0x04, 0xE8, 0xCE, 0xFB, 0x2C, 0x49, 0x7C, 0x08, 0x9D, 0x94, 0xD7, 0x8B, + 0x55, 0x84, 0x48, 0x21, 0xF8, 0xAA, 0x6E, 0x0E, 0xF6, 0xC6, 0x52, 0xAA, + 0xAF, 0xBE, 0x79, 0x8E, 0x08, 0xFB, 0xE2, 0xE9, 0x89, 0xE0, 0x34, 0x0A, + 0xD4, 0xD6, 0x37, 0x1F, 0x35, 0x29, 0xEF, 0x77, 0xDB, 0xCB, 0x0E, 0x09, + 0x62, 0xCE, 0x85, 0x28, 0xAF, 0x9B, 0x78, 0x1B, 0xC4, 0xE4, 0x09, 0xE7, + 0x7D, 0x64, 0xC9, 0x89, 0xF5, 0xD6, 0x83, 0x7E, 0x82, 0x80, 0x0C, 0xAE, + 0x7F, 0xF0, 0x3E, 0xB8, 0x6D, 0xBA, 0x05, 0x0C, 0x16, 0xD2, 0xAE, 0x2D, + 0x45, 0xFE, 0xCD, 0xFF, 0xF4, 0xEF, 0xB7, 0x02, 0x1F, 0xBF, 0x6F, 0x5B, + 0x22, 0x3E, 0xA8, 0x1B, 0x68, 0x6B, 0x23, 0x0E, 0xB8, 0xBB, 0x99, 0x37, + 0x88, 0x79, 0x19, 0x18, 0x23, 0xCE, 0x68, 0x9E, 0x32, 0xCE, 0x08, 0xA3, + 0x24, 0x26, 0x4C, 0x6E, 0xC1, 0xF1, 0x16, 0x7E, 0xDD, 0x55, 0xBE, 0x3E, + 0x6A, 0xFA, 0xFD, 0x7E, 0xC3, 0x70, 0x80, 0xAC, 0x88, 0x3B, 0x08, 0x6E, + 0xC8, 0x3C, 0x03, 0x6C, 0xCB, 0xA4, 0x6E, 0xE1, 0xE3, 0xF0, 0xED, 0x9B, + 0xFF, 0xB6, 0xDF, 0x12, 0x93, 0x30, 0x76, 0x55, 0xB9, 0xAD, 0xEB, 0x71, + 0x3B, 0x02, 0xBB, 0x30, 0x17, 0x25, 0x0D, 0x21, 0x6C, 0xAC, 0xD1, 0xB2, + 0x7B, 0xF1, 0xFC, 0xC5, 0xF7, 0xCF, 0xDE, 0x7C, 0xFB, 0xFC, 0xF4, 0xF2, + 0x6A, 0x89, 0x09, 0x6D, 0x3B, 0x35, 0x5B, 0xAC, 0x9A, 0xA6, 0x83, 0x10, + 0x94, 0xD2, 0x75, 0xD3, 0x29, 0x6D, 0x43, 0x40, 0xDE, 0x7B, 0xAD, 0x0D, + 0x0A, 0xC1, 0x39, 0xDF, 0x2B, 0x6D, 0x8C, 0xD9, 0x0E, 0x2B, 0x21, 0x84, + 0x27, 0x0C, 0x21, 0x30, 0xDA, 0x02, 0x04, 0xCE, 0x39, 0xC6, 0x78, 0xA8, + 0xDD, 0xA1, 0x94, 0x12, 0xB2, 0xD5, 0x7F, 0x09, 0x21, 0x18, 0x41, 0x08, + 0x3E, 0x78, 0xFF, 0x8F, 0x7F, 0xFA, 0x89, 0x31, 0xE6, 0xAF, 0x7F, 0xF9, + 0xED, 0xA4, 0xCC, 0xF7, 0x46, 0xF9, 0x1F, 0xFC, 0xF0, 0xF1, 0xD5, 0x6C, + 0x31, 0x9B, 0xAF, 0x97, 0xEB, 0x56, 0x64, 0xF9, 0xDE, 0x74, 0x92, 0x65, + 0x89, 0xE0, 0x3C, 0x32, 0x5E, 0x31, 0x4A, 0x8B, 0x32, 0x4B, 0x84, 0x00, + 0x40, 0x52, 0x29, 0xA9, 0x8C, 0x52, 0x3A, 0xF2, 0xBA, 0xC8, 0x5E, 0x61, + 0x82, 0x8B, 0x22, 0x3F, 0x3C, 0xDC, 0xDF, 0x3F, 0xD8, 0x17, 0x22, 0x59, + 0x2C, 0x57, 0x42, 0xF0, 0x32, 0x4F, 0x29, 0x81, 0x2C, 0x11, 0xC1, 0x5B, + 0x8A, 0x11, 0x17, 0x3C, 0x40, 0x38, 0x38, 0x98, 0xEE, 0x8D, 0x8A, 0x77, + 0xEF, 0x2F, 0x8B, 0x3C, 0x4F, 0x04, 0x9F, 0x4E, 0x46, 0x65, 0x99, 0x63, + 0xCA, 0x2E, 0x2E, 0xAF, 0xDB, 0xB6, 0x9D, 0x4E, 0x26, 0x49, 0x92, 0x24, + 0x89, 0x50, 0x4A, 0xE6, 0x59, 0x9A, 0xE7, 0x79, 0xF0, 0xFE, 0xED, 0xBB, + 0xF3, 0xB2, 0xAA, 0xB4, 0x75, 0xD7, 0xB3, 0x65, 0x16, 0xC9, 0x66, 0xA3, + 0x7F, 0x37, 0x84, 0x07, 0xF7, 0xEF, 0xF5, 0x52, 0xC6, 0x6D, 0x36, 0xEE, + 0x9D, 0xDE, 0x1A, 0x00, 0x60, 0x8C, 0x71, 0xCE, 0x03, 0x42, 0x8C, 0x31, + 0xAD, 0x8D, 0x77, 0x2E, 0xCE, 0x38, 0xC6, 0xC8, 0x3A, 0x1B, 0x63, 0x61, + 0xD1, 0xFF, 0xE2, 0x7D, 0x88, 0xDB, 0x67, 0x34, 0x5B, 0xF2, 0x3C, 0x8D, + 0xB4, 0xB1, 0x64, 0xD3, 0x11, 0xD9, 0x18, 0x1B, 0xC1, 0x45, 0x5B, 0x27, + 0x18, 0x2B, 0xB2, 0x34, 0xBA, 0x66, 0x62, 0x5C, 0xA7, 0xEB, 0x25, 0x63, + 0x34, 0xF8, 0xF0, 0xF4, 0xF1, 0xBD, 0x83, 0xFD, 0x49, 0x6C, 0xE1, 0x1E, + 0xF7, 0x30, 0x14, 0x36, 0xFC, 0xCB, 0x5B, 0xE6, 0x04, 0xD8, 0x50, 0xCD, + 0x20, 0x20, 0x51, 0x66, 0x37, 0x66, 0x4D, 0x8C, 0x93, 0x0D, 0x96, 0x07, + 0x46, 0x8C, 0x73, 0xD9, 0x2C, 0xE7, 0xB3, 0x79, 0xD3, 0x9B, 0xF9, 0xBA, + 0xA5, 0x98, 0xF8, 0x30, 0x78, 0x82, 0x10, 0x82, 0xC5, 0xB2, 0x0E, 0x21, + 0x38, 0x6B, 0x13, 0xC1, 0x47, 0x55, 0x91, 0xE7, 0x49, 0x91, 0x25, 0x82, + 0x11, 0xA3, 0xB5, 0xB5, 0x9A, 0x10, 0x22, 0xB5, 0x7D, 0xF2, 0xE8, 0xF8, + 0xD3, 0xC7, 0x27, 0x5D, 0xDB, 0x7F, 0xF9, 0xD5, 0x8B, 0xEB, 0xF9, 0xAA, + 0xEF, 0x65, 0x55, 0x15, 0xA3, 0x71, 0x45, 0x30, 0x7E, 0xF2, 0xE0, 0xDE, + 0xB3, 0x57, 0x67, 0x97, 0x57, 0x33, 0x29, 0xD5, 0x7C, 0xB1, 0x9A, 0x2D, + 0xD6, 0x4D, 0x2B, 0x01, 0x21, 0xA5, 0x4C, 0xD3, 0xF6, 0x8F, 0x1E, 0xDC, + 0xA3, 0x8C, 0x5A, 0xE7, 0xCB, 0x3C, 0xDB, 0xDF, 0x1B, 0x85, 0x10, 0x12, + 0xCE, 0x7D, 0x08, 0xAB, 0xBA, 0xED, 0xA5, 0x96, 0x4A, 0xE7, 0x59, 0xF2, + 0xE0, 0xF8, 0x80, 0x51, 0x5A, 0xE4, 0xE9, 0x62, 0x59, 0x37, 0x5D, 0x5F, + 0xE6, 0xD9, 0x78, 0x94, 0xD7, 0x75, 0x1F, 0x00, 0x2E, 0x67, 0x4B, 0x4C, + 0x30, 0x02, 0xB8, 0x9C, 0xAD, 0x12, 0x21, 0x16, 0xEB, 0x7A, 0xB9, 0x6A, + 0xBA, 0x5E, 0x8F, 0xAB, 0x7C, 0x7F, 0x3A, 0x42, 0x08, 0xF5, 0x4A, 0x75, + 0x4D, 0x7F, 0x76, 0x7E, 0xF5, 0xE0, 0xFE, 0xD1, 0x7C, 0xB1, 0x7A, 0x77, + 0x76, 0xF9, 0xC9, 0xA3, 0x7B, 0x0F, 0x8F, 0xF7, 0x8C, 0xF5, 0x91, 0xC9, + 0x67, 0x2B, 0xD4, 0x30, 0x70, 0x1F, 0x6D, 0xB3, 0xB5, 0xA2, 0x0F, 0x7A, + 0xE8, 0x97, 0xE8, 0x42, 0x04, 0xB8, 0x9B, 0x6C, 0xB2, 0xC1, 0x29, 0xE6, + 0xC0, 0x47, 0xB8, 0x08, 0x28, 0x80, 0x8F, 0xC5, 0x45, 0x91, 0xD2, 0xD5, + 0x3A, 0x3F, 0xE4, 0x8D, 0xA1, 0xB0, 0xC9, 0x59, 0xFB, 0x40, 0xC6, 0x29, + 0xC1, 0x38, 0x62, 0xC2, 0xA6, 0xEA, 0x71, 0xB8, 0x6A, 0x03, 0x18, 0x71, + 0x25, 0x84, 0x80, 0x06, 0xF8, 0x40, 0x1B, 0x6B, 0x95, 0x0E, 0xC0, 0x30, + 0x84, 0x56, 0xA5, 0xB2, 0x21, 0x04, 0xCE, 0xE8, 0xE6, 0x4E, 0x06, 0x4D, + 0x67, 0x37, 0xC1, 0xE4, 0x2E, 0x5A, 0x85, 0x1D, 0xBF, 0xFB, 0x5D, 0x14, + 0xBB, 0xAB, 0xC1, 0xC5, 0x57, 0xE3, 0x1E, 0x3E, 0x40, 0x18, 0x1A, 0x34, + 0xC3, 0x4D, 0x9C, 0xE9, 0xC6, 0x62, 0x0F, 0x1F, 0x4B, 0x45, 0xD9, 0xFD, + 0x9C, 0x30, 0x24, 0x55, 0xF8, 0x4D, 0x5A, 0xDB, 0xE0, 0x58, 0x74, 0x6E, + 0x28, 0x94, 0x8D, 0x29, 0xFD, 0xB0, 0xD1, 0x6C, 0x9D, 0x73, 0x08, 0x53, + 0xAD, 0x65, 0xBD, 0x5A, 0x21, 0x2B, 0xAF, 0x2E, 0xAF, 0xCE, 0xAF, 0xEB, + 0x75, 0x2D, 0x95, 0x71, 0x84, 0x92, 0xC5, 0xE9, 0x25, 0x65, 0x4C, 0x69, + 0x03, 0x21, 0x48, 0xD5, 0x84, 0x10, 0x94, 0x32, 0x98, 0xE0, 0x24, 0x15, + 0x8C, 0x31, 0xD5, 0x4B, 0x40, 0x10, 0x9C, 0xA7, 0x94, 0x00, 0x42, 0x11, + 0xA7, 0x30, 0x42, 0x80, 0x21, 0x84, 0x40, 0x19, 0x49, 0xF3, 0xD4, 0x7B, + 0x1F, 0x87, 0x3A, 0x49, 0x12, 0x84, 0x90, 0xD6, 0x3A, 0xEE, 0xAB, 0x4A, + 0xA9, 0x34, 0x49, 0x10, 0x02, 0xEF, 0x1C, 0x63, 0xD4, 0x28, 0x2B, 0x28, + 0xBA, 0x5C, 0x34, 0x59, 0x92, 0x7E, 0xF2, 0x60, 0xFF, 0xE4, 0x78, 0x3F, + 0xCF, 0xC4, 0xDB, 0x33, 0x59, 0x14, 0xB9, 0x71, 0x6D, 0xC2, 0x19, 0xC6, + 0x88, 0x53, 0x86, 0x22, 0x31, 0x1D, 0x46, 0xC1, 0x07, 0x67, 0x3D, 0xA5, + 0x74, 0x34, 0x2E, 0xC7, 0xE3, 0x6A, 0xB5, 0x6E, 0x30, 0x46, 0xE3, 0x71, + 0x85, 0x00, 0x96, 0xAB, 0x75, 0x9A, 0x24, 0xDA, 0x18, 0xE7, 0x43, 0x64, + 0xF2, 0x9B, 0x8C, 0x2B, 0xC1, 0x88, 0xE0, 0x14, 0xBC, 0xCB, 0x53, 0x51, + 0x37, 0xBE, 0x57, 0x06, 0x23, 0x64, 0x95, 0x62, 0x45, 0xDE, 0xF6, 0xF2, + 0x60, 0x7F, 0xAF, 0xEB, 0x64, 0x99, 0x25, 0xFB, 0x7B, 0xA3, 0x4E, 0x99, + 0x80, 0xE9, 0xE3, 0xC7, 0x0F, 0x29, 0xA3, 0x52, 0xAA, 0x00, 0x1E, 0x02, + 0xF5, 0xCE, 0x72, 0x46, 0x0E, 0xF6, 0xAA, 0x00, 0xF8, 0xE5, 0x9B, 0xB3, + 0xF3, 0xEB, 0x85, 0x36, 0xCE, 0x39, 0xA7, 0x8C, 0x19, 0x8F, 0x4A, 0x42, + 0xB0, 0xEC, 0xFB, 0xAA, 0x2A, 0xB5, 0xB1, 0x01, 0x40, 0x69, 0xCD, 0x29, + 0xF5, 0x21, 0x10, 0x4A, 0x70, 0x08, 0xD6, 0x3B, 0x17, 0x82, 0xF3, 0x5E, + 0x69, 0xAD, 0x95, 0x76, 0x3E, 0x44, 0xFA, 0x8D, 0xBE, 0x6F, 0xB2, 0x54, + 0x48, 0x6D, 0x31, 0xC2, 0x00, 0x88, 0x31, 0xEA, 0x7D, 0x50, 0xCA, 0x10, + 0x82, 0x83, 0x67, 0x8C, 0x51, 0x08, 0x20, 0xA5, 0x12, 0x42, 0x44, 0x4D, + 0x1D, 0x20, 0x34, 0x5D, 0xEF, 0xAC, 0xC3, 0x84, 0xC4, 0x14, 0x67, 0x63, + 0xAD, 0x77, 0x8E, 0x0B, 0x16, 0x21, 0x2C, 0xC6, 0x19, 0x04, 0x67, 0x5A, + 0x9B, 0xB6, 0x93, 0xF8, 0x66, 0xBB, 0x06, 0xEF, 0x03, 0x10, 0xC0, 0x1E, + 0x85, 0xC1, 0x37, 0x1A, 0x21, 0x6D, 0xBB, 0x30, 0x51, 0xDC, 0xC2, 0x87, + 0x86, 0x39, 0xC3, 0xEB, 0x38, 0x84, 0x40, 0x08, 0x09, 0xC1, 0x69, 0xD5, + 0x5F, 0x5E, 0x2D, 0x5A, 0xE5, 0x18, 0xA3, 0x18, 0xC1, 0x0F, 0x9F, 0xDE, + 0xFB, 0xED, 0x8B, 0xF3, 0x00, 0x81, 0x53, 0xB2, 0x3F, 0xCA, 0xDF, 0xF4, + 0x8B, 0xD8, 0x9D, 0xD0, 0x39, 0x97, 0x24, 0x02, 0x13, 0xDC, 0xB5, 0x3D, + 0xE3, 0x8C, 0x31, 0x5A, 0x55, 0xA5, 0x03, 0x38, 0xD8, 0x9B, 0x3E, 0x3E, + 0x39, 0x68, 0xFB, 0xFE, 0xEA, 0x7A, 0x79, 0x3D, 0x5F, 0x12, 0x82, 0x19, + 0x23, 0xCB, 0xD5, 0xBA, 0xE9, 0x3A, 0xEF, 0xEC, 0x6F, 0xBE, 0x79, 0xF1, + 0xDB, 0xAF, 0x9F, 0xC7, 0xAC, 0x63, 0xC1, 0xE8, 0xE5, 0xE5, 0x6C, 0xB9, + 0xAC, 0x47, 0x55, 0xB1, 0x58, 0xAE, 0x7F, 0xF2, 0xA3, 0xCF, 0x92, 0x54, + 0x4C, 0x47, 0x45, 0x22, 0x78, 0x22, 0x98, 0xD6, 0x56, 0x08, 0xA6, 0xAD, + 0xC1, 0x04, 0x0B, 0xCE, 0x97, 0xEB, 0x76, 0x3A, 0x2A, 0x62, 0xC0, 0xFD, + 0xE8, 0x60, 0x7C, 0xB0, 0x57, 0x3D, 0x38, 0x39, 0xA8, 0x9B, 0xAE, 0x2A, + 0xB2, 0xD8, 0x1E, 0x5B, 0x4A, 0x4D, 0x28, 0x9D, 0xCD, 0xEB, 0xCF, 0x1E, + 0x1F, 0x1F, 0x1F, 0x4E, 0x01, 0xA1, 0x2C, 0x13, 0xB3, 0xF9, 0xEA, 0xF2, + 0x7A, 0x31, 0x9B, 0xAF, 0xAE, 0x17, 0x4B, 0x6B, 0x5C, 0x92, 0x88, 0xCF, + 0x9F, 0x3E, 0xFC, 0xFA, 0xBB, 0x97, 0x8B, 0x55, 0xFD, 0x27, 0xFF, 0xF8, + 0xA7, 0xDF, 0xBF, 0x78, 0x7B, 0x71, 0xBD, 0x1C, 0x72, 0x55, 0x3E, 0xA2, + 0xAC, 0xDC, 0x9C, 0x74, 0xCE, 0x01, 0x10, 0x17, 0x13, 0x36, 0x63, 0x2D, + 0x37, 0xF6, 0x3E, 0x44, 0x63, 0x6F, 0xA3, 0x85, 0x79, 0x08, 0x3E, 0x6C, + 0xF8, 0xC6, 0x01, 0x01, 0xF2, 0x0E, 0x3C, 0x38, 0xEB, 0xC3, 0x36, 0xA2, + 0xE9, 0x5D, 0x20, 0x18, 0x21, 0x02, 0x5B, 0x60, 0xD9, 0x24, 0xAE, 0x23, + 0x4A, 0x08, 0x1A, 0x7C, 0x69, 0xF1, 0xF3, 0x11, 0x6C, 0x36, 0xBD, 0x1D, + 0xAE, 0xCC, 0x58, 0xA2, 0x09, 0x10, 0xD0, 0xC0, 0x4D, 0x06, 0x30, 0xF0, + 0x49, 0x22, 0x1C, 0xC9, 0x21, 0x91, 0x73, 0x43, 0x98, 0x4F, 0x2A, 0x43, + 0x09, 0x46, 0x08, 0x08, 0xC1, 0xB1, 0x7F, 0x04, 0xDC, 0x78, 0xEE, 0x07, + 0xA3, 0x30, 0x5A, 0xC7, 0xD1, 0xD7, 0xB0, 0xC5, 0x94, 0xED, 0x79, 0xB4, + 0xC3, 0x36, 0x89, 0x3E, 0x46, 0x8E, 0x1E, 0x99, 0x0F, 0xD0, 0x4E, 0x80, + 0x3C, 0x92, 0xB8, 0x0D, 0xF1, 0xA6, 0x9D, 0x7A, 0xAE, 0xED, 0xB0, 0x0E, + 0x4F, 0x63, 0x26, 0xC9, 0x0D, 0xBF, 0x1D, 0x61, 0x2C, 0x84, 0xA0, 0x63, + 0x81, 0x51, 0xDC, 0x90, 0xA3, 0x8E, 0x16, 0x77, 0xE0, 0xC8, 0x26, 0xC8, + 0x19, 0x05, 0x40, 0xC1, 0x07, 0x00, 0x74, 0x7D, 0x79, 0xF1, 0xEC, 0xDB, + 0x6F, 0x13, 0x4E, 0xF6, 0x46, 0x45, 0x96, 0x70, 0x42, 0xA9, 0x75, 0xDE, + 0x58, 0x23, 0x8D, 0xF1, 0x3E, 0x78, 0xE7, 0x10, 0x42, 0xCE, 0xD9, 0xB8, + 0xBD, 0xA7, 0x69, 0xE2, 0x01, 0x62, 0x9F, 0x70, 0xCC, 0xA8, 0xF7, 0x1E, + 0x41, 0xE0, 0x8C, 0x21, 0xEB, 0x42, 0x08, 0x94, 0x10, 0x00, 0x1F, 0xFC, + 0x4D, 0x46, 0x0C, 0xC6, 0x58, 0x69, 0xED, 0x94, 0x46, 0xD1, 0x41, 0x10, + 0xBC, 0x31, 0x16, 0x42, 0x90, 0xBD, 0xCA, 0xD2, 0x44, 0x6B, 0xE3, 0x9C, + 0x0D, 0x01, 0xC6, 0xE3, 0x42, 0x29, 0x75, 0x75, 0xBD, 0x2A, 0x32, 0xEE, + 0x01, 0x63, 0x04, 0x52, 0x99, 0xA6, 0xD7, 0x52, 0x69, 0xC2, 0x68, 0x27, + 0x15, 0xC2, 0xD8, 0x7B, 0xA8, 0xCA, 0xCC, 0xFB, 0x60, 0x8D, 0x8D, 0xD2, + 0x18, 0xAB, 0xF0, 0x7A, 0xA5, 0x43, 0x08, 0x07, 0xFB, 0x93, 0xAE, 0x97, + 0xCE, 0xF9, 0xA3, 0xA3, 0xC3, 0xA6, 0xED, 0xB0, 0x73, 0x08, 0xC1, 0x68, + 0x54, 0x22, 0x08, 0x04, 0x03, 0x27, 0xB8, 0x2A, 0x52, 0x67, 0xED, 0x64, + 0x94, 0x4F, 0x46, 0xF9, 0xCB, 0x77, 0x97, 0x89, 0xA0, 0x16, 0xF9, 0x34, + 0x15, 0x4D, 0xDB, 0x13, 0xF2, 0xFF, 0x11, 0xF6, 0x5E, 0x4D, 0x92, 0x25, + 0x59, 0x7A, 0xD8, 0x39, 0x7E, 0x5C, 0x5C, 0x15, 0x32, 0x45, 0x65, 0x55, + 0x75, 0x55, 0x77, 0xB5, 0x9E, 0x1E, 0xB1, 0x33, 0x3B, 0x8B, 0x01, 0x07, + 0xA0, 0x00, 0xD7, 0x40, 0x33, 0x3E, 0xF1, 0x85, 0xBF, 0x82, 0x86, 0x15, + 0xC0, 0xE2, 0xAF, 0xF0, 0x99, 0xFF, 0x81, 0x2F, 0x34, 0xD2, 0xC0, 0x25, + 0x09, 0xEE, 0x12, 0xB6, 0x8B, 0xDD, 0xC5, 0x08, 0xB4, 0x98, 0x16, 0x25, + 0xBA, 0x44, 0x56, 0xEA, 0x90, 0x57, 0xB9, 0x3A, 0x7C, 0xF0, 0x1B, 0x51, + 0xD9, 0x33, 0x8B, 0x45, 0x58, 0x59, 0x5A, 0x55, 0x66, 0x56, 0x44, 0xDC, + 0x1B, 0xEE, 0xC7, 0x8F, 0xF8, 0x84, 0xBC, 0x7F, 0xEF, 0xA8, 0x30, 0xB4, + 0xDA, 0xB4, 0xD7, 0x8B, 0x55, 0x53, 0x37, 0x4D, 0xDB, 0x6F, 0x36, 0x5B, + 0xE7, 0x7C, 0x08, 0x11, 0x91, 0xEF, 0x1C, 0x1F, 0xAE, 0x36, 0xDB, 0x8B, + 0xB3, 0xCB, 0xD9, 0xC1, 0x3C, 0x02, 0xB4, 0x5D, 0x1F, 0x23, 0x24, 0x2E, + 0xC7, 0xDD, 0x93, 0x3B, 0x21, 0x86, 0xD3, 0xD3, 0xB3, 0xE9, 0x64, 0xB2, + 0xAD, 0x1B, 0xE7, 0x43, 0xD7, 0x75, 0xBA, 0xAA, 0x04, 0xA2, 0xB3, 0x2E, + 0xE5, 0x3D, 0x7D, 0x6F, 0x15, 0x11, 0x30, 0x28, 0xAD, 0xC1, 0x7B, 0x22, + 0xEA, 0x7B, 0x9B, 0xA4, 0xEB, 0x80, 0xB1, 0xED, 0xED, 0xF1, 0xD1, 0x4C, + 0x29, 0xD9, 0x75, 0x76, 0xED, 0x9A, 0xBE, 0xB7, 0xC0, 0xCC, 0x1C, 0x95, + 0x52, 0xDE, 0x07, 0xEB, 0x42, 0xC2, 0xB2, 0x23, 0x8A, 0x84, 0x95, 0xD7, + 0xBB, 0x73, 0x54, 0x29, 0x72, 0xD6, 0x39, 0xCB, 0x4A, 0xC9, 0x14, 0x74, + 0xAC, 0xF5, 0xDE, 0x3A, 0x64, 0x4E, 0xD6, 0x1E, 0xFB, 0x1A, 0x42, 0x08, + 0x8E, 0x31, 0x82, 0xD8, 0xEF, 0x44, 0xDE, 0xA1, 0x3A, 0x91, 0xE3, 0xED, + 0x34, 0x1F, 0xDF, 0xFC, 0xC6, 0x00, 0x79, 0xF3, 0x9F, 0x7D, 0xF9, 0xE4, + 0xEB, 0x6F, 0x5E, 0x14, 0x5A, 0xC4, 0x08, 0x77, 0x8E, 0x46, 0xCB, 0x75, + 0xAD, 0xB5, 0x6C, 0x7B, 0xC7, 0x00, 0xD3, 0x2A, 0xCB, 0x14, 0xC5, 0xC8, + 0x4A, 0xA9, 0x54, 0x1A, 0xA3, 0x40, 0x08, 0x50, 0x77, 0x76, 0x3E, 0x19, + 0x19, 0xA3, 0x7B, 0xE7, 0x3E, 0xF9, 0xE8, 0xBD, 0xE9, 0xB8, 0x3C, 0xBB, + 0xB8, 0xBE, 0x5E, 0xAC, 0x9B, 0xBA, 0x59, 0xAD, 0xD6, 0x49, 0x4F, 0xA9, + 0xEB, 0x7A, 0x72, 0xEE, 0xE5, 0x2B, 0xFB, 0xFA, 0xEC, 0x4A, 0x6B, 0x59, + 0x15, 0xE3, 0xD5, 0xBA, 0xEF, 0x3A, 0x5B, 0xE4, 0x66, 0x53, 0xB7, 0xCE, + 0x7A, 0xAD, 0x95, 0x92, 0xF4, 0xBD, 0xF7, 0x1E, 0xF4, 0xBD, 0x8D, 0x15, + 0x4B, 0x25, 0xA5, 0x10, 0x24, 0x44, 0x6F, 0x6D, 0x55, 0xE6, 0xD3, 0x71, + 0xE1, 0x9D, 0x97, 0x44, 0x29, 0xAC, 0x0B, 0x44, 0xA5, 0x54, 0x6E, 0x4C, + 0x55, 0x64, 0x52, 0xD2, 0xCD, 0x62, 0x5D, 0x64, 0xBA, 0x6B, 0x7B, 0x81, + 0xC2, 0xB9, 0xEE, 0xDB, 0x57, 0x17, 0x77, 0x8F, 0xE7, 0x5D, 0x6F, 0xCB, + 0x32, 0x7B, 0xEF, 0xED, 0x7B, 0x0F, 0xEF, 0x1F, 0x2F, 0x56, 0xF5, 0xD3, + 0xE7, 0xA7, 0x9B, 0x4D, 0x33, 0x9F, 0x4D, 0x84, 0x14, 0x3F, 0xFE, 0xE1, + 0x47, 0xCF, 0x5E, 0x9C, 0xD5, 0x6D, 0x37, 0x1A, 0x97, 0xAF, 0xCE, 0x6F, + 0xFA, 0xDE, 0x49, 0x12, 0xBC, 0x43, 0x38, 0xA4, 0xE4, 0x21, 0x6D, 0xDF, + 0x5D, 0x55, 0xB8, 0x7B, 0x70, 0x8C, 0x8C, 0x00, 0x71, 0x80, 0x40, 0x44, + 0xDE, 0x25, 0x4C, 0x30, 0x4C, 0x36, 0x71, 0xB8, 0xA7, 0x1C, 0x21, 0xD5, + 0x9B, 0x00, 0xC0, 0x28, 0xE2, 0xBE, 0x0E, 0x43, 0xE0, 0x08, 0x12, 0x21, + 0xD1, 0x25, 0x79, 0x40, 0x1D, 0x08, 0x12, 0x48, 0x7F, 0xF4, 0xC7, 0x7F, + 0x46, 0x02, 0x45, 0xE2, 0x8A, 0xC3, 0x40, 0x9C, 0xDA, 0x4D, 0xA0, 0x87, + 0x4D, 0x0F, 0xBB, 0xC6, 0xE7, 0x6F, 0xA1, 0x4E, 0x85, 0x40, 0x25, 0x84, + 0x56, 0x84, 0x3B, 0x8D, 0xD9, 0x3E, 0xAD, 0x66, 0x00, 0x44, 0x91, 0x84, + 0x7A, 0xD3, 0x95, 0x38, 0xE7, 0xD2, 0xD7, 0xB6, 0xED, 0xAD, 0x75, 0x6D, + 0xDB, 0x47, 0x8E, 0x49, 0xD7, 0x75, 0x1F, 0xA1, 0xF6, 0x84, 0xC7, 0xDF, + 0xCD, 0xA1, 0xFE, 0x9E, 0x7F, 0x22, 0xBE, 0x51, 0xBD, 0xBD, 0x95, 0x76, + 0xA5, 0xBF, 0xEC, 0x79, 0x91, 0xB7, 0xB9, 0x04, 0xB8, 0xAB, 0x9C, 0xF7, + 0x38, 0xC6, 0x14, 0xDD, 0xD2, 0x3F, 0x95, 0x4A, 0xDF, 0x41, 0xC4, 0x94, + 0xF4, 0xA5, 0xB1, 0xD4, 0x20, 0x45, 0x3B, 0x88, 0x6D, 0x5D, 0x5D, 0x7C, + 0xF1, 0xEB, 0x5F, 0x9C, 0x4C, 0x0B, 0x85, 0xB0, 0x69, 0x3A, 0x40, 0xF1, + 0xE2, 0xF4, 0x66, 0xDB, 0xB4, 0xA4, 0x14, 0x82, 0x60, 0x1C, 0xBC, 0x38, + 0x9D, 0xF5, 0xA9, 0x42, 0x91, 0x4A, 0xFA, 0xC0, 0xDE, 0x85, 0x04, 0x2C, + 0x48, 0xA2, 0x7A, 0x31, 0x70, 0x0C, 0x11, 0x85, 0xC8, 0x33, 0x23, 0x25, + 0x01, 0xC2, 0x90, 0x39, 0x73, 0x0C, 0x21, 0x20, 0x40, 0x08, 0xC1, 0x5A, + 0x17, 0x63, 0x4C, 0x83, 0xC2, 0x34, 0x20, 0xCB, 0x33, 0x63, 0xAD, 0x8B, + 0x91, 0x11, 0xC4, 0x5B, 0x47, 0x63, 0x8E, 0xB1, 0x0F, 0x1C, 0x19, 0x95, + 0x14, 0x1F, 0xBD, 0xF7, 0xE0, 0xAB, 0x67, 0x67, 0xA7, 0xAF, 0xAF, 0xAB, + 0x51, 0xD5, 0xB4, 0xB6, 0xAA, 0x8A, 0x3C, 0xCF, 0xAD, 0xB5, 0x75, 0xD3, + 0x4A, 0x12, 0xBD, 0xB5, 0x4A, 0xC9, 0xA6, 0xED, 0x10, 0x99, 0x23, 0x87, + 0x10, 0xDA, 0xAE, 0x23, 0x21, 0xFA, 0xDE, 0xF6, 0xD6, 0x21, 0x40, 0x9E, + 0x9B, 0xA2, 0xC8, 0x11, 0x85, 0x24, 0xC1, 0x31, 0x08, 0x44, 0xA3, 0xA8, + 0xC8, 0x54, 0x55, 0xE5, 0x45, 0x6E, 0x48, 0x4A, 0x44, 0x94, 0x24, 0x8B, + 0xAA, 0x12, 0x42, 0x18, 0x63, 0xCA, 0xC2, 0x70, 0xB0, 0xCC, 0xF1, 0xF9, + 0xAB, 0x8B, 0xAA, 0x2C, 0x8D, 0x96, 0x8C, 0xB8, 0xDE, 0xD4, 0xE3, 0xF1, + 0xE8, 0xF8, 0xF8, 0x50, 0x69, 0xBD, 0x5A, 0x6D, 0x1E, 0xBD, 0x7D, 0xBF, + 0xCC, 0xF5, 0xB7, 0xA7, 0x57, 0x26, 0xCB, 0xD6, 0xEB, 0x6D, 0x72, 0xDB, + 0x8D, 0x91, 0x8F, 0x8F, 0x0F, 0x1E, 0x3E, 0xB8, 0xFF, 0xF2, 0xD5, 0xE9, + 0xE1, 0xC1, 0x41, 0x0C, 0x51, 0x12, 0x39, 0xE7, 0x52, 0x21, 0xA0, 0x24, + 0x09, 0x49, 0x3E, 0x84, 0x18, 0x62, 0x55, 0xE4, 0x59, 0x9E, 0x31, 0x00, + 0x0F, 0x22, 0x2C, 0xEC, 0xBD, 0x8F, 0x91, 0x49, 0x92, 0x94, 0x54, 0xE4, + 0x86, 0x99, 0x89, 0x04, 0x09, 0xE1, 0x43, 0x20, 0x31, 0x2C, 0xA1, 0x10, + 0x93, 0x24, 0xB7, 0xC8, 0x32, 0xE3, 0x43, 0xD8, 0x6C, 0x6A, 0xE7, 0x3D, + 0x33, 0xC7, 0x10, 0x99, 0xC1, 0x28, 0x09, 0xCC, 0x44, 0x62, 0x32, 0x2E, + 0x6F, 0x96, 0x5B, 0x8E, 0x8C, 0x08, 0xE3, 0x51, 0x15, 0x9C, 0x3F, 0x3C, + 0x98, 0xBC, 0xFF, 0xE8, 0x7E, 0x1A, 0xB6, 0xEC, 0x97, 0xD0, 0x9B, 0xBE, + 0xCA, 0x77, 0x9B, 0x21, 0x88, 0xFB, 0xF6, 0xFE, 0x6D, 0x82, 0x0A, 0x30, + 0xF3, 0xBF, 0xF9, 0xB7, 0x7F, 0xFB, 0xCB, 0x4F, 0x9F, 0xBC, 0xFF, 0xE8, + 0xAD, 0xA6, 0x69, 0xAB, 0x5C, 0x8F, 0x47, 0xC5, 0xB7, 0xAF, 0xAE, 0x98, + 0x79, 0xDB, 0x58, 0xEB, 0xC3, 0xC9, 0xC1, 0x98, 0x08, 0x2F, 0x97, 0x35, + 0x87, 0x98, 0xE6, 0xC2, 0x5D, 0xD7, 0x7B, 0x1F, 0x26, 0x93, 0x51, 0x9E, + 0x65, 0x37, 0x8B, 0x95, 0x10, 0xA8, 0xA4, 0x3C, 0x7D, 0x7D, 0xF9, 0xE4, + 0xDB, 0x97, 0x37, 0x37, 0xCB, 0xCD, 0xB6, 0x1E, 0x15, 0xD9, 0x6C, 0x3A, + 0x9A, 0x8C, 0x8A, 0x3C, 0x33, 0xDB, 0xA6, 0xF5, 0xDE, 0x23, 0x8A, 0x71, + 0x55, 0xA6, 0x03, 0x72, 0x36, 0x19, 0x09, 0x84, 0xD4, 0xBA, 0x3A, 0x38, + 0x98, 0xAE, 0x36, 0xDB, 0x2C, 0xD3, 0x52, 0xD2, 0x5F, 0xFE, 0xF5, 0xAF, + 0xF3, 0x4C, 0x9B, 0x4C, 0x3B, 0x17, 0x46, 0x55, 0x9E, 0x66, 0x53, 0xA9, + 0xB6, 0xD2, 0x4A, 0x09, 0x14, 0x69, 0x77, 0xC7, 0x10, 0xDA, 0xDE, 0x86, + 0x10, 0x92, 0x06, 0x99, 0x0B, 0x51, 0x49, 0x19, 0x42, 0xB4, 0xCE, 0x3F, + 0x7E, 0xF6, 0xEA, 0xC5, 0xAB, 0x8B, 0xDE, 0x86, 0x4C, 0x2B, 0xAD, 0x55, + 0x66, 0xD4, 0x7C, 0x3A, 0xFE, 0xE0, 0xD1, 0x83, 0xB2, 0xC8, 0xEA, 0xBA, + 0x7D, 0xF5, 0xFA, 0xB2, 0x28, 0x32, 0x63, 0xF4, 0xC5, 0xC5, 0xF5, 0xE7, + 0x5F, 0x3E, 0xB9, 0x77, 0xF7, 0xE8, 0x9D, 0xB7, 0xEE, 0x38, 0x17, 0x70, + 0x27, 0x4E, 0x43, 0x83, 0x02, 0xCF, 0x1E, 0x09, 0xB0, 0xBB, 0x8D, 0x3B, + 0x22, 0xA3, 0x40, 0xA4, 0x24, 0x76, 0xBD, 0x6B, 0x11, 0xF3, 0x6E, 0x5F, + 0xEF, 0x5B, 0xF4, 0x91, 0x39, 0x30, 0x02, 0xBE, 0xF9, 0x44, 0x00, 0x40, + 0xA0, 0xD8, 0x4F, 0x62, 0xF6, 0xAD, 0x70, 0xA5, 0x48, 0x2B, 0x49, 0x7F, + 0xFC, 0x27, 0x7F, 0x06, 0x3C, 0xBC, 0x04, 0xE2, 0xAD, 0x9F, 0xEF, 0x22, + 0xD8, 0x77, 0x43, 0xC9, 0x40, 0x27, 0x10, 0x28, 0x54, 0xCA, 0xC5, 0x86, + 0x7B, 0x04, 0x24, 0x70, 0x47, 0x26, 0x8F, 0x3E, 0x0C, 0xD6, 0x4A, 0xDE, + 0x0F, 0xDD, 0x56, 0xE7, 0x42, 0x8C, 0xEC, 0x7D, 0x88, 0x91, 0x7D, 0x88, + 0x69, 0x39, 0xCA, 0x61, 0xE6, 0xFD, 0x26, 0x6C, 0xDD, 0x1E, 0xA9, 0xEE, + 0x57, 0xC9, 0xED, 0xAF, 0x6F, 0x62, 0xD9, 0xF0, 0x06, 0xDF, 0x1C, 0xA4, + 0xB7, 0x53, 0xBF, 0xFD, 0x4D, 0xF9, 0x7B, 0xC3, 0xDC, 0xFE, 0xEF, 0xB7, + 0x30, 0xFD, 0x09, 0x34, 0x04, 0x44, 0x89, 0xEC, 0x4A, 0x52, 0x91, 0x18, + 0xA6, 0xEC, 0x18, 0x23, 0x08, 0x01, 0x24, 0xE5, 0xD5, 0xE9, 0xF3, 0x66, + 0xBD, 0xD6, 0x26, 0xD7, 0x4A, 0xF6, 0x36, 0xD4, 0xAD, 0xBD, 0x59, 0xB7, + 0x48, 0xC4, 0x11, 0x7C, 0x08, 0x4A, 0x6B, 0x00, 0x00, 0x06, 0x12, 0x98, + 0xC8, 0x25, 0x52, 0xA9, 0xAE, 0xB3, 0x31, 0xB2, 0x54, 0x52, 0x48, 0x91, + 0x72, 0x3D, 0xEF, 0x3C, 0x00, 0x0B, 0xC1, 0xC1, 0xFB, 0x94, 0x89, 0x58, + 0xE7, 0x53, 0x46, 0x9A, 0x02, 0x2B, 0x49, 0xE9, 0x77, 0x09, 0x33, 0xA2, + 0x08, 0x21, 0xDD, 0xBA, 0xD8, 0xF5, 0xCE, 0xF9, 0xB0, 0x6D, 0xBB, 0xC3, + 0x71, 0xAE, 0x15, 0x09, 0xA9, 0x5C, 0xE0, 0xB7, 0xEF, 0x1F, 0x97, 0xA3, + 0xD1, 0x5F, 0xFD, 0xCD, 0xA7, 0x3F, 0xF9, 0xE1, 0x07, 0x7F, 0xF3, 0x1F, + 0xBE, 0x70, 0xCE, 0xEB, 0x4C, 0xE7, 0x99, 0x79, 0x7D, 0x76, 0x51, 0x96, + 0x05, 0xA2, 0x88, 0x31, 0x4A, 0xA9, 0x9A, 0xB6, 0xDB, 0x36, 0x6D, 0xD3, + 0xB4, 0xD6, 0xB9, 0xC8, 0x20, 0x08, 0x09, 0x29, 0xCB, 0xB2, 0x10, 0xE2, + 0xF5, 0x62, 0xD5, 0x34, 0xAD, 0x52, 0x04, 0x1C, 0xBD, 0x73, 0x44, 0xA8, + 0x15, 0x65, 0x5A, 0x06, 0x1F, 0xA4, 0x94, 0x11, 0xD0, 0x68, 0x29, 0xA4, + 0x2A, 0x8A, 0x42, 0x4A, 0x22, 0xC2, 0x83, 0xE9, 0x28, 0xCB, 0xF4, 0x9F, + 0xFF, 0xDB, 0xBF, 0xB9, 0xBA, 0x59, 0xDF, 0x3D, 0x39, 0x32, 0x59, 0xBE, + 0x6D, 0x7B, 0xA3, 0xD5, 0xB6, 0x6E, 0x80, 0x24, 0x0A, 0x59, 0x16, 0xF9, + 0xA8, 0xCC, 0xE7, 0x47, 0x87, 0x9F, 0x7E, 0xF9, 0x74, 0x3A, 0x9D, 0xCC, + 0x67, 0x93, 0xB6, 0xED, 0x11, 0x91, 0x39, 0x3A, 0xE7, 0x1E, 0x3C, 0xB8, + 0xB7, 0x5A, 0x6D, 0xAE, 0x6E, 0x16, 0x3E, 0x84, 0xAE, 0xEB, 0xA4, 0xA4, + 0xBE, 0x77, 0xC0, 0x3C, 0x9D, 0x4E, 0x42, 0x8C, 0xBD, 0xF3, 0x44, 0x94, + 0x69, 0x15, 0x62, 0xE8, 0xBA, 0x3E, 0xDD, 0x01, 0x00, 0x24, 0x21, 0x7C, + 0x88, 0x42, 0x88, 0xD9, 0x6C, 0x12, 0x42, 0xDC, 0x6E, 0xDB, 0xA6, 0xEB, + 0xA5, 0x24, 0xE0, 0xE4, 0x57, 0xC2, 0x00, 0x98, 0x56, 0xB9, 0x0F, 0x51, + 0x6B, 0x9D, 0xE8, 0x5F, 0x99, 0x51, 0x77, 0x0E, 0xA7, 0xE3, 0x2A, 0x47, + 0x84, 0xB6, 0xEF, 0x99, 0x81, 0x88, 0xF2, 0xCC, 0x24, 0x99, 0xEF, 0x18, + 0xD9, 0x68, 0x95, 0x50, 0xB2, 0xDF, 0xFB, 0xF0, 0xED, 0xFD, 0x09, 0x7A, + 0x7B, 0xA9, 0xEC, 0x17, 0xFF, 0xAE, 0xE5, 0x3F, 0x74, 0x4E, 0x6F, 0x3F, + 0x98, 0x59, 0x6B, 0x75, 0xFA, 0xFA, 0xE2, 0x2F, 0xFE, 0xFA, 0x33, 0x10, + 0xF4, 0xD1, 0xDB, 0x87, 0xCF, 0x5E, 0x5D, 0x8D, 0x0A, 0x53, 0x18, 0xFD, + 0xE4, 0xE5, 0x45, 0xA6, 0xF5, 0xA6, 0x75, 0x91, 0xF9, 0xC1, 0x9D, 0x99, + 0xF3, 0xE1, 0x6A, 0xD9, 0x70, 0x64, 0x44, 0x4C, 0xF3, 0xB7, 0x3C, 0xCF, + 0x9C, 0x73, 0x8B, 0xE5, 0x0A, 0x00, 0xEA, 0xA6, 0x7D, 0x7D, 0x76, 0x71, + 0xBD, 0x58, 0x35, 0x6D, 0xEF, 0x9C, 0x13, 0x02, 0x8C, 0xD1, 0x44, 0xA2, + 0xC8, 0x4D, 0x96, 0x69, 0x12, 0x88, 0xC0, 0x21, 0x86, 0x94, 0x58, 0x3D, + 0xB8, 0x7F, 0xB7, 0xED, 0x7A, 0x21, 0xF0, 0xFE, 0xBD, 0x13, 0x12, 0x08, + 0x31, 0x30, 0x07, 0xA5, 0xCD, 0x66, 0xDB, 0xFE, 0xE2, 0xD7, 0x5F, 0x7E, + 0xF5, 0xF8, 0x45, 0xDB, 0xD9, 0x2C, 0xD3, 0x89, 0xC6, 0x8B, 0x88, 0x46, + 0x2B, 0x18, 0x76, 0x2B, 0x13, 0x11, 0xC7, 0x98, 0x2E, 0x2B, 0x46, 0x3E, + 0xBB, 0x5C, 0x34, 0x6D, 0xFF, 0xD5, 0xE3, 0x17, 0x0C, 0x5C, 0xE4, 0x19, + 0x00, 0x74, 0x7D, 0xAF, 0x95, 0x6E, 0xFB, 0xFE, 0xF2, 0x7A, 0xB5, 0x5C, + 0x6D, 0xF3, 0x3C, 0x23, 0x12, 0x69, 0x79, 0x1E, 0x4C, 0xC7, 0x4A, 0xAB, + 0x6D, 0xDD, 0xD6, 0x75, 0xDB, 0x76, 0x5D, 0x59, 0x14, 0xCE, 0xC7, 0xEF, + 0xBD, 0xFF, 0x40, 0x52, 0xE2, 0x56, 0xBF, 0xD1, 0xBD, 0x18, 0x6E, 0xE3, + 0xD0, 0xB1, 0xC2, 0xDD, 0x7A, 0x46, 0xD8, 0x81, 0x37, 0xE5, 0x80, 0x57, + 0x81, 0x24, 0x2D, 0xB1, 0x6F, 0xA6, 0x0D, 0x47, 0x48, 0x1A, 0xA7, 0xC0, + 0xF0, 0x24, 0xDF, 0xFD, 0x68, 0xC4, 0x4E, 0x02, 0x90, 0x89, 0x44, 0xA6, + 0xA5, 0x56, 0x44, 0xFF, 0xD3, 0xBF, 0xF8, 0x97, 0x69, 0x40, 0x30, 0xD4, + 0x53, 0xB8, 0x93, 0xC7, 0xE6, 0xFD, 0x47, 0x88, 0xBC, 0x23, 0xE5, 0x20, + 0x82, 0x00, 0x90, 0x83, 0xC7, 0x2D, 0x08, 0x1A, 0x4E, 0xA7, 0xDD, 0x90, + 0x1A, 0x01, 0x99, 0x23, 0x20, 0x60, 0x59, 0x18, 0x63, 0xD4, 0x3E, 0xC4, + 0x24, 0x95, 0x18, 0x29, 0x85, 0x94, 0xD2, 0x18, 0x95, 0x67, 0x26, 0x31, + 0xE9, 0x6E, 0x8F, 0x02, 0x52, 0x00, 0x12, 0x3B, 0xD3, 0xD3, 0x7D, 0xE4, + 0xDA, 0x2F, 0x97, 0x5B, 0xAB, 0xEA, 0xCD, 0x55, 0xFD, 0xF6, 0x69, 0x79, + 0xBB, 0x35, 0x7E, 0x6B, 0xC5, 0xFD, 0x76, 0x42, 0xF7, 0x5D, 0x10, 0x59, + 0xBC, 0xA5, 0x68, 0x36, 0xDC, 0xF1, 0x21, 0x26, 0x02, 0x22, 0x92, 0x10, + 0x92, 0x24, 0x11, 0x6D, 0x6E, 0x2E, 0xFA, 0xDE, 0x26, 0xA3, 0x2A, 0x1F, + 0x42, 0xDF, 0x87, 0x57, 0x97, 0x6B, 0x00, 0x68, 0xDB, 0x5E, 0x84, 0x70, + 0x21, 0x95, 0x00, 0x00, 0x20, 0x00, 0x49, 0x44, 0x41, 0x54, 0x6B, 0x9D, + 0xC0, 0xA8, 0xCC, 0xB1, 0x6D, 0x3B, 0xEF, 0xBD, 0xD6, 0x2A, 0x02, 0x04, + 0x3F, 0xA0, 0xC6, 0xD3, 0x94, 0x20, 0x86, 0x40, 0x02, 0xB5, 0x94, 0x29, + 0xDE, 0x71, 0x88, 0x91, 0xE3, 0xBE, 0xB0, 0x55, 0x92, 0xD2, 0x1D, 0x23, + 0x49, 0xCC, 0xD1, 0xF9, 0xE0, 0xBD, 0xB7, 0xD6, 0x87, 0x37, 0x76, 0x2A, + 0x22, 0x84, 0xF0, 0xDE, 0x83, 0x83, 0x3B, 0xC7, 0x07, 0xDB, 0xD6, 0x5E, + 0x5C, 0xAF, 0x7E, 0xF2, 0xC3, 0xF7, 0xFE, 0xF6, 0x97, 0x5F, 0x4D, 0xC7, + 0x23, 0xEF, 0xE3, 0xB7, 0x2F, 0xCF, 0x85, 0x40, 0x49, 0x12, 0x01, 0x67, + 0xB3, 0x29, 0x33, 0xB4, 0x6D, 0x9F, 0xE7, 0x99, 0x31, 0x46, 0x4A, 0x42, + 0x80, 0xB2, 0x28, 0x92, 0x35, 0x4C, 0xDB, 0xF6, 0xEB, 0xF5, 0x66, 0xBD, + 0xD9, 0x32, 0x80, 0xED, 0xFB, 0xC4, 0xF3, 0x69, 0x9B, 0x26, 0xCF, 0x34, + 0xA1, 0x98, 0x8C, 0x0A, 0x67, 0x9D, 0x31, 0xAA, 0xAC, 0xAA, 0xF3, 0xCB, + 0x9B, 0xB3, 0x8B, 0x25, 0x49, 0xE9, 0xDA, 0xFA, 0xE6, 0xE2, 0xF2, 0x9D, + 0x47, 0x0F, 0x9C, 0x73, 0xFF, 0xCF, 0x5F, 0xFC, 0xDD, 0xAB, 0xD3, 0xF3, + 0xA3, 0xA3, 0xA3, 0xBA, 0x69, 0x6F, 0x16, 0xAB, 0xB7, 0x1F, 0xDC, 0x17, + 0x52, 0x1E, 0x1E, 0x1E, 0x5E, 0xDF, 0x2C, 0x7D, 0xE4, 0xD1, 0xA8, 0x22, + 0xA5, 0x9E, 0x3E, 0x7F, 0xBD, 0x5C, 0x2C, 0xAF, 0xAE, 0x17, 0x07, 0x07, + 0x33, 0xEB, 0x5C, 0x12, 0x08, 0x62, 0x00, 0xAD, 0xB5, 0x24, 0x61, 0x5D, + 0x58, 0x2E, 0x57, 0x31, 0x44, 0xAD, 0x55, 0x2A, 0xF4, 0x06, 0x73, 0x2D, + 0x00, 0x29, 0xA5, 0xD1, 0x0A, 0x19, 0x92, 0x30, 0xBF, 0x75, 0xDE, 0x85, + 0x28, 0x48, 0x30, 0x73, 0x9E, 0xE7, 0xE9, 0x5C, 0xEC, 0x7B, 0x17, 0x23, + 0x77, 0xBD, 0x8D, 0x91, 0xA5, 0x54, 0xC6, 0x64, 0x21, 0x04, 0xE7, 0x5D, + 0x3A, 0x29, 0x7B, 0x6B, 0xD3, 0xF0, 0x5E, 0x49, 0x9A, 0x4F, 0x4B, 0x66, + 0x36, 0x46, 0x8F, 0xAA, 0xA2, 0xEB, 0xAD, 0xF3, 0x71, 0x32, 0x2A, 0x36, + 0xDB, 0x36, 0x81, 0x75, 0x24, 0x11, 0x11, 0x8E, 0xAB, 0x32, 0x05, 0xB2, + 0xDB, 0x8B, 0x64, 0x58, 0x6F, 0xE9, 0x2C, 0x1F, 0x8A, 0xCB, 0x37, 0xAB, + 0xF1, 0x36, 0x82, 0x89, 0x99, 0xA5, 0x94, 0x5F, 0x7E, 0xF5, 0xF4, 0xCB, + 0xC7, 0x2F, 0x3E, 0x7C, 0x74, 0x77, 0xB9, 0xDA, 0x3E, 0x7B, 0x71, 0x61, + 0x14, 0x39, 0x17, 0xCE, 0xAF, 0xD6, 0x6D, 0x6F, 0x03, 0x00, 0x03, 0x1E, + 0xCD, 0x4A, 0xE7, 0xC3, 0xCD, 0xAA, 0x26, 0x49, 0x24, 0x95, 0x10, 0x42, + 0x12, 0x6D, 0xB7, 0x75, 0xD7, 0xF5, 0x44, 0x82, 0x39, 0xDA, 0xDE, 0x31, + 0x40, 0x96, 0x99, 0x84, 0x0A, 0x28, 0x32, 0xAD, 0x48, 0xB8, 0x10, 0x85, + 0x20, 0x66, 0xD0, 0x8A, 0xCA, 0x22, 0x4F, 0x4A, 0xD6, 0x80, 0x78, 0x73, + 0xB3, 0xF4, 0xCE, 0xB5, 0x6D, 0x97, 0x0E, 0xA1, 0x51, 0x95, 0xDF, 0x39, + 0x9A, 0xFF, 0xD3, 0x9F, 0xFD, 0xDE, 0x74, 0x5C, 0xBC, 0x3C, 0x3D, 0x77, + 0xDE, 0x73, 0x8C, 0x4A, 0xC9, 0xF9, 0x74, 0x2C, 0x04, 0xA5, 0xD2, 0x4C, + 0x49, 0xDA, 0x5D, 0x11, 0x08, 0x14, 0x82, 0x04, 0x02, 0x26, 0x50, 0x51, + 0xE4, 0xD8, 0x5B, 0x67, 0xAD, 0x37, 0xC6, 0x5C, 0xDD, 0xAC, 0xCE, 0xCE, + 0xAE, 0x5F, 0xBC, 0x7A, 0xBD, 0x58, 0xAC, 0xBA, 0xDE, 0x3D, 0x7E, 0xF2, + 0xE2, 0xF2, 0x6A, 0xF9, 0xEA, 0xEC, 0xCA, 0xF9, 0x70, 0x75, 0xB3, 0x7A, + 0x71, 0x7A, 0xD1, 0x75, 0x76, 0x36, 0x1D, 0x1D, 0xCE, 0x27, 0xC7, 0x47, + 0x73, 0x92, 0xB2, 0x77, 0x1E, 0x98, 0xEF, 0xDE, 0x39, 0x80, 0x5D, 0x75, + 0x09, 0x80, 0x00, 0x22, 0xF5, 0xFB, 0x13, 0x44, 0x65, 0x77, 0xDF, 0xC4, + 0x8E, 0x22, 0xCE, 0x88, 0x28, 0xE5, 0x30, 0x4A, 0x01, 0x00, 0x21, 0x90, + 0x84, 0xD8, 0x6F, 0x59, 0x81, 0x28, 0x29, 0x31, 0xD6, 0x38, 0x32, 0x30, + 0x40, 0x62, 0x38, 0xEE, 0x11, 0x7E, 0x09, 0x7F, 0xA6, 0x95, 0x28, 0x33, + 0x95, 0x80, 0x50, 0xF4, 0x2F, 0xFE, 0xE4, 0x5F, 0xED, 0xB5, 0x2B, 0xD2, + 0x91, 0x23, 0x08, 0xC5, 0xCE, 0x72, 0x8E, 0x48, 0x0C, 0xE2, 0xD9, 0x02, + 0x09, 0x91, 0xDE, 0x04, 0x45, 0x40, 0x71, 0x7B, 0xB6, 0x08, 0x08, 0x48, + 0x28, 0x04, 0x82, 0xD1, 0x6A, 0x36, 0x29, 0xAB, 0x32, 0x4F, 0x79, 0x8D, + 0x4A, 0x7A, 0xFB, 0x00, 0x03, 0x0F, 0x9B, 0x28, 0x25, 0x62, 0xBF, 0xD5, + 0x89, 0xE7, 0xEF, 0x4A, 0xAD, 0xEE, 0x63, 0xD0, 0x3E, 0xD6, 0xDC, 0x8E, + 0x41, 0xB0, 0x2B, 0xBC, 0x7F, 0x2B, 0x3C, 0xFD, 0x56, 0x38, 0xBB, 0xF5, + 0xF6, 0x86, 0xE7, 0xBE, 0x2D, 0xCB, 0xB3, 0x2B, 0x58, 0x62, 0x4A, 0x94, + 0xF6, 0x27, 0xC6, 0x9B, 0xF8, 0x08, 0x7B, 0xA9, 0x38, 0xD0, 0x4A, 0x33, + 0x87, 0x6E, 0xBD, 0xE8, 0x3B, 0xBB, 0xDA, 0xD4, 0x29, 0xCA, 0xD6, 0x9D, + 0x5B, 0xAC, 0x5B, 0x8E, 0x2C, 0x84, 0x10, 0x44, 0x00, 0x40, 0x02, 0x43, + 0x08, 0xDE, 0x07, 0x44, 0xE1, 0x9C, 0x4F, 0xE0, 0x78, 0x44, 0x1E, 0xD0, + 0x98, 0x92, 0xB4, 0x94, 0x69, 0xF8, 0x42, 0x02, 0x25, 0x09, 0x1F, 0x22, + 0x20, 0x2A, 0x65, 0xD2, 0xAC, 0x38, 0xC4, 0x10, 0x02, 0x6B, 0xAD, 0x01, + 0xB1, 0xEB, 0xFA, 0xDD, 0xC0, 0x8E, 0xD3, 0x38, 0x82, 0x19, 0xF2, 0xCC, + 0x1C, 0xCE, 0xAA, 0x9F, 0x7E, 0xF2, 0x48, 0x67, 0xE6, 0x9B, 0x67, 0xAF, + 0x27, 0x55, 0x7E, 0xFF, 0x64, 0xF6, 0xFC, 0xC5, 0xF9, 0x0F, 0xBE, 0xFF, + 0xFE, 0xE3, 0x67, 0xAF, 0xAF, 0x97, 0x1B, 0x88, 0xB1, 0xDE, 0x6C, 0xF2, + 0x22, 0x27, 0xA9, 0xB6, 0x75, 0x53, 0x55, 0x65, 0xD3, 0x75, 0xEB, 0x75, + 0x6D, 0x8C, 0x1A, 0x8D, 0xAA, 0x18, 0xE3, 0x62, 0xB9, 0xF2, 0xCE, 0x1D, + 0xCC, 0xA7, 0xC7, 0x47, 0x33, 0x41, 0xE4, 0xAC, 0x6B, 0xDB, 0x0E, 0x38, + 0x0A, 0x64, 0x25, 0x87, 0x42, 0x4F, 0x0A, 0xAC, 0xCA, 0xEC, 0xE8, 0x68, + 0x1E, 0x18, 0x96, 0xEB, 0x36, 0x44, 0xFE, 0xEA, 0xF1, 0x8B, 0x27, 0x4F, + 0x5F, 0xE8, 0xCC, 0x4C, 0x26, 0xA3, 0xE7, 0x2F, 0x5F, 0xFF, 0xBB, 0xBF, + 0xFE, 0x35, 0x08, 0x34, 0x59, 0xD6, 0x76, 0x9D, 0x36, 0xC6, 0x79, 0xBF, + 0xAD, 0xBB, 0xEB, 0xD5, 0xFA, 0xAD, 0xFB, 0x27, 0x55, 0x91, 0x5F, 0x5E, + 0x2F, 0x18, 0xF0, 0xF8, 0x70, 0x8E, 0x24, 0xCE, 0xCE, 0xAE, 0x9C, 0x0F, + 0x5A, 0xEB, 0xB2, 0xC8, 0x89, 0xC4, 0xCF, 0xFE, 0xE0, 0x27, 0x97, 0x57, + 0xD7, 0xDB, 0xED, 0xB6, 0xEF, 0x1D, 0x0A, 0xF4, 0xDE, 0xA7, 0x1A, 0x3F, + 0xC1, 0xC1, 0x33, 0x63, 0x18, 0x80, 0x43, 0xCC, 0xB4, 0x12, 0x42, 0x30, + 0x40, 0xDB, 0x3B, 0x8E, 0x90, 0x94, 0x76, 0x42, 0x88, 0x55, 0x99, 0x77, + 0x7D, 0xEF, 0xBD, 0x0F, 0x31, 0x0E, 0x14, 0x77, 0x00, 0xA3, 0x14, 0x00, + 0xE7, 0x45, 0xEE, 0x9D, 0x0F, 0x21, 0x58, 0x1B, 0x22, 0x30, 0x33, 0x48, + 0x49, 0xBD, 0x75, 0x21, 0xC2, 0xF5, 0x62, 0xBB, 0xAE, 0xDB, 0x22, 0xCB, + 0xA5, 0x92, 0xC9, 0xF2, 0x36, 0xC6, 0xE8, 0x7C, 0x10, 0x08, 0xA9, 0x6B, + 0xAE, 0x14, 0x7D, 0xFF, 0xA3, 0x47, 0xC3, 0x2A, 0xE3, 0x04, 0xEE, 0xDF, + 0x47, 0x29, 0xBC, 0x25, 0xE8, 0xBF, 0x2B, 0x01, 0xBE, 0x7B, 0x34, 0x22, + 0x0A, 0x60, 0x5E, 0x2E, 0x97, 0xD7, 0x8B, 0x8D, 0x00, 0x78, 0xF6, 0xFA, + 0x4A, 0x08, 0x51, 0x15, 0xA6, 0x30, 0xFA, 0x7A, 0x59, 0x3F, 0xBC, 0x7B, + 0xB0, 0xAE, 0xFB, 0xDE, 0xF9, 0xB7, 0x8E, 0xA7, 0xD6, 0xFA, 0x8B, 0xC5, + 0x36, 0x32, 0x27, 0x84, 0x1D, 0x40, 0xE4, 0xC8, 0x91, 0x07, 0x41, 0x34, + 0xEB, 0x83, 0x24, 0x2A, 0x0B, 0x93, 0x7A, 0xE2, 0x52, 0x52, 0x66, 0x14, + 0x22, 0x26, 0xF5, 0x17, 0xDB, 0x5B, 0x66, 0xD8, 0x36, 0x5D, 0x96, 0xE5, + 0x21, 0x04, 0x25, 0x50, 0x90, 0x40, 0x21, 0xDA, 0xAE, 0xE7, 0x18, 0xF3, + 0x4C, 0x03, 0xC0, 0xF5, 0xCD, 0xDA, 0x47, 0x5E, 0x6F, 0xB6, 0x4D, 0xD3, + 0x6D, 0xEA, 0xE6, 0xB3, 0x2F, 0x9F, 0x5E, 0x5C, 0x2E, 0x98, 0x63, 0xDB, + 0x5B, 0x12, 0x02, 0x10, 0x43, 0x8C, 0xDE, 0x05, 0x29, 0x07, 0x29, 0x3F, + 0x22, 0x21, 0x50, 0x48, 0x49, 0xC8, 0x98, 0x68, 0x9E, 0xB3, 0x71, 0x39, + 0x9F, 0x8E, 0x89, 0x44, 0x59, 0x96, 0x45, 0x91, 0xCF, 0x67, 0xE3, 0x07, + 0xF7, 0x8F, 0xBD, 0xF7, 0x07, 0xF3, 0xE9, 0x3B, 0x0F, 0xEE, 0x66, 0x46, + 0x85, 0x10, 0xAF, 0x6F, 0x56, 0x00, 0x18, 0x39, 0x5E, 0x5E, 0xDE, 0x4C, + 0x27, 0xD5, 0x6C, 0x3A, 0x02, 0xC0, 0xBF, 0xFA, 0xBB, 0xCF, 0xA7, 0x93, + 0x6A, 0x3E, 0x1D, 0xC5, 0xC8, 0x3B, 0x40, 0x2A, 0xA7, 0x11, 0xE4, 0xAE, + 0x0B, 0x06, 0x88, 0x69, 0x2B, 0xA6, 0xBC, 0x08, 0x77, 0x86, 0x1B, 0xC0, + 0xCC, 0xA9, 0x7F, 0x22, 0x70, 0xC8, 0x88, 0x52, 0x03, 0x1C, 0x11, 0x23, + 0x83, 0x22, 0x21, 0x49, 0x48, 0x29, 0x94, 0x14, 0xC0, 0x83, 0x93, 0x11, + 0x21, 0x6A, 0x89, 0x65, 0xA6, 0x8D, 0xA6, 0xF4, 0x51, 0xC8, 0x21, 0x9F, + 0xDA, 0xEB, 0x70, 0x40, 0x02, 0x1C, 0x20, 0xD2, 0x40, 0x4A, 0x12, 0x02, + 0x25, 0x88, 0xA4, 0x97, 0x70, 0x9B, 0x43, 0xB0, 0x9F, 0x9D, 0x0E, 0xA3, + 0x3E, 0x44, 0x92, 0x58, 0xE6, 0x45, 0xB2, 0x87, 0x71, 0xCE, 0x69, 0xAD, + 0x05, 0x0C, 0xDE, 0x2A, 0x7B, 0x7D, 0xFD, 0xBD, 0xB4, 0xD7, 0xED, 0xC0, + 0x84, 0x3B, 0xD1, 0xC8, 0x24, 0xA7, 0xB3, 0xAF, 0x67, 0xC5, 0xCE, 0x9A, + 0x85, 0x77, 0x40, 0x5E, 0xFE, 0x1D, 0x04, 0x3F, 0xDC, 0x2A, 0x27, 0x7F, + 0x37, 0xBF, 0x4B, 0xF1, 0xCE, 0x7B, 0x9F, 0x9E, 0x2D, 0x51, 0x28, 0x52, + 0x06, 0x94, 0x7C, 0xC6, 0x52, 0x1E, 0xCA, 0xCC, 0xCC, 0xE1, 0xF6, 0x31, + 0x0B, 0x3C, 0x94, 0xE7, 0xCC, 0xAC, 0xA4, 0x5A, 0x2C, 0xAE, 0x9F, 0x3E, + 0x79, 0x5A, 0xA9, 0x90, 0x67, 0x3A, 0x44, 0x1E, 0x57, 0xF9, 0xB6, 0xEE, + 0x8A, 0x4C, 0x95, 0xB9, 0xEE, 0x5D, 0x04, 0x44, 0xEF, 0x1C, 0x33, 0x28, + 0x45, 0xDE, 0x79, 0x49, 0x22, 0x32, 0x77, 0xBD, 0x27, 0xA9, 0x84, 0x40, + 0x29, 0x85, 0x96, 0x64, 0xB4, 0x06, 0x84, 0x18, 0x42, 0xE2, 0xB7, 0x92, + 0x18, 0x2A, 0xCD, 0x10, 0x82, 0x90, 0x22, 0x02, 0x93, 0x92, 0xC1, 0xC6, + 0xC8, 0xAE, 0x69, 0xDB, 0x84, 0x1E, 0x48, 0xD7, 0xA2, 0xB4, 0x42, 0x1F, + 0x62, 0x08, 0x52, 0xCA, 0x10, 0x63, 0x55, 0xE8, 0xB7, 0xEF, 0xCF, 0xFF, + 0xB7, 0xBF, 0xFC, 0x74, 0x53, 0x77, 0x3F, 0xFB, 0xC9, 0x47, 0xDF, 0x3C, + 0x39, 0xBD, 0x77, 0xF7, 0xB0, 0x1A, 0x95, 0x28, 0x70, 0x52, 0x66, 0x59, + 0x66, 0xEA, 0xBA, 0x5D, 0x2E, 0x57, 0x2E, 0x44, 0x00, 0xD4, 0x4A, 0x91, + 0x94, 0x31, 0x86, 0x97, 0xAF, 0x5E, 0x8F, 0xC7, 0x55, 0x6E, 0x0C, 0x0D, + 0x1A, 0xCA, 0xB6, 0x6B, 0xDB, 0x8B, 0x8B, 0x6B, 0xE6, 0xA8, 0x08, 0x4F, + 0x8E, 0x66, 0x55, 0x91, 0x5D, 0xDD, 0xAC, 0x92, 0x17, 0xEF, 0x5B, 0xF7, + 0xEF, 0x1C, 0x1F, 0xCF, 0xCF, 0xAF, 0x56, 0xE7, 0x17, 0x37, 0x93, 0xC9, + 0x68, 0x36, 0x1B, 0xAF, 0xB7, 0xED, 0x6A, 0xB5, 0xFE, 0x0F, 0x9F, 0x7E, + 0xDD, 0xF9, 0x38, 0x9D, 0x4E, 0xDE, 0xFB, 0xE0, 0x3D, 0x06, 0x9C, 0xCD, + 0xC6, 0xA3, 0x32, 0x57, 0x24, 0x4E, 0xCF, 0x2E, 0x23, 0xD2, 0xC9, 0xC9, + 0xB1, 0x92, 0xE4, 0x9C, 0xBF, 0x77, 0x72, 0xD4, 0x76, 0xF6, 0x7A, 0xB1, + 0xD2, 0x4A, 0xCD, 0xE7, 0x93, 0xB6, 0xB3, 0xDF, 0xFF, 0xF8, 0xBD, 0x5F, + 0xFE, 0xC7, 0xDF, 0x08, 0x21, 0xAE, 0x6E, 0x16, 0x45, 0x9E, 0xDF, 0x39, + 0x3E, 0xF8, 0xF2, 0xCB, 0xA7, 0x8E, 0x41, 0x88, 0x84, 0xC5, 0x97, 0xAB, + 0xF5, 0x46, 0x4A, 0xE9, 0x7C, 0x48, 0x50, 0x8C, 0x6D, 0xDD, 0x4C, 0xC6, + 0x95, 0xD6, 0xCA, 0x87, 0xE8, 0x7D, 0x74, 0xCE, 0x49, 0x29, 0x95, 0x1E, + 0x06, 0x47, 0xD6, 0x3A, 0x06, 0x10, 0x24, 0x14, 0xE2, 0xB6, 0xED, 0x3A, + 0xEC, 0x63, 0x4C, 0xDC, 0x58, 0x67, 0x9D, 0xD7, 0x4A, 0x87, 0xC8, 0x28, + 0x40, 0x49, 0xD9, 0x0B, 0xD1, 0x34, 0x9D, 0x24, 0xB4, 0x2E, 0x5E, 0xDE, + 0xAC, 0x42, 0x08, 0x5A, 0x49, 0x66, 0x48, 0x06, 0xD2, 0x49, 0x3D, 0x4F, + 0x49, 0xB9, 0x6D, 0xBA, 0xAE, 0xB3, 0x46, 0xEB, 0x38, 0x48, 0xA1, 0xEE, + 0x22, 0x17, 0xC2, 0x3E, 0xC9, 0x60, 0x00, 0x91, 0xC8, 0x7F, 0x02, 0xF6, + 0xA8, 0x82, 0xDD, 0xAA, 0x8B, 0x88, 0xF2, 0xF2, 0x6A, 0xF9, 0xE2, 0xEC, + 0xE6, 0xFD, 0x07, 0xC7, 0xA3, 0xB2, 0x70, 0xDE, 0x97, 0x55, 0xD1, 0xD8, + 0x40, 0x92, 0xEE, 0xBF, 0x75, 0xFC, 0xF2, 0x6A, 0x83, 0x80, 0x69, 0x0E, + 0x16, 0x22, 0xE4, 0x46, 0x29, 0x81, 0xC1, 0x87, 0xFD, 0x06, 0x26, 0xA2, + 0xA6, 0xED, 0xD3, 0x19, 0x9F, 0x2C, 0xD6, 0x33, 0x63, 0x56, 0xEB, 0x8D, + 0x22, 0x61, 0x8C, 0x8A, 0x1C, 0x11, 0x28, 0x95, 0x5A, 0x46, 0xAB, 0xD5, + 0x6A, 0x6D, 0x8C, 0x3E, 0x3C, 0x9E, 0x76, 0xBD, 0x63, 0xE0, 0x51, 0x55, + 0x68, 0x25, 0xAB, 0xAA, 0xEC, 0xBA, 0xFE, 0xE2, 0xF2, 0x6A, 0xB3, 0x6D, + 0xDA, 0xCE, 0x4E, 0xC6, 0x55, 0x4A, 0x1B, 0x56, 0xEB, 0xED, 0xDF, 0xFE, + 0xF2, 0x0B, 0x49, 0xF4, 0xF6, 0xC3, 0xBB, 0xEF, 0x3F, 0x7A, 0x70, 0x72, + 0x3C, 0x2F, 0x73, 0xD3, 0x75, 0xB6, 0xB7, 0xAE, 0xED, 0x3A, 0x63, 0x74, + 0x55, 0xE4, 0x46, 0xEB, 0xAA, 0xCC, 0x46, 0xA3, 0x7C, 0xB3, 0x6D, 0xB5, + 0x92, 0x65, 0x91, 0x1D, 0x1D, 0x4C, 0x22, 0x73, 0xDB, 0xF5, 0x6D, 0x67, + 0x8B, 0xDC, 0xF4, 0xD6, 0x09, 0xC4, 0xD5, 0x66, 0xBB, 0x58, 0x6E, 0xDF, + 0x79, 0x70, 0xF2, 0xCE, 0x83, 0x93, 0xCE, 0xBA, 0xC5, 0x62, 0xFD, 0xED, + 0xCB, 0xD7, 0xC7, 0xBD, 0xFD, 0xFD, 0x1F, 0x7D, 0x54, 0xD7, 0xCD, 0x72, + 0xDD, 0xFE, 0xF2, 0xD3, 0xC7, 0xEF, 0x3C, 0x38, 0x19, 0x0C, 0xB9, 0x39, + 0x42, 0xE2, 0x45, 0xFA, 0x80, 0x38, 0xF8, 0x29, 0x01, 0xEC, 0x53, 0xAA, + 0xDB, 0xA8, 0x26, 0x88, 0x0C, 0x62, 0x27, 0x2B, 0x1D, 0x23, 0x2A, 0x1A, + 0xD0, 0x03, 0x44, 0xC2, 0x28, 0x80, 0xC1, 0xE0, 0x91, 0x95, 0x94, 0x8A, + 0xFC, 0xBA, 0xB1, 0x80, 0xA8, 0x09, 0xB5, 0x14, 0xA9, 0xA1, 0x9C, 0x9E, + 0x50, 0x0A, 0x14, 0x51, 0x70, 0x2A, 0xA6, 0xD2, 0xBC, 0xF9, 0x8D, 0xB6, + 0x58, 0x7A, 0x71, 0x01, 0xC8, 0x43, 0x93, 0x4D, 0x50, 0x72, 0x57, 0xDA, + 0x95, 0x6F, 0x42, 0x00, 0xA0, 0x56, 0x94, 0xEC, 0x00, 0x32, 0xAD, 0x94, + 0x92, 0xE9, 0xD4, 0x92, 0xC9, 0xF1, 0x0C, 0x80, 0x6F, 0x29, 0x4D, 0x0F, + 0x47, 0xDE, 0xAE, 0x3F, 0x95, 0xC2, 0x99, 0x73, 0x3E, 0x01, 0x82, 0x00, + 0x60, 0x97, 0x1E, 0x71, 0x08, 0x48, 0x14, 0x13, 0xFB, 0x27, 0x7D, 0xD2, + 0x70, 0x2B, 0xC3, 0xFA, 0x4E, 0xDE, 0x74, 0x2B, 0x72, 0xED, 0xFE, 0x8E, + 0x7B, 0x04, 0x46, 0x9A, 0x30, 0xA4, 0x36, 0x81, 0x94, 0xE0, 0x23, 0x27, + 0x96, 0x96, 0x10, 0x9C, 0xA4, 0x17, 0x86, 0x0B, 0x21, 0xF1, 0x26, 0x32, + 0x0E, 0x27, 0x08, 0x72, 0x64, 0x46, 0x26, 0xA2, 0xD5, 0xE2, 0xFA, 0xB3, + 0xCF, 0xBE, 0x20, 0x81, 0xF3, 0xA2, 0x8C, 0x01, 0x7D, 0xC0, 0xD6, 0x06, + 0x40, 0x01, 0x98, 0x12, 0xA5, 0xC0, 0x00, 0x3E, 0x04, 0x21, 0x44, 0xDD, + 0x74, 0x7D, 0x67, 0xF3, 0xDC, 0x28, 0x49, 0x59, 0x96, 0xB9, 0x10, 0x7D, + 0x0C, 0x49, 0x21, 0x23, 0x9D, 0xF5, 0x42, 0xA0, 0x94, 0xD2, 0xFB, 0x44, + 0x53, 0x1F, 0x1C, 0x30, 0x5D, 0xDF, 0x01, 0xA2, 0xED, 0x2D, 0x22, 0x54, + 0x65, 0xD9, 0x5B, 0xDB, 0x75, 0x9B, 0xFD, 0x5D, 0x4A, 0xB7, 0xDB, 0x18, + 0xDD, 0x5B, 0x7F, 0xB3, 0xAC, 0xDF, 0xBD, 0x3F, 0x67, 0x44, 0x6B, 0x7D, + 0x8C, 0xDC, 0x59, 0xBB, 0x5A, 0x6F, 0x1F, 0x3C, 0xB8, 0xFB, 0xF8, 0xE9, + 0xE9, 0xF2, 0xF2, 0xFA, 0xE1, 0xDD, 0xC3, 0x83, 0xC3, 0x69, 0x8C, 0xFC, + 0xF4, 0xF9, 0x99, 0xED, 0xFB, 0x2C, 0xCB, 0x97, 0xCB, 0x75, 0x51, 0xE6, + 0x47, 0xF3, 0xA9, 0x96, 0xD4, 0xF7, 0x2E, 0xB8, 0x08, 0xEC, 0x25, 0xC9, + 0xED, 0x66, 0xD3, 0x34, 0x8D, 0xB7, 0xF6, 0xC1, 0xBD, 0xE3, 0xCC, 0xC8, + 0xE3, 0xC3, 0x49, 0x66, 0x34, 0x73, 0xB8, 0x59, 0xAC, 0x7F, 0xF4, 0xC3, + 0x0F, 0x95, 0x54, 0xE7, 0x57, 0xCB, 0xBE, 0xB3, 0x8B, 0xE5, 0xBA, 0x73, + 0xA1, 0x6E, 0xDA, 0xD9, 0x6C, 0x3A, 0x99, 0x8C, 0x36, 0x9B, 0x3A, 0xCB, + 0xB4, 0x52, 0xFA, 0xDD, 0x47, 0x0F, 0xDB, 0xCE, 0x96, 0x55, 0x1E, 0x63, + 0xBC, 0x7B, 0x38, 0x3B, 0x38, 0x3C, 0x78, 0xF9, 0xFA, 0xF2, 0x3F, 0x7E, + 0xF6, 0xF5, 0x87, 0xEF, 0xBF, 0x73, 0x72, 0x34, 0x0B, 0x31, 0x22, 0x8A, + 0xBE, 0xEF, 0xAF, 0xAE, 0x16, 0x9F, 0x7C, 0xF2, 0xE1, 0x62, 0xB1, 0xBA, + 0xB8, 0xBE, 0xF9, 0xE0, 0x83, 0x77, 0xB4, 0x54, 0xA7, 0x67, 0x67, 0xC6, + 0x64, 0x52, 0x29, 0xA5, 0xE5, 0xB6, 0xAE, 0x33, 0x63, 0xB4, 0xA4, 0x22, + 0x33, 0xB6, 0xEB, 0x89, 0x84, 0x75, 0x81, 0x39, 0x16, 0x79, 0xEE, 0x9C, + 0x4F, 0xC7, 0x48, 0x5A, 0x18, 0x29, 0x77, 0x36, 0x46, 0xA7, 0x9B, 0x16, + 0x19, 0x54, 0x9A, 0x2F, 0x49, 0x61, 0x94, 0xCA, 0xF3, 0x7C, 0xB9, 0xDE, + 0x90, 0x75, 0x89, 0x25, 0x69, 0xBD, 0x93, 0x24, 0x11, 0xA1, 0xB7, 0xAE, + 0xB7, 0x4E, 0x91, 0x48, 0x0C, 0x2D, 0xAD, 0x54, 0xE3, 0x03, 0x02, 0x78, + 0xEF, 0xE7, 0xD3, 0xE9, 0x62, 0xB9, 0xF4, 0x2E, 0xF1, 0x1D, 0x63, 0xEF, + 0xC3, 0x6A, 0xD3, 0xDC, 0x39, 0xD4, 0x91, 0xE3, 0x00, 0x0F, 0x4B, 0x6A, + 0xC9, 0x09, 0x6C, 0x91, 0x72, 0x03, 0xC6, 0x08, 0x11, 0x01, 0x21, 0x22, + 0x20, 0x32, 0xB2, 0xD8, 0x55, 0x24, 0x31, 0x70, 0x44, 0x46, 0x81, 0xD6, + 0x85, 0xBA, 0xB3, 0x00, 0x28, 0x89, 0x36, 0xDB, 0x2E, 0xC4, 0x68, 0x8C, + 0x72, 0xD6, 0x73, 0x84, 0x22, 0xD7, 0x4D, 0x67, 0x2F, 0x96, 0x5B, 0xA3, + 0x25, 0x21, 0x84, 0xC8, 0xD6, 0x3A, 0xA5, 0x88, 0x99, 0x49, 0x08, 0xAD, + 0x54, 0xD7, 0xFB, 0x51, 0x95, 0x93, 0xC0, 0xA6, 0xED, 0x93, 0x44, 0x7D, + 0x55, 0x64, 0x44, 0x02, 0x00, 0x81, 0xD9, 0x79, 0x67, 0xAD, 0x53, 0x92, + 0xBC, 0x73, 0x4D, 0xDB, 0x1D, 0xCC, 0xC6, 0x46, 0x2B, 0xE7, 0x63, 0xD3, + 0x75, 0x52, 0x52, 0x9E, 0xA7, 0x41, 0x50, 0xD4, 0x4A, 0xB5, 0x5D, 0x97, + 0x70, 0xF1, 0x02, 0xE4, 0xA8, 0x2C, 0xA4, 0x24, 0x1F, 0xC2, 0x72, 0xB5, + 0xFD, 0xEC, 0x8B, 0x27, 0xBF, 0xF9, 0xEA, 0xDB, 0xBB, 0x77, 0x0E, 0xEE, + 0x9D, 0x1C, 0xFE, 0xFE, 0x8F, 0x3E, 0xAA, 0xCA, 0xFC, 0xE2, 0x7A, 0xF1, + 0xC5, 0xD7, 0xCF, 0x8B, 0x3C, 0x7B, 0xEF, 0xED, 0x7B, 0x28, 0x44, 0x9E, + 0xA9, 0xE3, 0xC3, 0xC9, 0x66, 0xDB, 0x26, 0x21, 0x90, 0x34, 0x66, 0x49, + 0x9B, 0xB4, 0x2A, 0x32, 0x45, 0xE4, 0x7D, 0x68, 0x5B, 0xAB, 0x24, 0x25, + 0x91, 0xD3, 0x32, 0x33, 0xE6, 0xE7, 0x3F, 0x89, 0x81, 0xF3, 0xCC, 0x28, + 0x45, 0x59, 0xA6, 0xB4, 0xD6, 0x8A, 0x88, 0xB5, 0x02, 0x40, 0x1F, 0x23, + 0x44, 0x0E, 0xC1, 0x87, 0xC8, 0x72, 0x40, 0xD5, 0xBF, 0x09, 0x2B, 0x81, + 0x93, 0xB3, 0x6D, 0xFA, 0x88, 0x03, 0x20, 0x44, 0x66, 0xEF, 0x23, 0x91, + 0xD0, 0x4A, 0x68, 0xA5, 0x18, 0x62, 0x02, 0xB9, 0xA3, 0x00, 0x21, 0x28, + 0x09, 0x3A, 0x84, 0x10, 0x95, 0x24, 0x45, 0x82, 0x39, 0x4A, 0x02, 0x91, + 0xC2, 0xA5, 0x47, 0x41, 0x2C, 0x84, 0x90, 0x24, 0x84, 0xD8, 0x83, 0xB9, + 0x86, 0x7E, 0x3F, 0x30, 0x0C, 0x7C, 0x9F, 0x21, 0x6A, 0x08, 0x46, 0x46, + 0xA5, 0x08, 0x00, 0x9C, 0xF7, 0x8A, 0x44, 0xCA, 0x29, 0x8A, 0x4C, 0x1B, + 0x2D, 0x95, 0x4A, 0x6C, 0x0D, 0xB1, 0x4F, 0x9D, 0xF6, 0xA8, 0x8B, 0xBF, + 0x37, 0x5D, 0x0A, 0x61, 0x90, 0x24, 0x4C, 0x6F, 0xAE, 0x6E, 0x3A, 0x00, + 0x90, 0x52, 0xE2, 0x80, 0x72, 0x85, 0x1D, 0xF7, 0x03, 0x63, 0x04, 0x29, + 0xDF, 0x00, 0x78, 0x6E, 0x65, 0x5A, 0x29, 0x1D, 0x15, 0x6F, 0xDE, 0xE1, + 0xAE, 0x0E, 0xBD, 0x95, 0x8B, 0x71, 0x08, 0xDE, 0x39, 0x37, 0xF4, 0x3B, + 0x07, 0xAD, 0xE4, 0x3D, 0x4C, 0x0F, 0xF6, 0x6C, 0x25, 0x44, 0xDE, 0xD7, + 0xEA, 0xB0, 0xFF, 0xDE, 0x0E, 0x7A, 0x12, 0x83, 0x7F, 0xFA, 0xE4, 0xD9, + 0x6C, 0x32, 0x72, 0xAE, 0xDF, 0x6C, 0x5B, 0xEB, 0xE2, 0xFD, 0x93, 0xD9, + 0xD5, 0xB2, 0x76, 0xCE, 0x17, 0x99, 0x11, 0x88, 0xBD, 0x75, 0x92, 0x44, + 0x3A, 0x72, 0x01, 0xC0, 0x64, 0x5A, 0x10, 0x31, 0x70, 0xDF, 0xF5, 0x48, + 0x24, 0x18, 0xE4, 0x4E, 0x1E, 0x88, 0xA4, 0x48, 0x62, 0x1B, 0x42, 0x70, + 0x8C, 0x28, 0x04, 0x03, 0x04, 0x40, 0x50, 0x4A, 0x21, 0x62, 0x08, 0xC1, + 0x28, 0x35, 0x99, 0x8E, 0x96, 0xEB, 0xED, 0xCD, 0xCD, 0x32, 0xDD, 0x04, + 0x21, 0x44, 0x08, 0xB1, 0x4F, 0x4A, 0x66, 0x31, 0x12, 0x89, 0x83, 0xE9, + 0x68, 0xB3, 0xED, 0xBA, 0xCE, 0x6A, 0x4D, 0xE9, 0x3F, 0xD6, 0xBD, 0xFB, + 0xE5, 0x2F, 0x3E, 0xD7, 0x84, 0xDA, 0x48, 0x6B, 0x5D, 0x22, 0x51, 0x75, + 0x7D, 0xD7, 0xB4, 0xB1, 0x2C, 0x2B, 0xDB, 0xF7, 0xCE, 0xBB, 0xB2, 0xC8, + 0xC3, 0x36, 0x06, 0xEF, 0x9B, 0xA6, 0x2D, 0x8A, 0x1C, 0x80, 0x91, 0xF9, + 0x60, 0x3A, 0x3A, 0x9C, 0x57, 0x55, 0x91, 0x1D, 0x1E, 0xCE, 0xAC, 0x73, + 0xF3, 0xE9, 0xE8, 0xBD, 0x77, 0xDF, 0xB6, 0x3E, 0x9E, 0x9E, 0x5F, 0x11, + 0x87, 0x2F, 0xBE, 0x7A, 0xF6, 0xD5, 0xD3, 0x53, 0x10, 0xE2, 0xD1, 0xA3, + 0x87, 0x87, 0x87, 0x07, 0x79, 0x96, 0x95, 0x45, 0x5E, 0x16, 0xF9, 0xCD, + 0x72, 0x6D, 0x9D, 0x67, 0xC4, 0x27, 0xCF, 0x5E, 0x29, 0xC2, 0xE9, 0xB8, + 0x22, 0xA2, 0xC3, 0xF9, 0xF4, 0x9D, 0x87, 0xF6, 0xFC, 0xEA, 0x66, 0x54, + 0x15, 0x93, 0x71, 0x21, 0x89, 0xC6, 0xA3, 0x12, 0x51, 0xAC, 0xD6, 0x9B, + 0xCD, 0x66, 0xDB, 0x5B, 0xF7, 0xB3, 0xDF, 0xFF, 0x61, 0xD3, 0xF5, 0x27, + 0x77, 0x0E, 0xD6, 0x9B, 0xBA, 0xB7, 0xAE, 0x1A, 0x95, 0xAB, 0xD5, 0x46, + 0x49, 0x62, 0x66, 0xE7, 0x1C, 0x91, 0x08, 0x3E, 0x90, 0x40, 0x0E, 0xD8, + 0x77, 0xBD, 0xD2, 0x0A, 0x10, 0xA3, 0x0F, 0x42, 0x08, 0x67, 0x1D, 0x23, + 0x28, 0x29, 0x39, 0x46, 0x44, 0x4C, 0x2A, 0x80, 0x46, 0xEB, 0x74, 0xC7, + 0x88, 0xA8, 0xED, 0x7A, 0x29, 0x28, 0xE9, 0x6B, 0x2B, 0x29, 0x7B, 0x67, + 0x21, 0xA2, 0x96, 0x12, 0x89, 0x71, 0x70, 0xDF, 0x41, 0xE7, 0xBD, 0x24, + 0xA1, 0xB5, 0x14, 0x84, 0xA3, 0x51, 0x31, 0x1A, 0x95, 0xCB, 0xD5, 0x4A, + 0x4A, 0xF2, 0xC1, 0x03, 0xEA, 0xBA, 0xEE, 0x3E, 0xFF, 0xEA, 0xDB, 0x93, + 0xE3, 0x59, 0x48, 0x52, 0xF3, 0xBB, 0x8C, 0x0C, 0x11, 0x07, 0x11, 0x87, + 0x01, 0x04, 0x8E, 0x88, 0x80, 0x0C, 0x08, 0x8C, 0x8C, 0x91, 0x61, 0x70, + 0x4B, 0x04, 0x0C, 0x31, 0xD4, 0x4D, 0x27, 0xA5, 0x5C, 0x6F, 0xBB, 0x32, + 0xD7, 0x0F, 0x4E, 0x0E, 0x56, 0xDB, 0x96, 0x04, 0x69, 0xA5, 0xEA, 0xBA, + 0x4D, 0xDD, 0x3A, 0x1F, 0x62, 0x91, 0x67, 0xD8, 0x3B, 0x44, 0xE1, 0x43, + 0x48, 0x51, 0x0C, 0x11, 0x49, 0x60, 0x88, 0xA1, 0xC8, 0x15, 0x0D, 0x13, + 0x27, 0xF6, 0x21, 0x4A, 0x12, 0x46, 0x29, 0x1F, 0x82, 0xF5, 0x9D, 0xD6, + 0x3A, 0x04, 0x8F, 0x00, 0x44, 0x14, 0x98, 0xA7, 0xE3, 0xB2, 0xC8, 0x54, + 0x1A, 0x04, 0x23, 0x62, 0xD3, 0x76, 0x55, 0x99, 0x23, 0xA0, 0xF3, 0x11, + 0x20, 0x6C, 0xB6, 0x8D, 0x92, 0xB2, 0xEB, 0x9D, 0x40, 0xCC, 0x32, 0xE5, + 0x7C, 0xA8, 0xCA, 0x7C, 0xBB, 0x6D, 0x32, 0x93, 0x2F, 0xD7, 0xF5, 0xD7, + 0x4F, 0x5E, 0x3C, 0x7D, 0x7E, 0x7A, 0x7E, 0xB5, 0x7C, 0xF4, 0xF6, 0xBD, + 0x22, 0x33, 0xAB, 0x75, 0xAD, 0xA4, 0x7C, 0x7E, 0x7A, 0x71, 0xF7, 0xCE, + 0xE1, 0xD5, 0xCD, 0xEA, 0xF5, 0xC5, 0xE2, 0xFD, 0xB7, 0xEF, 0x25, 0x64, + 0x9C, 0x60, 0x1C, 0x29, 0x59, 0xE4, 0x46, 0xEC, 0xFC, 0x37, 0x8E, 0x0E, + 0x26, 0x07, 0xB3, 0x71, 0x1A, 0xBE, 0xE7, 0x99, 0x11, 0x88, 0x99, 0xD1, + 0xDE, 0x07, 0xEB, 0x7D, 0xA6, 0xD5, 0x4F, 0x7E, 0xF0, 0x3E, 0x00, 0x3C, + 0xFE, 0xF6, 0x8C, 0x04, 0xBE, 0xBE, 0xB8, 0x3E, 0x3A, 0x9C, 0xCD, 0x27, + 0x95, 0x52, 0x89, 0xAF, 0x88, 0x69, 0xF8, 0xCE, 0xBB, 0xB6, 0xBB, 0x18, + 0x72, 0x20, 0x20, 0x21, 0x22, 0xB1, 0x10, 0xC3, 0xC7, 0x04, 0x9C, 0x7A, + 0xFD, 0x40, 0x44, 0xDE, 0xC7, 0xD4, 0x23, 0x88, 0x31, 0xE0, 0x60, 0x25, + 0xC7, 0x00, 0x98, 0x69, 0xB2, 0x6E, 0x30, 0xEB, 0x85, 0x84, 0x27, 0x0D, + 0xC0, 0x1C, 0xE4, 0xCE, 0xDE, 0x9C, 0xE1, 0xD6, 0x3E, 0xBE, 0x9D, 0xEC, + 0x24, 0x50, 0xB5, 0x51, 0x52, 0x2B, 0x69, 0xAD, 0x47, 0x29, 0x8D, 0x92, + 0x24, 0x85, 0x51, 0xCA, 0x18, 0x45, 0x43, 0xCE, 0x9B, 0xEA, 0x3E, 0x80, + 0xEF, 0x8A, 0xDB, 0xDC, 0x8E, 0x3D, 0xE9, 0x7A, 0x42, 0x02, 0x59, 0xED, + 0x70, 0xBA, 0x3E, 0x04, 0x22, 0xA1, 0x64, 0x1A, 0xC5, 0x90, 0x1A, 0xEC, + 0x91, 0x86, 0x7E, 0x56, 0x8C, 0x10, 0x02, 0x87, 0xE0, 0x87, 0xA3, 0x69, + 0xC8, 0xEF, 0x92, 0x2A, 0xC7, 0x1B, 0xC1, 0x90, 0xDD, 0x6C, 0x6B, 0x78, + 0xAD, 0xFD, 0x23, 0xC9, 0x8A, 0xA5, 0x89, 0x72, 0x42, 0xE7, 0xE2, 0x4E, + 0x43, 0x6A, 0xE8, 0x21, 0x32, 0xC3, 0xCE, 0x8A, 0x69, 0xB8, 0x95, 0x6F, + 0xD2, 0xB9, 0x94, 0xA9, 0xD1, 0xF5, 0xE5, 0x65, 0xD7, 0xB6, 0xC1, 0x4B, + 0x08, 0xDE, 0x03, 0xFB, 0x18, 0xAB, 0xDC, 0xE4, 0x99, 0xC6, 0x1D, 0x12, + 0x38, 0xF5, 0x6B, 0xAC, 0x75, 0x28, 0x44, 0x08, 0x41, 0x2A, 0xA9, 0x8C, + 0xF6, 0x7D, 0x2F, 0x15, 0x01, 0xA3, 0x90, 0xD2, 0x18, 0x9D, 0x10, 0xF9, + 0x43, 0x1E, 0x3A, 0xA4, 0xB4, 0x11, 0x10, 0x92, 0xDC, 0x19, 0x46, 0x17, + 0x39, 0x4A, 0x49, 0xCC, 0xF1, 0xE6, 0xFA, 0x66, 0xDB, 0x76, 0xB7, 0x51, + 0xC4, 0x49, 0x64, 0xC6, 0x18, 0xD5, 0x75, 0xF6, 0x70, 0x36, 0xFA, 0xF0, + 0xD1, 0xC9, 0xB7, 0xA7, 0xD7, 0x6D, 0x67, 0xFF, 0xC9, 0x3F, 0xFE, 0xC1, + 0xCD, 0xCD, 0x52, 0x99, 0x6C, 0xBD, 0xED, 0x49, 0xC0, 0x27, 0x9F, 0xBC, + 0x77, 0x30, 0x1F, 0x57, 0x55, 0xE9, 0x9C, 0xBB, 0xBA, 0x59, 0x6F, 0xB6, + 0x8D, 0x04, 0xD1, 0x35, 0x5B, 0x06, 0xDC, 0x6C, 0x34, 0x8E, 0x90, 0x99, + 0x7B, 0xEB, 0x36, 0xDB, 0x26, 0x0D, 0x49, 0x43, 0xF0, 0xCE, 0x87, 0xD5, + 0x2A, 0x3F, 0x3A, 0x9C, 0x92, 0x24, 0xB6, 0x3E, 0x30, 0x7E, 0xFE, 0xE5, + 0xB3, 0xD9, 0xA4, 0xDA, 0xAE, 0xD6, 0x97, 0xD7, 0xCB, 0xDE, 0xC3, 0xBD, + 0x7B, 0x77, 0xAC, 0x8F, 0xBF, 0xFE, 0xF5, 0x17, 0xAF, 0x5E, 0x9E, 0xFD, + 0x77, 0xFF, 0xFC, 0xBF, 0x1A, 0x55, 0xC5, 0xF5, 0x62, 0x23, 0x48, 0xBA, + 0xCE, 0x5A, 0x17, 0x9C, 0xED, 0x7F, 0xF5, 0xC5, 0x37, 0x1F, 0x7F, 0xF8, + 0x1E, 0x40, 0x40, 0xC4, 0xBB, 0x77, 0x0E, 0xEF, 0xDE, 0x39, 0x7C, 0x79, + 0x7A, 0xC9, 0x1C, 0x47, 0x55, 0x81, 0x00, 0x1F, 0xBD, 0xFF, 0xF0, 0xE5, + 0xE9, 0x45, 0xDF, 0xBB, 0xEB, 0xC5, 0xF2, 0xDF, 0xFC, 0x5F, 0xFF, 0xAE, + 0xAC, 0xCA, 0xB6, 0xEB, 0xAD, 0xF5, 0xFF, 0xE8, 0xA7, 0xDF, 0x7F, 0xF7, + 0xD1, 0x83, 0xB3, 0xD7, 0x17, 0xA9, 0x13, 0x9A, 0xDA, 0xF9, 0xA9, 0x55, + 0x44, 0x29, 0xBA, 0xC7, 0x18, 0x62, 0x6C, 0xBB, 0x4E, 0x08, 0x91, 0x06, + 0x61, 0x52, 0x52, 0xF2, 0x60, 0x17, 0x02, 0x8B, 0xDC, 0x6C, 0xB6, 0x8D, + 0x56, 0x92, 0x48, 0xF4, 0xD6, 0xA6, 0x6D, 0xAF, 0x04, 0x31, 0x73, 0xDB, + 0xF5, 0xCC, 0xCC, 0x94, 0x74, 0x67, 0x65, 0xD2, 0xB4, 0xC8, 0x74, 0x3A, + 0x68, 0x40, 0x0B, 0x91, 0xE5, 0xD9, 0xBD, 0xBB, 0xC7, 0xD7, 0xD7, 0x37, + 0x02, 0x51, 0x1A, 0xDD, 0xF7, 0x36, 0x32, 0x10, 0xD1, 0xCB, 0xB3, 0x2B, + 0xE7, 0x02, 0x0F, 0x62, 0x0C, 0x43, 0x22, 0xB6, 0x3F, 0x16, 0x11, 0x87, + 0xCF, 0x9A, 0x41, 0xA4, 0xCE, 0x3F, 0x02, 0xE0, 0x0E, 0x84, 0x8D, 0x08, + 0xDE, 0xC7, 0xC5, 0xAA, 0x01, 0x80, 0xCE, 0xFA, 0xCC, 0xA8, 0x18, 0xA3, + 0x94, 0x64, 0xAD, 0x3F, 0x98, 0x4F, 0x62, 0x64, 0x8E, 0x31, 0x44, 0x71, + 0x7E, 0xB3, 0x39, 0x9A, 0x8D, 0x9A, 0xCE, 0x86, 0x18, 0x22, 0x83, 0xD1, + 0xCA, 0xF9, 0x10, 0x63, 0x40, 0x31, 0xB0, 0x2F, 0x9C, 0xF7, 0x75, 0xD3, + 0x6F, 0x9B, 0x2E, 0xCF, 0xB4, 0x51, 0xE4, 0x43, 0x90, 0x02, 0x11, 0x48, + 0x08, 0xCC, 0x32, 0x0D, 0x00, 0xCE, 0x39, 0xE7, 0x7C, 0x72, 0x45, 0x62, + 0x00, 0x22, 0x2C, 0x72, 0x0D, 0x08, 0x09, 0x5E, 0xC3, 0x8C, 0xDE, 0x87, + 0xB6, 0xEB, 0xA9, 0x10, 0xCE, 0x79, 0x29, 0x49, 0x09, 0x99, 0x69, 0x01, + 0xCC, 0x52, 0x49, 0x8E, 0xB1, 0xC8, 0xCD, 0xBD, 0x3B, 0x87, 0x97, 0xD7, + 0x8B, 0xCF, 0xBE, 0xF8, 0xE6, 0xF1, 0x93, 0x17, 0x79, 0x6E, 0xE6, 0xB3, + 0x29, 0x00, 0xEB, 0xB5, 0x9C, 0x4D, 0x46, 0x65, 0x91, 0x7D, 0xF9, 0xF8, + 0x45, 0x55, 0xE6, 0x0F, 0xEE, 0x1D, 0x26, 0x63, 0xF9, 0xB4, 0xB3, 0x78, + 0xE8, 0x65, 0x43, 0xE4, 0x08, 0x08, 0x24, 0x07, 0x65, 0x0B, 0xEB, 0x82, + 0x92, 0x52, 0xA9, 0x94, 0xDF, 0xE0, 0xE1, 0x7C, 0x12, 0x42, 0x74, 0xC1, + 0x37, 0x9D, 0x27, 0x41, 0xDB, 0x6D, 0xD3, 0xB5, 0x7D, 0x51, 0x18, 0xAD, + 0x94, 0x94, 0x54, 0x95, 0xF9, 0xAE, 0x8E, 0x4E, 0x07, 0xF9, 0xB0, 0xC0, + 0x05, 0x82, 0x96, 0x42, 0x90, 0x42, 0x4E, 0xFC, 0xD7, 0xC1, 0xED, 0x3B, + 0x6D, 0x92, 0x5D, 0x43, 0x09, 0x04, 0x42, 0x08, 0xC9, 0x2C, 0x6E, 0xF0, + 0x25, 0x01, 0x8E, 0xA9, 0xE7, 0x36, 0x6C, 0xF9, 0xC8, 0x72, 0x68, 0x15, + 0xA4, 0x6F, 0xE2, 0xC0, 0x71, 0x42, 0xC0, 0x84, 0x37, 0x4D, 0x61, 0x45, + 0x2B, 0x25, 0x49, 0x00, 0x83, 0x94, 0x42, 0x23, 0x65, 0x46, 0xE7, 0xB9, + 0xC6, 0x94, 0xC6, 0xDC, 0x02, 0x4C, 0xEC, 0xA7, 0x13, 0xF0, 0xDD, 0xC7, + 0xBE, 0xD5, 0x95, 0xFE, 0x29, 0xA5, 0x24, 0xE2, 0x94, 0x2E, 0x1A, 0x52, + 0x99, 0x51, 0x7B, 0xA4, 0x44, 0x0A, 0x49, 0xCC, 0x31, 0x84, 0x28, 0x04, + 0x49, 0x39, 0x50, 0xE4, 0xBD, 0xF7, 0x5D, 0xEF, 0x98, 0x39, 0xF5, 0x29, + 0x53, 0xF2, 0xE5, 0x43, 0x60, 0x06, 0x12, 0x82, 0x68, 0x08, 0xB8, 0x31, + 0x72, 0xE4, 0x61, 0xDE, 0x2C, 0xC4, 0xE0, 0xC3, 0xC4, 0x83, 0x5F, 0x1E, + 0x73, 0x64, 0x14, 0x48, 0x02, 0x95, 0x1C, 0x86, 0x09, 0x91, 0x53, 0x1B, + 0x7E, 0xC0, 0x85, 0x24, 0xD4, 0xD8, 0xD0, 0xCB, 0xE3, 0x98, 0x02, 0xD9, + 0x62, 0xB9, 0x3E, 0x7D, 0x7D, 0x75, 0xFF, 0xDE, 0x61, 0x95, 0xA9, 0xAA, + 0xCC, 0xDB, 0xDE, 0x2D, 0x17, 0x4B, 0xA3, 0xCD, 0xE5, 0xF5, 0xBA, 0x2A, + 0x4C, 0x91, 0x29, 0x04, 0xF0, 0x3E, 0xD8, 0xDE, 0xE6, 0x65, 0xE1, 0x9D, + 0x4B, 0xF2, 0x3B, 0x82, 0x64, 0x22, 0x1D, 0x68, 0xAD, 0x38, 0x46, 0xCF, + 0x11, 0x31, 0xC9, 0x09, 0x60, 0x8C, 0x1C, 0x62, 0x48, 0xC1, 0x3C, 0x39, + 0x30, 0x12, 0x09, 0x6D, 0x94, 0xED, 0x1D, 0x21, 0x2A, 0x29, 0x8F, 0x0F, + 0x66, 0x0B, 0xB9, 0x5D, 0x6F, 0xB6, 0x29, 0x95, 0xB0, 0xDE, 0x4B, 0x22, + 0x04, 0x40, 0x84, 0xBB, 0xC7, 0xE3, 0xE5, 0x6A, 0xF3, 0xEA, 0x62, 0x21, + 0x95, 0x3C, 0x39, 0x9E, 0xFF, 0xF9, 0x67, 0x5F, 0x7F, 0xF8, 0xF1, 0x07, + 0x4F, 0x9E, 0xBD, 0xD6, 0x99, 0xA9, 0xAA, 0xE2, 0xBD, 0x77, 0x1F, 0xAE, + 0xD6, 0x9B, 0xB6, 0x6D, 0xEF, 0xDF, 0x3D, 0x20, 0xA2, 0xCB, 0xEB, 0xA5, + 0x22, 0xDC, 0xD6, 0xCD, 0xC5, 0xEB, 0xCE, 0xF5, 0xCE, 0xC5, 0x78, 0x7E, + 0x71, 0xBD, 0xDD, 0x0E, 0xAA, 0xFC, 0x09, 0xAD, 0x56, 0x96, 0x0F, 0xA6, + 0x93, 0x71, 0x67, 0xFD, 0xCD, 0xB2, 0x76, 0x3E, 0x62, 0xF4, 0x67, 0x67, + 0x17, 0x75, 0x1F, 0xAA, 0xD9, 0xFC, 0xDD, 0xF7, 0xA6, 0x21, 0xF8, 0x9B, + 0x4D, 0xBB, 0xD9, 0x6C, 0x3F, 0xFD, 0xF4, 0x8B, 0x83, 0xF9, 0xE4, 0x67, + 0x7F, 0xF0, 0x23, 0x40, 0x94, 0x92, 0xAA, 0x22, 0xFF, 0xCD, 0xE3, 0xE7, + 0x27, 0xC7, 0x47, 0xF3, 0xD9, 0xB4, 0xAE, 0x1B, 0x6D, 0x94, 0xD6, 0xDA, + 0x76, 0xFD, 0x64, 0x54, 0x54, 0xA5, 0x79, 0xFC, 0xED, 0xAB, 0x7B, 0x77, + 0x8E, 0x8E, 0x0F, 0xA7, 0xDB, 0x6D, 0x3B, 0x9F, 0x4D, 0xC6, 0xE3, 0x6A, + 0x54, 0xE5, 0xAF, 0x5F, 0x5F, 0x2C, 0x17, 0x8B, 0xF3, 0xCB, 0xC5, 0xC5, + 0xE5, 0xA2, 0x6D, 0xDB, 0x7F, 0xFE, 0xDF, 0xFE, 0xFC, 0xE0, 0x60, 0x76, + 0x73, 0x7D, 0x43, 0x54, 0xB8, 0x10, 0x49, 0x4A, 0x6F, 0x2D, 0x87, 0x18, + 0x05, 0x27, 0xB3, 0xB2, 0xAE, 0xB7, 0x59, 0x66, 0x92, 0xE9, 0x06, 0x03, + 0x6B, 0x96, 0x24, 0xA5, 0x75, 0x01, 0x11, 0x9D, 0x0F, 0xCE, 0x7B, 0x40, + 0x28, 0xA4, 0x21, 0x44, 0x16, 0xE8, 0x9C, 0x57, 0x44, 0xC0, 0x1C, 0x99, + 0x33, 0x63, 0xBA, 0xBE, 0x77, 0x3E, 0x38, 0x1F, 0xB3, 0x2C, 0x2B, 0x72, + 0x2D, 0x10, 0xEE, 0x18, 0x7D, 0x79, 0xB5, 0x54, 0x46, 0x49, 0x49, 0xAF, + 0xCF, 0x2E, 0x63, 0x8C, 0x59, 0xA6, 0xDB, 0xCE, 0xA5, 0xA5, 0xA5, 0xA4, + 0x40, 0x41, 0xD6, 0x7B, 0x4C, 0x9F, 0x7B, 0xCA, 0x0D, 0x86, 0xE0, 0x35, + 0x6C, 0x95, 0x61, 0x71, 0x02, 0x33, 0xA4, 0xBD, 0xCD, 0x7B, 0x55, 0x98, + 0xF4, 0xBF, 0xB6, 0x9D, 0xF5, 0x3E, 0xF4, 0xD6, 0xE5, 0x99, 0x7A, 0x7E, + 0xBE, 0xF0, 0x21, 0x21, 0x7B, 0x10, 0x62, 0x44, 0x81, 0x5D, 0x6F, 0xE7, + 0xE3, 0x92, 0x01, 0x42, 0x04, 0x49, 0x22, 0xFA, 0xD0, 0x76, 0x96, 0x48, + 0xC8, 0xB4, 0xB1, 0x89, 0x9C, 0x0F, 0xBD, 0xF3, 0x5D, 0x6F, 0x43, 0x88, + 0x4D, 0xD7, 0x1B, 0xAD, 0x32, 0x89, 0xC0, 0xAC, 0x8D, 0x36, 0xC6, 0xEC, + 0xCB, 0x97, 0x3C, 0x33, 0x69, 0xDD, 0x4A, 0x29, 0x42, 0xE0, 0xD4, 0x46, + 0x14, 0x88, 0x65, 0x9E, 0x2D, 0x37, 0xB5, 0x40, 0x2C, 0x8B, 0x2C, 0x01, + 0xD1, 0xD3, 0x3E, 0xE1, 0x14, 0x2C, 0x94, 0xAC, 0xEB, 0x16, 0x11, 0xCA, + 0xC2, 0x5C, 0x5E, 0x71, 0x91, 0x67, 0x42, 0x60, 0x6E, 0xD4, 0x62, 0xB9, + 0xD8, 0xD6, 0x5B, 0x25, 0x65, 0xEF, 0xDC, 0x8F, 0x7F, 0xF8, 0xF1, 0xE1, + 0x6C, 0xF2, 0xF9, 0x97, 0xCF, 0xA4, 0x10, 0x27, 0xC7, 0xB3, 0x1D, 0x06, + 0x75, 0x70, 0x7D, 0x7F, 0xD3, 0x1D, 0xDF, 0x25, 0x3B, 0x3C, 0x28, 0xF7, + 0x85, 0x10, 0x23, 0xA6, 0xDC, 0x2A, 0x49, 0x5D, 0x19, 0x55, 0xE5, 0x06, + 0x00, 0x9C, 0xF3, 0x37, 0xCB, 0x0D, 0x02, 0x7A, 0x1F, 0xEE, 0xDE, 0x39, + 0x38, 0x3A, 0x9C, 0xA5, 0xC8, 0x92, 0xA6, 0xA5, 0x69, 0xD8, 0xB5, 0x4F, + 0x1D, 0x50, 0x88, 0x18, 0xA3, 0x40, 0x14, 0x84, 0x21, 0x44, 0x1F, 0x39, + 0x46, 0x48, 0x48, 0xD7, 0x1D, 0xA0, 0x2F, 0x42, 0x88, 0xD6, 0x86, 0x64, + 0xE4, 0xFC, 0x26, 0xED, 0x4A, 0x0D, 0x00, 0x46, 0x19, 0x99, 0xE9, 0xD6, + 0x9C, 0x0E, 0x70, 0xA7, 0xCA, 0xB4, 0xFB, 0x5D, 0x12, 0x02, 0x18, 0xAC, + 0xF3, 0x24, 0x84, 0xD6, 0x4A, 0x4B, 0xCA, 0x32, 0x95, 0xA0, 0x6C, 0xF0, + 0x5B, 0xD8, 0xAE, 0xDF, 0x09, 0x61, 0xB7, 0x7F, 0xC4, 0x3B, 0xFC, 0x48, + 0xEA, 0x70, 0x0F, 0x12, 0x28, 0xBB, 0x1C, 0x2A, 0xB5, 0xC6, 0xF6, 0xF2, + 0xB0, 0x29, 0xD0, 0x24, 0x75, 0x79, 0xE7, 0x83, 0xF7, 0xB1, 0xB7, 0x2E, + 0x0E, 0xDE, 0x50, 0x90, 0xBC, 0x97, 0x53, 0xE0, 0xA4, 0x37, 0xD6, 0x73, + 0xE9, 0xF6, 0x02, 0xC7, 0x41, 0xCA, 0x39, 0x1D, 0x1D, 0x0C, 0xB8, 0x1F, + 0x54, 0xC4, 0x10, 0x01, 0x05, 0x84, 0x48, 0x91, 0x31, 0xB1, 0x14, 0x84, + 0x88, 0x0C, 0xC8, 0xC3, 0xB2, 0xDB, 0xA9, 0x57, 0xA7, 0xCA, 0x92, 0x99, + 0xB9, 0xD9, 0xD6, 0x6D, 0xD7, 0x6D, 0xEB, 0x4E, 0x0B, 0xA6, 0x71, 0xA5, + 0x28, 0x28, 0x29, 0xBB, 0xDE, 0xD6, 0x6D, 0x5F, 0x15, 0x46, 0x20, 0x3A, + 0x1F, 0xB4, 0x22, 0xA5, 0xC8, 0x76, 0x9D, 0xD2, 0x12, 0x50, 0xD4, 0x4D, + 0xA7, 0x09, 0x09, 0x04, 0x08, 0x88, 0xC1, 0xEF, 0x36, 0x03, 0x44, 0x06, + 0xEF, 0x5D, 0xA2, 0x40, 0x84, 0x10, 0x03, 0x27, 0xAE, 0xF4, 0x90, 0xCC, + 0x26, 0x0C, 0xA6, 0x52, 0x72, 0x8F, 0xA9, 0x09, 0x21, 0x38, 0x17, 0xAC, + 0x8F, 0x2E, 0x91, 0xA8, 0x88, 0xDE, 0xBA, 0x33, 0x2B, 0x8A, 0xFC, 0xE5, + 0xE9, 0xCD, 0x7F, 0xF9, 0x4F, 0x7F, 0xBC, 0x5E, 0x6D, 0xCA, 0xB2, 0xB8, + 0x73, 0x74, 0x70, 0x73, 0xB3, 0x04, 0xCE, 0x8C, 0x96, 0xDE, 0x79, 0x44, + 0x5C, 0x6D, 0x6A, 0x1F, 0xF8, 0xE4, 0xF8, 0xA0, 0xEF, 0xFA, 0xB3, 0x8B, + 0xEB, 0xAA, 0xC8, 0x17, 0xEB, 0xED, 0xD5, 0xE5, 0x95, 0x29, 0x8B, 0xBE, + 0xEF, 0xFB, 0xDE, 0x0A, 0xA2, 0x64, 0xCF, 0xF3, 0x7B, 0xDF, 0x7F, 0xF7, + 0xDD, 0x47, 0xF7, 0x6F, 0x16, 0x9B, 0xCE, 0x05, 0x60, 0x0E, 0xD6, 0x36, + 0x75, 0x7B, 0xB3, 0xAE, 0xEF, 0xDD, 0xBF, 0x33, 0x2A, 0xF3, 0xAB, 0xCB, + 0x8B, 0xAF, 0x1F, 0x3F, 0xDB, 0x34, 0x4E, 0x08, 0xFA, 0xE9, 0xEF, 0xFF, + 0xDE, 0xF9, 0xF9, 0xD5, 0xFF, 0xFE, 0x7F, 0xFE, 0xE5, 0x8F, 0x7F, 0xFC, + 0x83, 0xD1, 0xA8, 0x2C, 0x0A, 0xF3, 0xFE, 0x3B, 0xF7, 0x4F, 0xCF, 0xAE, + 0xEE, 0xDD, 0x39, 0xC8, 0x12, 0xC5, 0x3D, 0x99, 0xB0, 0x84, 0xF8, 0xF0, + 0xFE, 0xC9, 0xC1, 0x6C, 0x52, 0x77, 0x7D, 0x72, 0xE5, 0x41, 0xC4, 0xBE, + 0x77, 0x1F, 0x3C, 0x7A, 0xF8, 0xFE, 0x3B, 0x6F, 0x5D, 0x5F, 0xDD, 0x7C, + 0xF5, 0xE4, 0x85, 0x56, 0xD2, 0xF6, 0xF6, 0xEC, 0xFC, 0x2A, 0xCD, 0x2E, + 0x78, 0x28, 0xC9, 0x59, 0x12, 0x75, 0xCE, 0x2A, 0xA5, 0x05, 0xA2, 0xB5, + 0x7E, 0x94, 0x65, 0xF3, 0xD9, 0xB4, 0xB7, 0xEE, 0xF5, 0xD9, 0x25, 0x47, + 0xB0, 0xD6, 0x65, 0xB9, 0x18, 0x7A, 0xA6, 0x42, 0x10, 0x51, 0xF0, 0x21, + 0xCD, 0x8B, 0x89, 0x59, 0x1A, 0x43, 0x52, 0x28, 0xA6, 0xAE, 0x77, 0x16, + 0xAD, 0x40, 0x74, 0x2E, 0xC4, 0x10, 0xF3, 0xC2, 0x14, 0x45, 0x2E, 0x49, + 0xC4, 0x10, 0xBB, 0xCE, 0x7A, 0xE7, 0xFA, 0xDE, 0x76, 0x5D, 0x64, 0x4E, + 0x33, 0x9F, 0xC0, 0x00, 0x08, 0x18, 0x62, 0xBC, 0xBA, 0x5E, 0x2E, 0xD7, + 0xCD, 0x6C, 0x52, 0x85, 0x90, 0xC0, 0x12, 0x20, 0xDE, 0xD0, 0xC7, 0x11, + 0x12, 0xC9, 0x25, 0x82, 0xD8, 0x61, 0x17, 0x6F, 0x0D, 0xBA, 0x00, 0x00, + 0xAC, 0xF7, 0x75, 0xD3, 0x27, 0x8C, 0x08, 0x30, 0x38, 0x1F, 0xDA, 0xDE, + 0x4A, 0x21, 0xAE, 0x96, 0x9B, 0x10, 0x62, 0x64, 0x16, 0x42, 0xF4, 0x2E, + 0x74, 0xAB, 0x3A, 0x04, 0xC7, 0x51, 0x28, 0xA5, 0x7C, 0x88, 0xFB, 0xAC, + 0x6F, 0xDB, 0xF4, 0xD6, 0xBA, 0xC3, 0xD9, 0x38, 0x9D, 0xDF, 0x4D, 0xDB, + 0x2E, 0x56, 0x9B, 0x59, 0x95, 0x17, 0x99, 0x0E, 0xDE, 0x3B, 0x21, 0xBC, + 0x0F, 0xC9, 0x85, 0x40, 0x2B, 0x25, 0x04, 0x56, 0x45, 0x96, 0x64, 0x76, + 0x18, 0x30, 0xE9, 0x68, 0xF6, 0xD6, 0x7A, 0xE7, 0xF2, 0xDC, 0xC4, 0xC8, + 0x3E, 0x04, 0x21, 0x92, 0x17, 0x1A, 0x32, 0x70, 0x52, 0x4C, 0x4C, 0xD9, + 0x8D, 0x75, 0x4E, 0x08, 0x14, 0x11, 0x26, 0xA3, 0x62, 0x3E, 0xAD, 0x10, + 0xC5, 0x72, 0xB3, 0xF5, 0x3E, 0xBC, 0x7C, 0x75, 0x3E, 0x1E, 0x8F, 0xA6, + 0x93, 0x51, 0xDF, 0xF7, 0x9F, 0x7F, 0xF5, 0x94, 0x08, 0x8D, 0xD1, 0x92, + 0x48, 0x6B, 0xB5, 0xDA, 0xD6, 0xC9, 0xE1, 0x6C, 0x80, 0x52, 0x01, 0x00, + 0xA2, 0x90, 0xC2, 0x20, 0xF6, 0xBD, 0x4B, 0x02, 0x9F, 0xE9, 0x42, 0x42, + 0x9A, 0xD3, 0x21, 0x5A, 0xF6, 0x08, 0x80, 0x00, 0x99, 0xD6, 0x44, 0xA2, + 0xED, 0xFA, 0xD7, 0xE7, 0xD7, 0x80, 0x5C, 0x55, 0x65, 0x91, 0x65, 0x88, + 0x9C, 0xEA, 0x92, 0xB0, 0x9B, 0x5F, 0xD2, 0x77, 0x32, 0xA1, 0x81, 0x09, + 0x09, 0x10, 0xF7, 0x61, 0x6E, 0x68, 0x22, 0xF9, 0xB4, 0x8F, 0xDE, 0x28, + 0xBF, 0x02, 0x43, 0x80, 0x98, 0x7E, 0x9B, 0xFE, 0xE8, 0x4F, 0xFF, 0x0C, + 0x76, 0xC1, 0x36, 0xC5, 0xAF, 0x1D, 0xA1, 0x0C, 0x77, 0xB3, 0x99, 0x41, + 0x40, 0x4E, 0x0A, 0xA1, 0x95, 0x14, 0x02, 0x93, 0x64, 0x8E, 0xD8, 0xE9, + 0x31, 0xF1, 0x77, 0x81, 0x14, 0x7F, 0xEF, 0x63, 0x9F, 0xA6, 0xEF, 0x4A, + 0xCB, 0x80, 0xF8, 0xE6, 0xBF, 0xF3, 0x60, 0xE1, 0x11, 0x87, 0x08, 0x05, + 0x00, 0x00, 0xC9, 0xD1, 0x63, 0xB5, 0x6D, 0x9B, 0xD6, 0x5A, 0x37, 0x84, + 0x83, 0x24, 0xFD, 0x11, 0x86, 0xFC, 0x8E, 0x63, 0x64, 0x1F, 0x38, 0x84, + 0x98, 0xA4, 0xD6, 0xF6, 0xC6, 0x47, 0xBF, 0xFB, 0xEA, 0x4A, 0xD2, 0xA8, + 0xCC, 0x10, 0x51, 0x26, 0xAC, 0x0A, 0x20, 0xEE, 0x24, 0x59, 0xF6, 0xB3, + 0x61, 0x66, 0x4E, 0xF3, 0xE9, 0x14, 0xCB, 0x00, 0x80, 0x48, 0xBC, 0x7A, + 0xF1, 0x7C, 0xBB, 0xDE, 0x6C, 0x9A, 0xFE, 0x68, 0x3E, 0x26, 0x42, 0xAD, + 0xD4, 0xA6, 0x69, 0x6E, 0x56, 0xF5, 0xA6, 0xE9, 0x7B, 0x17, 0x96, 0xEB, + 0x66, 0xB3, 0x69, 0x23, 0xEF, 0x74, 0x95, 0x10, 0xAD, 0xF3, 0x09, 0xA2, + 0xCD, 0xCC, 0x52, 0xC9, 0xA4, 0xDF, 0x90, 0xAC, 0xED, 0x77, 0xA5, 0xF0, + 0x70, 0xBD, 0x49, 0xB2, 0x43, 0x08, 0xA1, 0xB5, 0x0E, 0x3E, 0xA4, 0x10, + 0x53, 0x16, 0xA6, 0x2C, 0x73, 0x66, 0x6E, 0x3B, 0xCB, 0x0C, 0x6D, 0x6F, + 0x7B, 0xEB, 0x52, 0x5C, 0x1B, 0x57, 0xC5, 0x1F, 0xFE, 0xFC, 0x93, 0xC7, + 0xDF, 0xBE, 0xFE, 0xF6, 0xF5, 0xE2, 0x7F, 0xFC, 0x1F, 0xFE, 0xD9, 0xDF, + 0xFD, 0xDD, 0xA7, 0x77, 0x4E, 0x8E, 0xCB, 0xB2, 0xF8, 0xF8, 0x83, 0x87, + 0x0F, 0xEE, 0x1F, 0x97, 0x45, 0x26, 0x10, 0x8B, 0x22, 0x3F, 0x3C, 0x9C, + 0x6D, 0x37, 0xCD, 0xF9, 0xC5, 0x75, 0xD7, 0xD9, 0xBA, 0x69, 0x53, 0x7C, + 0xD9, 0xB6, 0x7D, 0xD7, 0xDB, 0xBA, 0x6E, 0xAB, 0x6A, 0xA4, 0xB5, 0x5E, + 0x6F, 0xB6, 0x3F, 0xF8, 0xE8, 0xD1, 0x4F, 0x7F, 0xFC, 0x3D, 0xEF, 0xB9, + 0xAE, 0xBB, 0xBE, 0xEF, 0xAF, 0xAF, 0x16, 0x4D, 0xDB, 0x55, 0x55, 0x8E, + 0x08, 0x52, 0xA9, 0x8B, 0xF3, 0xCB, 0xD5, 0xA6, 0xFE, 0xFA, 0xF1, 0xF3, + 0xAF, 0xBF, 0x7E, 0x56, 0x56, 0xD5, 0x47, 0x9F, 0x7C, 0x9C, 0x97, 0xE5, + 0x6C, 0x3A, 0xFD, 0xFC, 0x37, 0xDF, 0x14, 0x79, 0x56, 0x16, 0xC5, 0xD1, + 0x7C, 0x9A, 0x65, 0xBA, 0xEB, 0xFB, 0xF9, 0x64, 0x1C, 0x63, 0x72, 0x8A, + 0x6B, 0x94, 0xA4, 0xDC, 0x28, 0x25, 0x65, 0x91, 0x67, 0x5A, 0xA9, 0xD4, + 0xE0, 0x13, 0x42, 0x48, 0x29, 0x0E, 0x67, 0x23, 0xAD, 0xD5, 0x74, 0x3A, + 0xBE, 0x73, 0x7C, 0x10, 0x23, 0xD7, 0x75, 0x7B, 0x73, 0xB3, 0xEC, 0xFA, + 0x0E, 0x51, 0x10, 0xC9, 0x84, 0xEA, 0x72, 0xCE, 0xA5, 0x4E, 0x79, 0x8A, + 0xDA, 0xE3, 0xF1, 0xE8, 0x60, 0x3E, 0xED, 0x7A, 0x9B, 0x65, 0x59, 0x8C, + 0x4C, 0x52, 0xA0, 0xC0, 0x22, 0xCF, 0x8C, 0xD1, 0xC0, 0x9C, 0xC0, 0x3D, + 0x7B, 0xAB, 0xF0, 0x74, 0xF2, 0x34, 0x6D, 0x9F, 0x6A, 0x13, 0xA5, 0x64, + 0x04, 0x76, 0xD6, 0x6D, 0x36, 0x75, 0x0C, 0xBE, 0x6B, 0x3B, 0xAD, 0x95, + 0x24, 0x0A, 0x91, 0x43, 0x64, 0xE7, 0x83, 0x0F, 0x31, 0xD9, 0x4A, 0x10, + 0xA1, 0xF3, 0x01, 0x51, 0xBC, 0xFB, 0xCE, 0xFD, 0x51, 0x59, 0x24, 0x8B, + 0xA3, 0xE1, 0xD8, 0x63, 0x88, 0x83, 0x9C, 0x0A, 0xA2, 0xD8, 0x35, 0x91, + 0xBF, 0x7B, 0x40, 0xA7, 0xC0, 0xBA, 0x6D, 0xBA, 0xBF, 0xFD, 0xE5, 0x97, + 0x6D, 0xE7, 0x8A, 0x3C, 0x1B, 0x57, 0xB9, 0x75, 0x3E, 0x46, 0x08, 0x21, + 0x24, 0x26, 0x75, 0xD7, 0x3B, 0x25, 0x15, 0x00, 0x93, 0x40, 0x12, 0xC2, + 0x79, 0x4F, 0x44, 0x4A, 0x52, 0xDF, 0xFB, 0xB4, 0x3C, 0x42, 0xE4, 0x18, + 0xB9, 0x2C, 0x4C, 0x60, 0x76, 0xCE, 0xB7, 0x5D, 0xE7, 0x7D, 0x50, 0x24, + 0x32, 0xA3, 0x84, 0x40, 0xE7, 0xC3, 0x6A, 0x5D, 0x5B, 0xE7, 0x3A, 0xEB, + 0xB4, 0x94, 0x89, 0x0F, 0x94, 0x04, 0xBF, 0xD2, 0xF3, 0x84, 0x18, 0x42, + 0x08, 0x65, 0x9E, 0x31, 0xA0, 0x73, 0x0E, 0x00, 0x00, 0x41, 0x20, 0x5A, + 0xE7, 0x52, 0x91, 0xE1, 0x5C, 0xE8, 0xFA, 0x5E, 0x12, 0x4D, 0xC7, 0xE5, + 0xD1, 0x7C, 0x9C, 0x19, 0xDD, 0xF6, 0x36, 0xCF, 0x34, 0x32, 0x1F, 0x1E, + 0x4C, 0x62, 0xE0, 0xB3, 0x8B, 0x9B, 0xAB, 0xAB, 0xC5, 0x72, 0xB5, 0x49, + 0x9D, 0xAF, 0x10, 0xD8, 0x7B, 0x77, 0x75, 0xBD, 0x22, 0x12, 0x8B, 0xD5, + 0xA6, 0xDE, 0x76, 0x1C, 0x63, 0x08, 0x61, 0x5B, 0xB7, 0xCE, 0xB9, 0xAE, + 0xB7, 0x6D, 0x67, 0x53, 0xCE, 0x97, 0x68, 0x3C, 0x00, 0x89, 0x1E, 0x93, + 0x72, 0x09, 0xE0, 0x44, 0x25, 0x56, 0x32, 0x19, 0xC7, 0x28, 0x29, 0x8D, + 0x56, 0xEB, 0x4D, 0xFD, 0xF2, 0xD5, 0xC5, 0xCD, 0x72, 0x45, 0x92, 0x8A, + 0x3C, 0x4B, 0x78, 0xA3, 0x04, 0xDB, 0x02, 0xE0, 0xFD, 0xC6, 0x8F, 0x31, + 0x71, 0xC2, 0x41, 0x26, 0x1B, 0x36, 0x81, 0x3B, 0x2B, 0x89, 0x81, 0xE2, + 0xF4, 0x9D, 0x78, 0x02, 0xE9, 0xD3, 0x06, 0x00, 0x90, 0xCC, 0x89, 0x44, + 0x08, 0x6F, 0x5A, 0x97, 0x43, 0x4F, 0x80, 0x71, 0x68, 0x23, 0xA5, 0x86, + 0x00, 0x13, 0x0D, 0x66, 0xE5, 0x42, 0x60, 0x8C, 0x10, 0x42, 0x44, 0x0C, + 0xB7, 0x31, 0x5F, 0xFF, 0xA9, 0x28, 0xB6, 0x7F, 0xEC, 0x50, 0x17, 0xA8, + 0x86, 0x55, 0x3E, 0xA8, 0xE0, 0xA7, 0x44, 0x6C, 0x27, 0x8A, 0xCF, 0x00, + 0xE0, 0x7D, 0x68, 0x7B, 0xEB, 0x9C, 0x0F, 0xBC, 0xCF, 0xAD, 0x86, 0xB8, + 0x0A, 0xC3, 0x62, 0x4A, 0x64, 0xFA, 0x7D, 0xB3, 0xFF, 0x0D, 0x9E, 0x36, + 0xBD, 0x96, 0x56, 0x32, 0x0C, 0xBC, 0x4E, 0x4E, 0x90, 0x96, 0xDE, 0x3A, + 0x22, 0x22, 0x14, 0x0C, 0x6F, 0xA0, 0x64, 0xE9, 0xE9, 0xC2, 0x10, 0x8A, + 0x86, 0x10, 0x93, 0x62, 0x66, 0xDA, 0x87, 0xAB, 0xF5, 0x56, 0x2B, 0x2A, + 0xA4, 0x6C, 0xBB, 0x7E, 0x54, 0xE6, 0x8B, 0xD5, 0x06, 0x18, 0x14, 0x89, + 0xA6, 0xB3, 0x6D, 0xE7, 0x36, 0x75, 0x17, 0x99, 0x83, 0x75, 0x46, 0xAB, + 0x18, 0xD9, 0x85, 0xA8, 0x32, 0xA3, 0x07, 0xDB, 0x94, 0xD4, 0xC9, 0xF6, + 0x80, 0xC0, 0x51, 0x58, 0x6B, 0x13, 0xB8, 0x64, 0x20, 0x3C, 0x5B, 0x1B, + 0x81, 0x63, 0x60, 0x00, 0x61, 0x6D, 0xAD, 0x94, 0x64, 0x80, 0x24, 0xFC, + 0x1F, 0xBC, 0x4F, 0x90, 0xDA, 0xC4, 0x5A, 0x4A, 0xFD, 0x52, 0xEF, 0xC2, + 0x83, 0x93, 0x99, 0x31, 0xEA, 0xD3, 0xAF, 0x5E, 0xFD, 0xF4, 0xF7, 0x3E, + 0xEA, 0xDA, 0x1A, 0x88, 0xEE, 0xDE, 0xBD, 0x13, 0x82, 0x1F, 0x8F, 0x47, + 0xC6, 0xE8, 0xAE, 0x6D, 0x81, 0x99, 0xA4, 0x6C, 0x36, 0xDB, 0xED, 0xB6, + 0xBE, 0xBA, 0x5E, 0xAE, 0xD6, 0xDB, 0x41, 0xC1, 0x0E, 0xA0, 0xEB, 0x9D, + 0x6F, 0x5A, 0x1F, 0x78, 0x6A, 0x0C, 0x02, 0xFF, 0xFC, 0x0F, 0x3E, 0xF9, + 0xDE, 0x47, 0x8F, 0x9C, 0x75, 0x5D, 0x6F, 0xEB, 0xBA, 0xB9, 0xB8, 0xB8, + 0x52, 0x92, 0xF2, 0xCC, 0x58, 0x1F, 0x5E, 0x9F, 0x5F, 0xF5, 0xBD, 0xCD, + 0xB3, 0xEC, 0xF9, 0xE9, 0xC5, 0xB6, 0x71, 0xF3, 0xC3, 0x03, 0xEF, 0x43, + 0xA6, 0x65, 0x79, 0x34, 0xEB, 0xAD, 0xFB, 0xF1, 0xEF, 0x7D, 0xF2, 0xEA, + 0xD5, 0xD9, 0xDD, 0x3B, 0x87, 0xEB, 0x4D, 0x5D, 0x96, 0xB9, 0x94, 0xE4, + 0xBC, 0x1F, 0x97, 0xC5, 0xF5, 0x6A, 0x53, 0xE6, 0xE6, 0x60, 0x5A, 0xD6, + 0x75, 0xC7, 0x00, 0x8B, 0xE5, 0x7A, 0x34, 0x2A, 0x01, 0xD1, 0x18, 0xDD, + 0x34, 0x5D, 0x8C, 0xD1, 0x28, 0x39, 0x1E, 0x15, 0x2E, 0x70, 0x96, 0x65, + 0x6D, 0x67, 0x7F, 0xF5, 0xE9, 0x6F, 0xD2, 0xF9, 0x5D, 0x37, 0x8D, 0xD6, + 0x3A, 0x33, 0x26, 0xF1, 0x25, 0x89, 0x44, 0x8C, 0x91, 0x88, 0x60, 0x98, + 0x1A, 0xD1, 0xF7, 0x3E, 0x7C, 0xF4, 0xE2, 0xD5, 0xB9, 0x73, 0x5E, 0x20, + 0x59, 0x6B, 0x81, 0x51, 0x6B, 0x35, 0x9D, 0x8C, 0x63, 0x8C, 0xCE, 0x3B, + 0x1F, 0x02, 0x00, 0xC5, 0x10, 0x52, 0x19, 0x21, 0x10, 0x39, 0x32, 0x09, + 0x11, 0xBC, 0x27, 0x42, 0xA9, 0x34, 0x33, 0x58, 0x17, 0x8C, 0xA6, 0x24, + 0xD9, 0xC8, 0xC0, 0xDE, 0xC7, 0x54, 0x1E, 0x56, 0x65, 0x0E, 0xA9, 0x7F, + 0x15, 0x7D, 0xE4, 0xD8, 0xB6, 0x7D, 0x60, 0xF0, 0x21, 0x41, 0xA3, 0x61, + 0xF8, 0x03, 0x38, 0x0C, 0xEC, 0x77, 0xF9, 0x41, 0x00, 0x4E, 0xE8, 0x80, + 0xD4, 0xF2, 0x4F, 0x8B, 0x2D, 0x59, 0x6A, 0xA5, 0x48, 0x97, 0xDC, 0xB5, + 0x88, 0x30, 0x04, 0x00, 0x14, 0x21, 0xB2, 0xF3, 0x51, 0x6B, 0x16, 0x8C, + 0x44, 0xC2, 0xFB, 0x68, 0x8C, 0x49, 0x2B, 0x5C, 0xEE, 0x6C, 0xB2, 0x2B, + 0x25, 0x63, 0xA6, 0xB5, 0xD6, 0xD6, 0x07, 0xEB, 0x9D, 0x73, 0x3E, 0xBD, + 0xB6, 0x10, 0xA0, 0x95, 0xF4, 0x81, 0x8D, 0x51, 0x44, 0xC2, 0xF9, 0x90, + 0x1A, 0xC4, 0x44, 0x22, 0xC6, 0xC0, 0x0C, 0x59, 0xA6, 0x98, 0xC1, 0x7B, + 0x46, 0x84, 0x10, 0xA3, 0x94, 0x62, 0x9A, 0x55, 0x5D, 0xEF, 0xBA, 0xCE, + 0xA2, 0x10, 0x46, 0x0A, 0x12, 0x22, 0xAD, 0x23, 0xA3, 0x35, 0x33, 0x37, + 0x4D, 0x57, 0x95, 0x59, 0xD7, 0xF7, 0x4A, 0x52, 0x55, 0xE4, 0x4A, 0x11, + 0x33, 0xAC, 0x37, 0x8D, 0x94, 0x32, 0xF8, 0x50, 0xD7, 0x6D, 0x95, 0x1B, + 0xEF, 0xDC, 0x72, 0xB9, 0xDA, 0x6E, 0xB7, 0xF3, 0xD9, 0xC4, 0xF6, 0x56, + 0x30, 0x3B, 0x67, 0xAD, 0x22, 0xAD, 0xA4, 0xB7, 0xAE, 0xB6, 0x2E, 0x46, + 0xBE, 0x5E, 0xAE, 0xEF, 0x9D, 0x1C, 0x4D, 0xC6, 0xE5, 0xBE, 0xD6, 0xEE, + 0x9A, 0x2E, 0x26, 0x99, 0x4C, 0x00, 0x04, 0x90, 0x92, 0x7A, 0xE7, 0x30, + 0x55, 0xA6, 0x31, 0xC6, 0x18, 0x49, 0x88, 0x51, 0x59, 0x84, 0x18, 0x4E, + 0xCF, 0xAE, 0xEA, 0xA6, 0x7D, 0xE7, 0xC1, 0xDD, 0x94, 0x8D, 0x04, 0x1E, + 0xB2, 0x86, 0xB4, 0x9D, 0x89, 0x92, 0x9C, 0x19, 0x8B, 0xD4, 0x16, 0x47, + 0x88, 0x91, 0x5D, 0x42, 0x3A, 0xC7, 0xDF, 0xC6, 0x81, 0xC2, 0x2E, 0x5E, + 0x01, 0xC0, 0x30, 0x5E, 0x8C, 0x03, 0x1C, 0x66, 0x60, 0x18, 0x70, 0x7A, + 0x2E, 0x21, 0x62, 0xEA, 0xC2, 0x7A, 0xC8, 0x33, 0x95, 0xD8, 0x88, 0xC9, + 0x3C, 0x35, 0xB9, 0xA2, 0x21, 0xC2, 0xED, 0x01, 0xE5, 0x3F, 0xFC, 0xE0, + 0x9D, 0xA3, 0x84, 0x94, 0x6F, 0xE8, 0x44, 0xA9, 0xFF, 0x9D, 0xEA, 0x4D, + 0xA5, 0xC8, 0x5A, 0xC7, 0xCC, 0xD6, 0xF9, 0xCE, 0x3A, 0xEF, 0x23, 0x27, + 0xD9, 0x5C, 0x48, 0xD4, 0xF1, 0xDB, 0x43, 0xC9, 0xFD, 0x55, 0xA4, 0xC4, + 0x71, 0xE0, 0x81, 0xFA, 0x1D, 0xB4, 0x35, 0x37, 0xDA, 0x68, 0x19, 0x99, + 0x63, 0x88, 0xD6, 0xF9, 0x28, 0x29, 0xE5, 0x92, 0xE9, 0xC9, 0x79, 0x30, + 0x4C, 0x12, 0x00, 0x10, 0x62, 0x14, 0x3B, 0x47, 0x38, 0x4E, 0xA5, 0x7E, + 0x64, 0x66, 0x26, 0x46, 0x00, 0xB0, 0xCE, 0xF5, 0xBD, 0xD7, 0x4A, 0xAE, + 0xB7, 0xDD, 0xB8, 0xCA, 0x8A, 0x22, 0x5F, 0xAC, 0xB7, 0x91, 0x59, 0x29, + 0x59, 0xE5, 0xC6, 0x07, 0x5E, 0xD7, 0x1D, 0x03, 0x24, 0xBE, 0x05, 0x0B, + 0x50, 0x42, 0x18, 0xAD, 0x81, 0x59, 0x20, 0xF1, 0x4E, 0x6D, 0x06, 0x11, + 0x22, 0xC4, 0x84, 0x59, 0x8B, 0x91, 0xDB, 0xB6, 0x37, 0xC6, 0x10, 0x91, + 0x1F, 0xB8, 0x35, 0x81, 0x88, 0xAC, 0x75, 0x92, 0xA8, 0xEB, 0xDD, 0xEB, + 0x8B, 0x45, 0x99, 0xEB, 0x22, 0xD3, 0x75, 0xA3, 0xD2, 0x24, 0x44, 0x30, + 0x4B, 0xA5, 0x32, 0xA5, 0xFF, 0xF1, 0x4F, 0xBF, 0xF7, 0xD5, 0xD3, 0xD7, + 0x99, 0x31, 0xC7, 0x07, 0xE3, 0xCB, 0xEB, 0xED, 0x27, 0x9F, 0x7C, 0x3C, + 0x9F, 0x4D, 0xFA, 0xBE, 0x8D, 0x91, 0xA5, 0xD2, 0x99, 0xC0, 0x64, 0xEE, + 0x7B, 0xF6, 0xF8, 0xDB, 0x6F, 0x9E, 0xBD, 0xF6, 0x3E, 0x8E, 0x26, 0x63, + 0x25, 0x65, 0xD3, 0xB6, 0x65, 0xA5, 0xA5, 0x29, 0xB6, 0x4D, 0xAB, 0x94, + 0x3E, 0x9A, 0x97, 0x1F, 0x3C, 0x7A, 0x6B, 0x3C, 0x2A, 0x9F, 0xBF, 0x38, + 0xED, 0xDA, 0xFE, 0xF9, 0xAB, 0x73, 0x04, 0xBC, 0x73, 0x30, 0xF5, 0xB6, + 0x37, 0xD3, 0x89, 0xED, 0xEC, 0xB6, 0xED, 0x97, 0xCB, 0xED, 0xC9, 0x49, + 0x5E, 0x8D, 0xC6, 0x9D, 0xF5, 0xE7, 0xE7, 0x97, 0x75, 0xDD, 0xF4, 0x5D, + 0x77, 0xF7, 0xEE, 0xF1, 0xEB, 0xF3, 0x2B, 0x12, 0xF4, 0xBD, 0x8F, 0xDF, + 0x7B, 0xF2, 0xFC, 0xF5, 0x7B, 0x6F, 0xDF, 0xEB, 0x7B, 0x9B, 0xE7, 0x19, + 0x87, 0xE8, 0x43, 0x9C, 0x4D, 0x47, 0x5D, 0xEF, 0xB4, 0x56, 0xB3, 0x71, + 0xE1, 0x43, 0xD4, 0x0A, 0x97, 0x9B, 0x6E, 0xB1, 0xAE, 0xCB, 0x22, 0x9F, + 0x4F, 0x47, 0x08, 0x68, 0xBD, 0x57, 0x92, 0xBE, 0xFC, 0xFA, 0xE9, 0x74, + 0x3A, 0x7E, 0xEF, 0x9D, 0xB7, 0xCE, 0xCE, 0xAF, 0x9E, 0x3E, 0x7B, 0xC1, + 0x91, 0x63, 0xE4, 0xAE, 0xED, 0xCB, 0x3C, 0x8F, 0x31, 0x00, 0x62, 0x8C, + 0x60, 0x63, 0xD4, 0x02, 0x89, 0xD9, 0x3B, 0x47, 0x44, 0x9B, 0x6D, 0xFD, + 0xEA, 0xF4, 0xAC, 0x28, 0x0A, 0x00, 0xB0, 0xCE, 0x87, 0x10, 0xB7, 0x75, + 0x63, 0x9D, 0x17, 0x88, 0x45, 0x6E, 0x04, 0x0A, 0x17, 0xBC, 0x92, 0xB2, + 0xB7, 0xD6, 0x5B, 0xA7, 0x95, 0x70, 0x3E, 0x3A, 0xEF, 0x03, 0xD3, 0x38, + 0xCB, 0xD3, 0xF4, 0xA0, 0xEB, 0x2D, 0x21, 0x06, 0x8E, 0xCE, 0xDB, 0x22, + 0xD3, 0x56, 0x80, 0xB3, 0x69, 0xDC, 0x11, 0x8A, 0xDC, 0xB4, 0x1D, 0x33, + 0x0A, 0xEF, 0xC2, 0x72, 0xBD, 0x4D, 0x39, 0xFE, 0xAE, 0xC3, 0x3D, 0x34, + 0xB9, 0x31, 0x22, 0x0B, 0xE6, 0x18, 0x71, 0xE8, 0xF6, 0x0E, 0xC8, 0x0C, + 0x06, 0xA0, 0xE1, 0xE8, 0x1F, 0x68, 0xC2, 0x79, 0x96, 0x01, 0x80, 0x73, + 0x3E, 0xC4, 0x68, 0xB4, 0x2A, 0x72, 0xF2, 0x81, 0x63, 0x8C, 0x99, 0xD1, + 0x31, 0xC6, 0x28, 0xA0, 0x77, 0x7E, 0x8F, 0x90, 0x42, 0x4C, 0x28, 0xA8, + 0x30, 0x8C, 0xFC, 0x45, 0xC2, 0x1E, 0x3A, 0xA3, 0x54, 0x7E, 0x34, 0x4B, + 0x07, 0x58, 0x8C, 0xD1, 0x5A, 0x6B, 0xB2, 0x2C, 0x8B, 0xBA, 0x87, 0x04, + 0xE5, 0xE5, 0x10, 0x22, 0x22, 0x44, 0x00, 0x21, 0x50, 0x6B, 0xD9, 0x75, + 0x0E, 0x87, 0x1E, 0xB3, 0x88, 0x81, 0x59, 0x70, 0x0C, 0x71, 0xDB, 0xB4, + 0x87, 0xD9, 0xC4, 0xA8, 0x21, 0xA1, 0x93, 0x89, 0x84, 0x17, 0x58, 0x10, + 0x5D, 0x2E, 0x36, 0x31, 0xF2, 0xC1, 0x74, 0xA4, 0x94, 0x52, 0x8A, 0x36, + 0xDB, 0x76, 0xBD, 0xA9, 0xB3, 0xCC, 0x28, 0x25, 0x25, 0x49, 0x00, 0x48, + 0x7E, 0xA3, 0x07, 0xB3, 0x89, 0x96, 0x42, 0x11, 0x52, 0xA6, 0x57, 0x9B, + 0x7A, 0xB3, 0xA9, 0x67, 0xE3, 0x92, 0x08, 0x9D, 0x75, 0x4D, 0x67, 0x37, + 0xDB, 0xFA, 0xF4, 0x35, 0x28, 0x49, 0x24, 0x89, 0x48, 0x38, 0xEB, 0xCF, + 0x2F, 0x6F, 0x6E, 0x16, 0xEB, 0x3B, 0xC7, 0xF3, 0x32, 0xCF, 0x8C, 0x56, + 0x29, 0x85, 0x8C, 0x21, 0x18, 0x2D, 0x81, 0x21, 0xCB, 0x74, 0x6F, 0x5D, + 0x5D, 0xB7, 0x52, 0xC9, 0xF1, 0xA8, 0x5A, 0xAF, 0xEB, 0xD7, 0x67, 0xD7, + 0xB3, 0xF9, 0x44, 0x92, 0xA0, 0x37, 0xA9, 0xC9, 0x90, 0x91, 0x08, 0x44, + 0x42, 0x91, 0x80, 0xE5, 0x09, 0xFE, 0x2A, 0x52, 0xC6, 0xB4, 0x03, 0x6C, + 0xC5, 0x5B, 0x56, 0xD9, 0xC3, 0x50, 0x00, 0x40, 0xEE, 0xA3, 0x4C, 0xFA, + 0x81, 0x40, 0x91, 0xB2, 0x13, 0xA3, 0xA4, 0x0F, 0x91, 0xE3, 0xC0, 0xC9, + 0x94, 0x34, 0x50, 0x4F, 0xA5, 0xA4, 0x84, 0x03, 0x90, 0x92, 0x12, 0xD2, + 0x62, 0x9F, 0x28, 0xFD, 0x6E, 0xE4, 0xBA, 0x9D, 0x88, 0xE1, 0x2E, 0x5E, + 0xEC, 0xB9, 0x47, 0xFB, 0xEC, 0x29, 0xA1, 0xDA, 0x88, 0xC8, 0x18, 0x95, + 0xFA, 0x65, 0x00, 0x4E, 0x08, 0x88, 0x01, 0x77, 0xBE, 0x45, 0xC0, 0x1C, + 0x71, 0xD0, 0xE0, 0x18, 0x5A, 0x73, 0xCC, 0x69, 0x55, 0x0C, 0x36, 0xF7, + 0x98, 0xC4, 0x0C, 0x87, 0x7E, 0x0D, 0xF7, 0xBD, 0xE3, 0x9D, 0xAA, 0x7A, + 0xF2, 0x58, 0x14, 0x28, 0x50, 0x88, 0x10, 0x62, 0xE0, 0xB0, 0x47, 0xD9, + 0x25, 0x7D, 0xF7, 0x74, 0xED, 0x49, 0xA9, 0x4E, 0x08, 0xDC, 0x8B, 0x11, + 0x49, 0x29, 0xA7, 0x93, 0x92, 0xBC, 0xAA, 0x5B, 0xAB, 0x95, 0x4C, 0x79, + 0x72, 0x9E, 0xE9, 0x10, 0xE2, 0x9D, 0x83, 0xCA, 0x3A, 0x3E, 0x3D, 0xBF, + 0x89, 0x1C, 0xB5, 0xD4, 0x4A, 0x2B, 0x44, 0x0C, 0x43, 0xA3, 0x2D, 0x38, + 0xEF, 0x77, 0x89, 0x64, 0x48, 0xFD, 0xCE, 0x84, 0x51, 0x9A, 0x4E, 0x46, + 0x21, 0x06, 0x66, 0xEC, 0x9D, 0x43, 0x10, 0x24, 0x41, 0x4A, 0x31, 0x2A, + 0x4B, 0xE7, 0x5C, 0xDB, 0x59, 0x44, 0x40, 0x21, 0x94, 0x56, 0x7D, 0xEF, + 0xB4, 0x92, 0xA9, 0xDB, 0x1D, 0x22, 0x0B, 0x41, 0xEF, 0x3E, 0x3A, 0x59, + 0x6D, 0xB6, 0xBF, 0xFA, 0xFC, 0xD9, 0x8F, 0x3E, 0x79, 0x3F, 0x2F, 0xCB, + 0xF3, 0xAB, 0xF5, 0xC1, 0x6C, 0xE4, 0xBD, 0x57, 0x5A, 0x93, 0x54, 0xC9, + 0x0E, 0x15, 0x09, 0x9D, 0xB3, 0xB3, 0xD9, 0xB4, 0x1C, 0x8F, 0xCE, 0xCF, + 0xAF, 0x19, 0x71, 0x36, 0x9D, 0xDC, 0xBB, 0x7F, 0x92, 0x65, 0x99, 0x75, + 0xA1, 0x73, 0x7E, 0x32, 0x2A, 0xEE, 0xDF, 0x39, 0x70, 0xCE, 0x5D, 0x5E, + 0x5E, 0x5F, 0x9C, 0x5F, 0x45, 0x14, 0xC1, 0xBA, 0x0F, 0xDE, 0x7F, 0x90, + 0x67, 0x19, 0x12, 0x5D, 0xAF, 0x9A, 0x2F, 0xBE, 0x7A, 0xFA, 0xE9, 0xE7, + 0xDF, 0xBC, 0xF7, 0xFE, 0xBB, 0x6D, 0xEF, 0xB4, 0x31, 0xE3, 0xF1, 0xE8, + 0xE2, 0xEA, 0x7A, 0xBB, 0x69, 0xFA, 0xDE, 0x5E, 0xDD, 0x2C, 0xF3, 0x3C, + 0xFF, 0xFA, 0x9B, 0x67, 0xDF, 0x7E, 0xFB, 0x7C, 0x7E, 0x70, 0x30, 0x9D, + 0x8C, 0xE7, 0xD3, 0x2A, 0x86, 0xD0, 0x34, 0x5D, 0x88, 0xF1, 0x60, 0x3E, + 0xD1, 0x8A, 0x48, 0x88, 0xF1, 0xA8, 0xE8, 0x7B, 0x0F, 0x0C, 0x89, 0x74, + 0xC9, 0xCC, 0xD7, 0x37, 0xAB, 0xA3, 0x83, 0x89, 0x56, 0x12, 0x01, 0x1E, + 0xBD, 0x7D, 0xFF, 0xB3, 0x2F, 0x9F, 0x20, 0xD2, 0x5B, 0x6F, 0xDD, 0x73, + 0xCE, 0x3D, 0x79, 0xF2, 0x5C, 0x4A, 0x0A, 0x3E, 0x44, 0x8E, 0x4A, 0x49, + 0xDF, 0xBA, 0xC0, 0x4C, 0x02, 0x42, 0x04, 0x21, 0x44, 0x5D, 0xD7, 0x9B, + 0x6D, 0x71, 0x75, 0x75, 0x53, 0x37, 0x2D, 0xA2, 0x48, 0xA8, 0x05, 0x60, + 0xEE, 0x7A, 0xAB, 0xB5, 0xCA, 0xB4, 0x0E, 0x31, 0x64, 0x5A, 0xA3, 0x10, + 0x6D, 0xDB, 0x49, 0x22, 0x95, 0x53, 0x5D, 0xD7, 0x89, 0x24, 0x9E, 0x44, + 0x47, 0xA5, 0x44, 0x29, 0x65, 0x86, 0x00, 0x0C, 0xB9, 0xCE, 0x44, 0x6F, + 0x95, 0x92, 0x05, 0x8A, 0xAE, 0x5B, 0x27, 0x0B, 0xF7, 0x18, 0x43, 0x59, + 0x14, 0xD6, 0xBA, 0xBE, 0xEF, 0xB7, 0x75, 0x3B, 0xD0, 0xFE, 0x86, 0x4D, + 0x32, 0x80, 0x78, 0x10, 0x19, 0x19, 0x41, 0xA0, 0xC0, 0x41, 0x34, 0x86, + 0x87, 0xC6, 0x03, 0x84, 0xF4, 0x95, 0xC1, 0xBF, 0x69, 0x89, 0xC4, 0x10, + 0x91, 0x19, 0xBA, 0xCE, 0x09, 0x81, 0x49, 0x8A, 0x23, 0x29, 0x68, 0x62, + 0x9A, 0x73, 0x0E, 0xE8, 0x22, 0x90, 0x52, 0xA4, 0x34, 0xA3, 0xEF, 0xDD, + 0x68, 0x54, 0xF9, 0x10, 0x4E, 0xCF, 0xAF, 0x05, 0x89, 0xE3, 0xC3, 0xC9, + 0x7A, 0x53, 0x9B, 0x22, 0x4B, 0x3C, 0x1C, 0xA5, 0x14, 0x09, 0xA1, 0x88, + 0x96, 0x5D, 0xEF, 0x5C, 0x30, 0x46, 0x4B, 0x99, 0x04, 0x03, 0xC1, 0x18, + 0x09, 0xCC, 0x02, 0x41, 0x1B, 0x19, 0x95, 0x70, 0x3E, 0x30, 0x0F, 0x40, + 0x6B, 0x25, 0x09, 0x99, 0x01, 0x58, 0x91, 0x70, 0x8E, 0x43, 0x08, 0x69, + 0x44, 0xE6, 0x7C, 0x18, 0x55, 0x85, 0x24, 0x2A, 0x32, 0x2D, 0x84, 0x68, + 0x5A, 0xAB, 0xB5, 0xFA, 0xE0, 0xDD, 0xB7, 0x4E, 0xCF, 0xAE, 0x25, 0x49, + 0x12, 0x58, 0x37, 0x2D, 0x00, 0x1F, 0x4C, 0xC7, 0x6F, 0x9D, 0x1C, 0xCE, + 0x27, 0xE5, 0x0E, 0x74, 0x89, 0x08, 0x68, 0xAD, 0xED, 0x7B, 0xDB, 0xF5, + 0x7D, 0xDB, 0x74, 0x1C, 0x63, 0xDD, 0x34, 0xAB, 0xF5, 0x96, 0x01, 0x42, + 0x88, 0x99, 0xD1, 0xD6, 0xB9, 0x6D, 0xDD, 0xF4, 0x2F, 0xFA, 0x49, 0x55, + 0x76, 0xCE, 0x36, 0x75, 0x2B, 0x84, 0x38, 0x98, 0x4F, 0xF4, 0x6C, 0x52, + 0x14, 0xC6, 0x18, 0x43, 0x52, 0x19, 0x63, 0x96, 0xAB, 0xF5, 0x72, 0xB5, + 0xAE, 0xCA, 0xE2, 0xE9, 0x8B, 0xD3, 0xF3, 0xAB, 0x9B, 0x9F, 0xFE, 0xE8, + 0x83, 0x4C, 0xAB, 0xAE, 0x73, 0xB0, 0xAB, 0xA8, 0xF6, 0x51, 0xC3, 0x87, + 0x18, 0x22, 0x87, 0x10, 0x94, 0x92, 0xE9, 0x76, 0x87, 0x18, 0x15, 0x51, + 0xDA, 0x59, 0xB8, 0x63, 0x79, 0xEF, 0x7A, 0x8D, 0x7D, 0x23, 0x00, 0x00, + 0x20, 0x00, 0x49, 0x44, 0x41, 0x54, 0x1F, 0xF4, 0xC7, 0xFF, 0xF2, 0x5F, + 0xA7, 0x6D, 0x4C, 0x98, 0xAA, 0x56, 0x56, 0x4A, 0x66, 0x8A, 0xD2, 0x73, + 0x95, 0xB9, 0x2E, 0x32, 0x93, 0x9A, 0xD0, 0x65, 0x9E, 0x25, 0x52, 0x18, + 0xA7, 0x0E, 0xC5, 0x3F, 0xE8, 0x9B, 0xFB, 0x26, 0x65, 0x7A, 0x13, 0x6B, + 0x93, 0x9F, 0xE3, 0x1B, 0xFA, 0x37, 0xEE, 0xC0, 0x10, 0x62, 0x47, 0x0B, + 0xDF, 0xC1, 0xA6, 0x12, 0xC9, 0x3C, 0x32, 0x60, 0x64, 0x0E, 0x71, 0x98, + 0x3A, 0xA6, 0x64, 0x5F, 0xD0, 0xED, 0xB8, 0xF9, 0x46, 0x98, 0x38, 0xEC, + 0x18, 0xE0, 0xFB, 0xA0, 0xE9, 0x63, 0x4C, 0xC3, 0x41, 0x66, 0x48, 0xD0, + 0xC7, 0x84, 0x36, 0x8A, 0xBB, 0x5B, 0x96, 0xF2, 0xB2, 0x74, 0x53, 0xCA, + 0x32, 0x2B, 0xF2, 0x2C, 0xB1, 0xD9, 0x73, 0x93, 0x29, 0x29, 0x95, 0x92, + 0x21, 0x84, 0xB3, 0xD3, 0x57, 0x8B, 0xE5, 0x56, 0x6B, 0x7A, 0xEB, 0xEE, + 0x61, 0xD2, 0x57, 0x28, 0xF2, 0xAC, 0xAE, 0x9B, 0x83, 0xD9, 0xC8, 0xB9, + 0xF0, 0xF2, 0x6C, 0x41, 0x52, 0x11, 0x09, 0x40, 0x10, 0x29, 0x59, 0x4D, + 0xC6, 0x8E, 0xCE, 0xA7, 0xF0, 0x1D, 0x42, 0x88, 0x81, 0x95, 0x92, 0x28, + 0x90, 0x48, 0x8C, 0x46, 0xE5, 0xD1, 0xC1, 0x8C, 0x39, 0x5A, 0xE7, 0x13, + 0x98, 0x28, 0xCF, 0x4C, 0x6E, 0xB4, 0x52, 0xD2, 0x87, 0x60, 0x94, 0xF4, + 0xDE, 0x27, 0xCA, 0x7D, 0x6F, 0x5D, 0x08, 0x21, 0xB9, 0x94, 0xFB, 0x10, + 0xFE, 0xC9, 0x3F, 0xFA, 0xF8, 0xE5, 0x8B, 0xB3, 0x71, 0x55, 0x3D, 0x7C, + 0xE7, 0xA1, 0x8F, 0x80, 0x00, 0x99, 0xD1, 0x29, 0x57, 0x1D, 0x8F, 0x4A, + 0x52, 0x12, 0x00, 0x63, 0x0C, 0xC0, 0x6C, 0x5D, 0xB0, 0x1E, 0xB4, 0xD6, + 0x99, 0xD1, 0xF7, 0xEF, 0x9F, 0x8C, 0xC7, 0xD5, 0x64, 0x32, 0xCA, 0x8C, + 0x3A, 0x9A, 0x8D, 0x8E, 0x0F, 0xA6, 0x6D, 0xD3, 0x9E, 0x9F, 0x5F, 0x6C, + 0xEB, 0x2E, 0xFA, 0x90, 0x67, 0xEA, 0xC3, 0x0F, 0xDF, 0xB9, 0x77, 0x72, + 0x54, 0x37, 0xAD, 0xF5, 0xF1, 0xC5, 0xE9, 0xE5, 0xE9, 0xD9, 0x75, 0xDB, + 0xBB, 0x7A, 0x5B, 0x87, 0xE0, 0x67, 0xF3, 0x59, 0x9E, 0x67, 0x45, 0x55, + 0xDD, 0x2C, 0x16, 0x27, 0x77, 0xEF, 0x64, 0x79, 0x76, 0x38, 0x1D, 0x49, + 0x29, 0xCF, 0xCF, 0xAF, 0xBE, 0x7D, 0xF6, 0xAD, 0x31, 0xFA, 0xE8, 0xE8, + 0x50, 0x92, 0x40, 0x14, 0x5D, 0xDF, 0x93, 0xA0, 0x2C, 0x33, 0xB9, 0x96, + 0x09, 0x89, 0x93, 0xC4, 0x82, 0x52, 0xB9, 0x7D, 0x38, 0x9F, 0x08, 0x21, + 0x24, 0xA1, 0xB3, 0x36, 0x30, 0x5E, 0x5D, 0xAF, 0xBE, 0x7D, 0xF1, 0xFA, + 0x60, 0x3E, 0x45, 0x41, 0xAF, 0x5E, 0x9D, 0xED, 0x61, 0x2E, 0x90, 0x08, + 0x3B, 0xCC, 0x02, 0x61, 0x36, 0x9B, 0xE6, 0x79, 0xD6, 0x76, 0x1D, 0x33, + 0x34, 0x4D, 0xBB, 0xAD, 0x9B, 0x74, 0xD6, 0x24, 0xAD, 0x0B, 0x39, 0x38, + 0x5A, 0x06, 0x8E, 0x03, 0x06, 0xAD, 0xB7, 0xCE, 0x79, 0x07, 0x0C, 0x49, + 0x4A, 0x68, 0x38, 0xA5, 0x79, 0xE8, 0x73, 0x07, 0x1F, 0x26, 0x93, 0xD1, + 0xC1, 0x6C, 0x92, 0x50, 0xDF, 0x75, 0xD3, 0x05, 0xE6, 0x18, 0xB9, 0x2A, + 0x32, 0xEF, 0x63, 0x66, 0x94, 0x40, 0x6C, 0xDA, 0x2E, 0xCF, 0xCD, 0x87, + 0xEF, 0xBE, 0x1D, 0xDE, 0x94, 0x96, 0xB8, 0x13, 0x8C, 0xDF, 0xAD, 0x68, + 0xC0, 0x08, 0xC8, 0x3B, 0x0E, 0xD3, 0xF0, 0x35, 0x82, 0x94, 0x74, 0x79, + 0xB3, 0xFE, 0xE2, 0xEB, 0xE7, 0xC1, 0x07, 0x04, 0x10, 0x02, 0x7D, 0x82, + 0x4D, 0x01, 0x0B, 0x1C, 0x0A, 0x91, 0x18, 0x82, 0x52, 0x94, 0xF2, 0xA3, + 0x34, 0x37, 0x60, 0xE6, 0x64, 0x11, 0x87, 0x02, 0x5D, 0x88, 0x9B, 0xBA, + 0xED, 0x7A, 0xAB, 0xA5, 0x14, 0x42, 0x38, 0xE7, 0xF3, 0x64, 0x17, 0x8F, + 0x40, 0x34, 0x28, 0xAF, 0x58, 0xE7, 0xD3, 0x99, 0x6D, 0x8C, 0x16, 0x44, + 0xCE, 0xFB, 0x3C, 0x33, 0x89, 0xCB, 0xAD, 0x95, 0x14, 0x00, 0x4A, 0xCA, + 0x18, 0xA3, 0xF5, 0x1E, 0x00, 0xBA, 0xDE, 0xA6, 0x5E, 0xB0, 0x0F, 0xA1, + 0x69, 0x7B, 0x67, 0x5D, 0x92, 0xC3, 0xAE, 0x9B, 0x0E, 0x11, 0xA6, 0x93, + 0x32, 0x25, 0x22, 0x7A, 0x70, 0x66, 0xA0, 0x84, 0xC2, 0x9D, 0x8C, 0x4B, + 0x25, 0xA9, 0xC8, 0xB3, 0xC3, 0xF9, 0x64, 0x3E, 0x1D, 0x69, 0x25, 0x63, + 0x88, 0xE9, 0x25, 0x52, 0x7C, 0xDC, 0x6C, 0xDB, 0xB6, 0xB3, 0x9B, 0xBA, + 0x41, 0xC0, 0xB2, 0xC8, 0x17, 0xCB, 0xF5, 0x72, 0xB5, 0x79, 0xFA, 0xFC, + 0xD5, 0x72, 0xB5, 0x49, 0xFE, 0x81, 0x09, 0x13, 0x73, 0x76, 0x71, 0x8D, + 0x00, 0x47, 0x07, 0xB3, 0x2C, 0x37, 0x79, 0x9E, 0xA7, 0x04, 0xA9, 0xEB, + 0xFB, 0xBE, 0x77, 0xE3, 0x51, 0xA5, 0x95, 0x0A, 0x31, 0x94, 0x79, 0xB1, + 0x6D, 0xDA, 0xC7, 0xDF, 0x9E, 0x1E, 0x1F, 0x4C, 0x66, 0x93, 0xCA, 0x7B, + 0x8F, 0x30, 0x20, 0x55, 0x53, 0x11, 0xE3, 0x7C, 0x00, 0x80, 0x2C, 0xD3, + 0x4F, 0x9F, 0xBF, 0x66, 0x06, 0x04, 0xCE, 0x8C, 0x3E, 0x3D, 0xBF, 0xCC, + 0x8C, 0x96, 0x52, 0x0E, 0x0C, 0x81, 0x5B, 0x31, 0x46, 0xEE, 0x74, 0x55, + 0x07, 0x94, 0x96, 0x94, 0x54, 0x64, 0x9A, 0x99, 0x83, 0x75, 0x65, 0xA6, + 0x8B, 0xDC, 0x58, 0x17, 0x92, 0x22, 0x02, 0x20, 0xF0, 0x80, 0x01, 0x79, + 0x13, 0xBF, 0xFE, 0x53, 0x75, 0xE5, 0xED, 0xEF, 0xE3, 0x2D, 0xC1, 0x9C, + 0x7D, 0x13, 0x6A, 0xFF, 0x0B, 0xFB, 0x18, 0xB7, 0xCF, 0x1B, 0x53, 0xC6, + 0x87, 0x08, 0xCE, 0x47, 0xDC, 0x01, 0x3A, 0xC4, 0x20, 0x03, 0xBB, 0xCF, + 0x25, 0xF7, 0xE1, 0x12, 0x93, 0x38, 0xD1, 0x2E, 0x35, 0xE3, 0x34, 0x25, + 0xF7, 0x3B, 0xF0, 0x5A, 0xCA, 0xFA, 0x52, 0x76, 0x16, 0xE3, 0x30, 0x2B, + 0x51, 0x03, 0xF1, 0x3E, 0x75, 0xFA, 0xB0, 0x2A, 0xB3, 0xCC, 0x68, 0x60, + 0xC8, 0xB4, 0xDE, 0xCF, 0x1F, 0x88, 0x10, 0x20, 0x5E, 0x2D, 0x36, 0xD6, + 0x3A, 0xA3, 0x24, 0x00, 0x76, 0xD6, 0xA3, 0x10, 0x4D, 0xDB, 0x75, 0xBD, + 0x33, 0xDA, 0xF5, 0xD6, 0x91, 0x90, 0x20, 0x52, 0x7F, 0x7A, 0xA7, 0xF1, + 0x9D, 0xA8, 0xE3, 0x00, 0x88, 0x14, 0x42, 0x4C, 0xA7, 0xA8, 0x90, 0x34, + 0x1F, 0x8F, 0x67, 0xD3, 0xB1, 0x94, 0x84, 0x80, 0x8B, 0xC8, 0x92, 0x84, + 0x54, 0x94, 0x69, 0x65, 0xB4, 0x3A, 0x98, 0x8F, 0x97, 0xEB, 0xED, 0x7C, + 0x32, 0xB2, 0xCE, 0x0B, 0x12, 0x5D, 0xEF, 0xCA, 0xBC, 0x50, 0x52, 0xD4, + 0x4D, 0xB7, 0xDA, 0xB4, 0x4D, 0x6B, 0xDF, 0xBA, 0x3B, 0x3F, 0x9E, 0x8F, + 0x32, 0x65, 0x5C, 0x84, 0xE5, 0xB6, 0x35, 0x8A, 0xBA, 0xAE, 0xD3, 0x5A, + 0x1A, 0xA3, 0x8C, 0x56, 0x24, 0x44, 0x4A, 0x62, 0x51, 0x08, 0x08, 0xEC, + 0x43, 0xD4, 0x12, 0x0F, 0xA6, 0x55, 0xDB, 0xF5, 0xCE, 0xD9, 0x83, 0xD9, + 0x68, 0x54, 0x1A, 0x2E, 0xA4, 0xED, 0xAD, 0x14, 0xEC, 0x6C, 0xAF, 0xA4, + 0x3C, 0x3A, 0x2C, 0x9A, 0x6D, 0xF3, 0xF0, 0xC1, 0xC9, 0x64, 0x3A, 0xAE, + 0x9B, 0x6E, 0xB1, 0xDA, 0x3C, 0xF9, 0xF6, 0xB5, 0x32, 0xD9, 0xFB, 0xEF, + 0xBD, 0xBD, 0x5C, 0xAD, 0xA2, 0xF7, 0x1C, 0xE3, 0xC5, 0xF9, 0xE5, 0xB6, + 0x69, 0x7A, 0x6B, 0x11, 0xE9, 0xF1, 0x93, 0xE7, 0x1F, 0x7F, 0xF8, 0xAE, + 0x94, 0xB2, 0x2A, 0x8B, 0xE3, 0x3B, 0x47, 0x52, 0xC9, 0x2F, 0xBF, 0xF8, + 0xCD, 0x7C, 0x36, 0xFE, 0xDE, 0x47, 0xEF, 0x97, 0x85, 0xD2, 0x5A, 0xD5, + 0x4D, 0x2B, 0x3B, 0xAB, 0x09, 0x99, 0xA3, 0x96, 0xC2, 0xE8, 0x04, 0x6F, + 0x06, 0xA3, 0x24, 0x49, 0x4A, 0xC4, 0x46, 0x41, 0x74, 0x76, 0x7E, 0x19, + 0x63, 0xFC, 0xFE, 0xC7, 0xEF, 0xFE, 0xFA, 0xF3, 0x6F, 0x8E, 0x0E, 0x0F, + 0x66, 0xD3, 0xC9, 0x6A, 0xB5, 0xDE, 0x71, 0xC8, 0x28, 0x06, 0x4E, 0x20, + 0x32, 0x66, 0x1E, 0xFC, 0xE8, 0xAC, 0xB5, 0xD6, 0x19, 0xAD, 0x9D, 0x0F, + 0x0A, 0xE5, 0x6E, 0x4E, 0x02, 0x30, 0x48, 0xC4, 0x30, 0x00, 0x38, 0x6B, + 0x67, 0x93, 0xAA, 0xED, 0x6C, 0xDB, 0x76, 0x42, 0x08, 0x49, 0x14, 0x39, + 0x48, 0x29, 0x23, 0x73, 0xD3, 0xF6, 0x99, 0xD1, 0x4A, 0xC9, 0xB6, 0x69, + 0x17, 0xCB, 0xA5, 0x24, 0x4A, 0x16, 0x73, 0x2A, 0x50, 0xD3, 0xF6, 0xD6, + 0x3A, 0x00, 0xEE, 0x7B, 0x2B, 0x10, 0x94, 0x94, 0xEB, 0x75, 0xDD, 0xD9, + 0x9E, 0x04, 0x31, 0x47, 0x66, 0x04, 0xC0, 0x08, 0x91, 0x93, 0xD2, 0x1D, + 0x43, 0x8C, 0x20, 0x76, 0xC8, 0xB1, 0x37, 0xD0, 0xE9, 0x01, 0xA9, 0x03, + 0x6D, 0xDB, 0x5B, 0xE7, 0xB3, 0xCC, 0x24, 0x1A, 0x89, 0xF3, 0x31, 0xAF, + 0x4C, 0xE4, 0xB8, 0x6D, 0xBA, 0xC9, 0xA8, 0x90, 0x24, 0x2C, 0x40, 0x8C, + 0x51, 0x08, 0x42, 0x14, 0xCE, 0x05, 0xA2, 0x61, 0xAD, 0x6A, 0x2D, 0xB5, + 0x92, 0x8B, 0x75, 0xD3, 0x75, 0x7D, 0x9E, 0x9B, 0x10, 0x83, 0xB5, 0xDE, + 0xF9, 0x90, 0x90, 0x6A, 0x4D, 0xDB, 0x07, 0x1F, 0x4C, 0x96, 0x39, 0xE7, + 0x8C, 0x56, 0xFB, 0x95, 0xEF, 0x9C, 0x27, 0x49, 0x52, 0xCA, 0x10, 0x62, + 0xCA, 0xF3, 0x10, 0xD1, 0xA6, 0x8E, 0x21, 0x0F, 0xB6, 0xAD, 0x9D, 0xF5, + 0x9B, 0xBA, 0x4D, 0x38, 0x6D, 0xE7, 0x93, 0xA0, 0x51, 0x8D, 0x28, 0x94, + 0x94, 0x00, 0x50, 0xE6, 0x06, 0x52, 0x11, 0x93, 0x9B, 0xB6, 0xEB, 0x95, + 0xA4, 0xD9, 0x64, 0x5C, 0xE4, 0xA6, 0x2C, 0xB2, 0xF9, 0x74, 0x94, 0x52, + 0x94, 0x10, 0x62, 0xEF, 0x5D, 0x32, 0x0C, 0xB7, 0x2E, 0xF8, 0x10, 0x9C, + 0xF3, 0x6D, 0xD7, 0x3B, 0xE7, 0xF3, 0xCC, 0x08, 0x04, 0xEF, 0x7C, 0xC2, + 0x7C, 0xAC, 0xD7, 0x5B, 0x1F, 0x62, 0xDF, 0xF7, 0x26, 0x33, 0x79, 0x66, + 0x24, 0x51, 0x64, 0xD8, 0x36, 0x0D, 0x23, 0x77, 0x9D, 0x05, 0x80, 0xA2, + 0xC8, 0xAF, 0x6F, 0x96, 0x00, 0x7C, 0xEF, 0xE4, 0x28, 0xC6, 0x20, 0xA5, + 0xEC, 0xBA, 0x8D, 0x0F, 0xB1, 0xAA, 0xCA, 0x5F, 0x7F, 0xF9, 0xFC, 0xFD, + 0x77, 0x4E, 0xEE, 0x1D, 0xCD, 0xE2, 0x0E, 0x4B, 0xDF, 0xF7, 0xD6, 0x79, + 0x9F, 0xDE, 0xE7, 0xD3, 0x6F, 0x4F, 0xFF, 0xE7, 0xFF, 0xE5, 0x7F, 0x3D, + 0x38, 0x98, 0x7E, 0xFC, 0xFE, 0xDB, 0x79, 0xA6, 0xFF, 0xFD, 0x2F, 0x7E, + 0xF3, 0xF3, 0x3F, 0xF8, 0xE4, 0x0F, 0x7F, 0xFE, 0x43, 0x20, 0x8C, 0x21, + 0xF8, 0xC0, 0xB8, 0x43, 0x89, 0xD1, 0x9F, 0xFC, 0xE9, 0xBF, 0x4E, 0x00, + 0x3F, 0x22, 0xD4, 0x5A, 0xE6, 0x46, 0x33, 0x73, 0x62, 0x38, 0x67, 0x46, + 0x25, 0xA5, 0x07, 0xAD, 0x08, 0x60, 0x40, 0x39, 0xEF, 0x0C, 0xEE, 0xF1, + 0x1F, 0x48, 0xC7, 0xFE, 0x81, 0xB8, 0xF6, 0x5B, 0xD5, 0x25, 0x0E, 0x13, + 0xD7, 0xFD, 0x23, 0x32, 0x43, 0x5A, 0x47, 0x42, 0x88, 0xC0, 0x91, 0x23, + 0x0B, 0xC4, 0x14, 0xE9, 0xF7, 0x20, 0xAF, 0xFD, 0x11, 0xB9, 0xB7, 0x57, + 0xB9, 0xDD, 0x74, 0xDB, 0xE7, 0x9C, 0x29, 0xA8, 0xA5, 0x77, 0x59, 0x64, + 0x3A, 0x4B, 0x98, 0xAF, 0x5D, 0x15, 0x20, 0x10, 0x95, 0x22, 0x25, 0xA9, + 0x2A, 0xF3, 0x3C, 0xCF, 0x08, 0x13, 0x2C, 0x36, 0x9D, 0x09, 0x11, 0x05, + 0xA7, 0x5A, 0xF5, 0xF2, 0xF5, 0x59, 0x61, 0x54, 0x88, 0xA0, 0x94, 0xA8, + 0x3B, 0xE7, 0x7D, 0x28, 0x8C, 0x12, 0x00, 0x92, 0x84, 0xB5, 0xE1, 0x7A, + 0xD9, 0x20, 0x82, 0x20, 0xD4, 0x5A, 0xED, 0x84, 0x24, 0x87, 0xBE, 0x5B, + 0x42, 0xD6, 0x84, 0xC8, 0x4A, 0xC9, 0xBB, 0x77, 0x0E, 0xC6, 0xA3, 0xF2, + 0xEE, 0x9D, 0x03, 0xAD, 0x65, 0x9A, 0xFE, 0xE4, 0x99, 0x39, 0x3E, 0x98, + 0xDE, 0xBF, 0x7B, 0x14, 0x42, 0x38, 0x3E, 0x9C, 0x3F, 0x7C, 0xEB, 0x4E, + 0x66, 0x94, 0x56, 0xF2, 0x60, 0x3A, 0x7E, 0xFB, 0xC1, 0xC9, 0x74, 0x54, + 0x68, 0x25, 0xAD, 0xF3, 0x6D, 0xE7, 0x24, 0xC1, 0x7F, 0xFF, 0xCF, 0x7E, + 0x3A, 0x9B, 0x1F, 0x90, 0xD2, 0x9E, 0x31, 0x37, 0xAA, 0xEB, 0xDA, 0x22, + 0xD3, 0x99, 0xD6, 0x00, 0x3C, 0x9F, 0x8D, 0xB3, 0xDC, 0x30, 0xC7, 0x10, + 0x7C, 0x32, 0xC9, 0xF2, 0xDE, 0x73, 0x88, 0xA3, 0xB2, 0x28, 0x8A, 0x2C, + 0x33, 0x7A, 0x5C, 0x16, 0xA3, 0x51, 0x51, 0x55, 0x65, 0x35, 0x2A, 0x95, + 0xA4, 0xA6, 0x6E, 0xA5, 0x92, 0x46, 0xEB, 0xF1, 0xB8, 0x1C, 0x4F, 0xC6, + 0xD6, 0xDA, 0xEB, 0xAB, 0x05, 0x91, 0xB4, 0x2E, 0xE4, 0x79, 0x71, 0x78, + 0x38, 0x3D, 0x3E, 0x9C, 0x8D, 0xC7, 0x63, 0x1F, 0x42, 0xDD, 0x34, 0x8C, + 0x80, 0x20, 0x46, 0xA3, 0xF2, 0xC5, 0x8B, 0x57, 0x00, 0x58, 0x56, 0xE5, + 0x62, 0xB9, 0xFE, 0xE6, 0xF1, 0xD3, 0xE7, 0x2F, 0x5E, 0xE5, 0x5A, 0xA1, + 0xA0, 0xF1, 0x74, 0x7A, 0x7E, 0x79, 0x3D, 0x9B, 0x8E, 0x00, 0x61, 0xBB, + 0x6D, 0x26, 0x55, 0x01, 0x00, 0x75, 0xDB, 0xC7, 0xC8, 0x92, 0x84, 0x56, + 0x54, 0x37, 0x4D, 0xD7, 0xBB, 0xB2, 0xC8, 0x90, 0xE3, 0xE5, 0xE5, 0x4D, + 0xEF, 0xC2, 0x64, 0x32, 0xCA, 0xB2, 0xEC, 0xF4, 0xF4, 0x3C, 0x95, 0x24, + 0xAB, 0xD5, 0xDA, 0xF9, 0xA0, 0xB5, 0x02, 0xC6, 0xDE, 0x39, 0xB9, 0x23, + 0xD5, 0xEB, 0x81, 0x99, 0x14, 0x84, 0x10, 0x29, 0x21, 0x27, 0xA2, 0xE4, + 0x9F, 0xC8, 0x10, 0x13, 0x8D, 0x24, 0xA1, 0x2B, 0x01, 0xC0, 0x87, 0x38, + 0x74, 0x3C, 0x43, 0x60, 0x8E, 0x82, 0x84, 0xF3, 0x5E, 0x25, 0xA2, 0x2B, + 0x09, 0xAD, 0x65, 0x1A, 0x0A, 0x27, 0x88, 0x8F, 0xD6, 0x9A, 0x99, 0x77, + 0x13, 0x3D, 0x12, 0x02, 0x49, 0x50, 0x08, 0xC1, 0xF9, 0xF0, 0xFE, 0x7B, + 0x0F, 0xF3, 0xDC, 0x84, 0xC0, 0x8C, 0x03, 0xB9, 0x05, 0x6E, 0xA3, 0x23, + 0x77, 0xE8, 0x80, 0x1D, 0x42, 0x7D, 0x58, 0x84, 0x4A, 0xAB, 0x17, 0xAF, + 0xCE, 0x9F, 0x3E, 0x7F, 0xAD, 0xA4, 0x4C, 0xA3, 0x74, 0x14, 0x98, 0x44, + 0xBE, 0xF2, 0xCC, 0x8C, 0xAA, 0x1C, 0x00, 0x9A, 0xB6, 0xCF, 0xB4, 0x06, + 0xE6, 0xCE, 0xBA, 0x44, 0x1A, 0x4D, 0x23, 0x54, 0x49, 0x82, 0x23, 0x77, + 0xD6, 0x4B, 0x29, 0xDB, 0xAE, 0x57, 0x4A, 0x06, 0xEF, 0x93, 0xAD, 0x6A, + 0xDF, 0xBB, 0x10, 0xA2, 0x20, 0x91, 0x69, 0xD5, 0x59, 0x27, 0x89, 0x98, + 0x41, 0x29, 0x99, 0x3A, 0x65, 0x69, 0xA4, 0xC4, 0x0C, 0x31, 0x06, 0x45, + 0xB4, 0x27, 0x6F, 0x01, 0x8A, 0xDE, 0xFA, 0xBE, 0x77, 0xD6, 0x39, 0x6B, + 0xBD, 0xF7, 0xC1, 0x39, 0xD7, 0xF7, 0x5E, 0x90, 0x00, 0x44, 0x49, 0x94, + 0x65, 0x66, 0xBD, 0x69, 0x98, 0xD9, 0x68, 0x6D, 0x7D, 0xE0, 0x18, 0x7D, + 0xE0, 0x18, 0x79, 0x3C, 0x2A, 0x46, 0x45, 0x5E, 0x95, 0xF9, 0x64, 0x5C, + 0x66, 0x99, 0x4E, 0xB5, 0x9E, 0xED, 0x5D, 0xD7, 0x3B, 0x48, 0x0D, 0x65, + 0x06, 0xEB, 0x9C, 0x73, 0xBE, 0xC8, 0xB3, 0x3C, 0x33, 0x90, 0x9A, 0x74, + 0x4A, 0x12, 0x11, 0x49, 0x6A, 0xDA, 0xAE, 0xEF, 0x5C, 0xD3, 0x76, 0x1C, + 0xA3, 0x40, 0xE1, 0x53, 0x03, 0x9D, 0xA8, 0x6E, 0xDB, 0xCC, 0x98, 0x6D, + 0xDD, 0x9C, 0x5F, 0xDE, 0x48, 0xA9, 0xFB, 0xBE, 0xDF, 0xD6, 0x9D, 0x77, + 0x4E, 0x2B, 0xBD, 0x5A, 0x6F, 0xAE, 0xAE, 0x97, 0x17, 0x57, 0x8B, 0x9B, + 0x55, 0xB3, 0x69, 0xBA, 0xE4, 0x56, 0xF7, 0xFA, 0xE2, 0xFA, 0x2F, 0xFF, + 0xEA, 0x57, 0xDB, 0xBA, 0xF5, 0x81, 0xAF, 0x97, 0xDB, 0xC5, 0xAA, 0x3E, + 0x38, 0x98, 0x47, 0xC6, 0xD3, 0xB3, 0x9B, 0x5F, 0x7D, 0xF6, 0x78, 0xB9, + 0xDA, 0x5E, 0x5C, 0xAD, 0xDF, 0x7B, 0xFB, 0xE4, 0x66, 0xB9, 0x96, 0x24, + 0x26, 0x55, 0x19, 0x99, 0x3D, 0x47, 0x22, 0x41, 0x7F, 0xFC, 0xA7, 0x7F, + 0x86, 0x00, 0x52, 0xCA, 0xA4, 0xB8, 0x9F, 0x6A, 0x31, 0x49, 0x64, 0xB4, + 0x24, 0x21, 0x00, 0x38, 0xB1, 0x4F, 0x13, 0x58, 0x39, 0x71, 0x62, 0x6E, + 0x4B, 0xF2, 0xFF, 0x67, 0x03, 0xD9, 0xAD, 0x39, 0x20, 0xEC, 0xF3, 0xB2, + 0xDB, 0x41, 0xF0, 0xCD, 0xF4, 0x21, 0xD9, 0x4A, 0x03, 0xA7, 0xE4, 0xCB, + 0xBB, 0x84, 0xC5, 0x07, 0x44, 0x00, 0x01, 0x9A, 0xA4, 0x92, 0x94, 0xDA, + 0x64, 0x0C, 0x1C, 0x23, 0xE0, 0xA0, 0x0C, 0x05, 0x44, 0x42, 0x11, 0x49, + 0x1A, 0x00, 0x21, 0x5A, 0xCA, 0xFD, 0xE7, 0x4D, 0x24, 0x8C, 0x51, 0xA3, + 0x2A, 0xCF, 0x73, 0x23, 0x89, 0x52, 0x6B, 0x8C, 0x23, 0x6B, 0x29, 0xA7, + 0x93, 0x32, 0xCB, 0x74, 0x91, 0x9B, 0x2C, 0x33, 0x3B, 0x52, 0x2B, 0x00, + 0x42, 0x8C, 0x01, 0x11, 0x49, 0x28, 0x81, 0x22, 0xC6, 0x78, 0xFA, 0xE2, + 0x65, 0xF4, 0x7E, 0xDB, 0xF6, 0xD3, 0x51, 0x81, 0x28, 0xDA, 0xDE, 0x5B, + 0xEB, 0x8C, 0xA6, 0x18, 0xD9, 0xF9, 0x78, 0xB5, 0xD8, 0x7A, 0x1F, 0xF2, + 0x22, 0x43, 0x44, 0x29, 0x25, 0x49, 0x0A, 0x3E, 0xF4, 0x2E, 0x24, 0x09, + 0xF3, 0xDE, 0xF9, 0x18, 0xC1, 0x68, 0xF5, 0xD1, 0x07, 0x0F, 0x47, 0xA3, + 0x42, 0x1B, 0x75, 0x78, 0x30, 0x9B, 0x8E, 0x47, 0x00, 0xEC, 0x9C, 0x7F, + 0xEF, 0x9D, 0xFB, 0xEF, 0x3E, 0xBA, 0x3F, 0x9F, 0x4F, 0x94, 0xA4, 0x51, + 0x95, 0x8F, 0x47, 0x95, 0x92, 0x34, 0x9B, 0x8D, 0x8E, 0x8F, 0x66, 0x93, + 0x71, 0x35, 0x1E, 0x95, 0x82, 0x68, 0xB5, 0x5C, 0x7E, 0xF2, 0xC1, 0xC3, + 0x77, 0x1E, 0x3D, 0x6C, 0x7B, 0x7F, 0xBD, 0x58, 0x87, 0x18, 0x36, 0xCB, + 0xA5, 0x51, 0xE2, 0xBD, 0x77, 0x1F, 0xC6, 0x18, 0xE6, 0xF3, 0x71, 0x51, + 0x64, 0xE9, 0x06, 0xD6, 0x75, 0xE3, 0x5D, 0x48, 0x10, 0xDC, 0x22, 0xCF, + 0xB5, 0x51, 0x92, 0xC4, 0xE1, 0x7C, 0x22, 0x95, 0x94, 0x34, 0x38, 0xDD, + 0xC2, 0xCE, 0xD1, 0x63, 0x5B, 0xB7, 0x99, 0xC9, 0x7C, 0x8C, 0x97, 0x57, + 0x8B, 0xDE, 0x06, 0x14, 0x74, 0x79, 0xBD, 0xAC, 0x9B, 0x86, 0x63, 0x80, + 0x18, 0xCB, 0xAA, 0x38, 0x3A, 0x3A, 0xEC, 0xAD, 0x1B, 0x55, 0xE5, 0x7C, + 0x32, 0x3A, 0x39, 0x9E, 0xDF, 0x3B, 0xB9, 0x73, 0xBD, 0xDC, 0xCC, 0xA6, + 0x93, 0xD9, 0xA4, 0x3A, 0xBF, 0xB8, 0x5E, 0x2C, 0x96, 0x5D, 0xDF, 0x37, + 0x4D, 0xFF, 0xE0, 0xAD, 0x13, 0x29, 0xD5, 0x93, 0x67, 0xAF, 0x8E, 0x8F, + 0xE6, 0xC7, 0x07, 0x93, 0xD4, 0x0C, 0x8A, 0x1C, 0x8D, 0x56, 0x49, 0x6D, + 0xBD, 0xE9, 0x12, 0x68, 0xDF, 0x33, 0x63, 0xDD, 0xF6, 0x9B, 0xBA, 0x93, + 0x52, 0x7D, 0xFE, 0xC5, 0xD7, 0x07, 0xF3, 0xA9, 0x20, 0xBA, 0xBA, 0x5E, + 0xB4, 0x6D, 0xE7, 0x9D, 0x4F, 0x53, 0x23, 0xA9, 0x54, 0x92, 0x7E, 0xE3, + 0x18, 0x97, 0xAB, 0xB5, 0xD1, 0x1A, 0x80, 0xAB, 0x51, 0xD5, 0x75, 0xB6, + 0xAE, 0x1B, 0x22, 0x2A, 0x8A, 0x2C, 0x35, 0x19, 0x12, 0x9A, 0x3A, 0xE1, + 0x68, 0xCA, 0xAA, 0x48, 0xB6, 0xF0, 0x42, 0xE0, 0xC0, 0xAB, 0x15, 0x22, + 0x86, 0x68, 0xB4, 0x26, 0x12, 0x21, 0x04, 0xEB, 0x9C, 0x56, 0x2A, 0xCF, + 0xB3, 0xC8, 0x51, 0x24, 0xE0, 0xA5, 0x40, 0xE6, 0xA4, 0x94, 0x4D, 0x4A, + 0x52, 0x08, 0x21, 0x44, 0x0E, 0x31, 0x56, 0x65, 0x71, 0xF7, 0xEE, 0x51, + 0x52, 0xF4, 0x85, 0xDD, 0x38, 0x6C, 0xC7, 0xEC, 0xFD, 0x7B, 0xD6, 0x79, + 0x5A, 0xBF, 0x5A, 0xC9, 0x27, 0xCF, 0x4F, 0x9F, 0xBF, 0x3C, 0x4F, 0x23, + 0xDA, 0x54, 0x20, 0x24, 0xBC, 0xAB, 0x91, 0x32, 0x6D, 0x78, 0xE7, 0x7C, + 0x6A, 0x80, 0x26, 0x65, 0x94, 0x04, 0xFA, 0x09, 0x21, 0xD9, 0x3B, 0xB5, + 0xD6, 0x05, 0x21, 0x70, 0x5B, 0x37, 0x00, 0x90, 0x7A, 0x40, 0x8A, 0x28, + 0xC4, 0x38, 0xB4, 0x3E, 0x00, 0x08, 0x51, 0x2A, 0x29, 0x50, 0x78, 0x17, + 0xB2, 0x4C, 0x6B, 0xAD, 0x92, 0x3D, 0xAD, 0x56, 0xC4, 0x0C, 0x31, 0xC6, + 0x34, 0xE4, 0x4D, 0x8C, 0xC5, 0x54, 0xC0, 0x3A, 0xEB, 0x62, 0x1C, 0x88, + 0x0A, 0xA9, 0x90, 0x4C, 0x33, 0x2E, 0x63, 0xB4, 0x40, 0xF4, 0x3E, 0xA4, + 0x89, 0x6C, 0xDB, 0x59, 0x8E, 0x9C, 0x67, 0x26, 0x35, 0x8E, 0x94, 0x94, + 0x69, 0xA6, 0x07, 0x80, 0x4D, 0x6B, 0xD3, 0x55, 0x3A, 0xE7, 0x99, 0x07, + 0x32, 0x69, 0xC2, 0x6F, 0x7B, 0x1F, 0xDA, 0xB6, 0xEB, 0xAD, 0x5F, 0xAC, + 0x36, 0x28, 0x84, 0xB5, 0x0E, 0x11, 0x23, 0x40, 0x8C, 0xAC, 0xB5, 0x0E, + 0x21, 0x6A, 0x2D, 0x19, 0xB8, 0x6B, 0x6D, 0x88, 0xF1, 0x66, 0xB9, 0xDE, + 0x6E, 0x1B, 0x41, 0xA2, 0x2C, 0xF2, 0x10, 0xC2, 0x76, 0x5B, 0x73, 0x8C, + 0xD6, 0x79, 0x41, 0xD4, 0x5B, 0xB7, 0xD9, 0xD6, 0xF3, 0xE9, 0x78, 0xB9, + 0xA9, 0x57, 0x9B, 0x66, 0xB1, 0xDA, 0x2E, 0xD6, 0xCD, 0xE1, 0xC1, 0xFC, + 0xE2, 0x6A, 0xE5, 0x02, 0x23, 0x89, 0xF1, 0xA8, 0x7A, 0x70, 0xEF, 0xF8, + 0xCE, 0xD1, 0x0C, 0x11, 0xA6, 0xE3, 0x32, 0x29, 0x6D, 0x7C, 0xF9, 0xE4, + 0xF4, 0xCF, 0xFF, 0xE2, 0x97, 0xCB, 0x75, 0x9D, 0x17, 0xC6, 0x3A, 0x77, + 0x30, 0x1D, 0xB7, 0x6D, 0x27, 0x43, 0x8C, 0x09, 0x1C, 0xCF, 0xCC, 0x7D, + 0x62, 0xED, 0x66, 0xC6, 0x68, 0x95, 0x8C, 0xCC, 0xD5, 0x8E, 0xA4, 0x9E, + 0x48, 0xE0, 0xB7, 0x13, 0x9F, 0x7F, 0x38, 0x7E, 0xDD, 0x8E, 0x50, 0xFB, + 0x69, 0xE3, 0x00, 0xDE, 0xBD, 0x05, 0xA3, 0x7D, 0x93, 0x89, 0xC5, 0xB8, + 0x77, 0x33, 0x82, 0x37, 0xF3, 0x81, 0x9D, 0x3C, 0x19, 0x83, 0xD6, 0x32, + 0x33, 0xAA, 0xB7, 0x3E, 0x86, 0x18, 0x59, 0xF6, 0xD6, 0x25, 0x60, 0xF4, + 0x70, 0x2C, 0x48, 0x82, 0x37, 0xBC, 0x4B, 0x40, 0x40, 0xE7, 0x7D, 0xA6, + 0xA5, 0x54, 0x52, 0x2B, 0x99, 0x25, 0x6C, 0x74, 0x8C, 0x3A, 0xBD, 0x62, + 0xA6, 0x8A, 0x3C, 0x4F, 0xA6, 0x15, 0xC3, 0xC0, 0x01, 0x61, 0x30, 0x94, + 0x0B, 0x20, 0x08, 0x05, 0x12, 0x00, 0x24, 0x9D, 0x99, 0xDE, 0xBA, 0x10, + 0xA2, 0x73, 0x1E, 0x01, 0x26, 0x55, 0xD6, 0x34, 0x1D, 0x11, 0x35, 0x5D, + 0xBF, 0x5A, 0xB7, 0x2C, 0xA8, 0x28, 0x4C, 0x7A, 0xD3, 0x34, 0x18, 0x84, + 0x51, 0x08, 0x2C, 0x10, 0x02, 0x73, 0xDF, 0x5B, 0x00, 0x48, 0x98, 0x26, + 0x93, 0xE9, 0xE3, 0xA3, 0x83, 0x64, 0x26, 0x12, 0x39, 0xBE, 0x75, 0xFF, + 0x24, 0xC4, 0x78, 0x7E, 0x75, 0x03, 0x02, 0xEF, 0x1C, 0x1F, 0xF4, 0x5A, + 0x93, 0x24, 0x63, 0x34, 0x00, 0x74, 0x5D, 0xCF, 0x31, 0x66, 0x99, 0x31, + 0x46, 0x5B, 0x6B, 0xD5, 0x0F, 0x3E, 0x38, 0x3A, 0x3A, 0x5C, 0xAC, 0xEB, + 0xB4, 0x86, 0x32, 0x4D, 0xA3, 0x32, 0xBF, 0x77, 0xEF, 0xA8, 0xAA, 0x32, + 0x49, 0x30, 0x1A, 0x8F, 0x9C, 0x75, 0xC0, 0x1C, 0x85, 0x68, 0x9B, 0x4E, + 0x49, 0xA9, 0xB4, 0x4A, 0x6D, 0x60, 0xA5, 0xA8, 0xC8, 0x0D, 0x00, 0x26, + 0x6D, 0xDE, 0x10, 0x18, 0x01, 0xBD, 0x0B, 0xDE, 0x87, 0xEB, 0x9B, 0x95, + 0x8F, 0xBC, 0xDC, 0xD4, 0x5D, 0x67, 0x9F, 0x3E, 0x7B, 0x51, 0x94, 0x85, + 0xD6, 0xA6, 0xDE, 0x36, 0x75, 0x5D, 0x5B, 0xEB, 0x1E, 0x3E, 0x7C, 0x6B, + 0xB3, 0xD9, 0xBC, 0xFD, 0xF6, 0x5D, 0xA3, 0xD5, 0xCD, 0xCD, 0xE2, 0xE1, + 0xFD, 0xE3, 0x7A, 0x5B, 0xFF, 0xE2, 0xD3, 0xAF, 0x46, 0x65, 0xB9, 0xDD, + 0x36, 0xDF, 0x3C, 0x7E, 0xF6, 0xE4, 0xC9, 0xB7, 0x55, 0x55, 0x3D, 0x78, + 0x70, 0x5F, 0x1B, 0xFD, 0xFF, 0xFE, 0x7F, 0xFF, 0xFE, 0x0F, 0xFF, 0xEB, + 0xFF, 0xE2, 0x67, 0xBF, 0xFF, 0x83, 0xAE, 0x6D, 0x38, 0xC4, 0x2C, 0x33, + 0xCC, 0x80, 0x01, 0x22, 0xB3, 0x44, 0xE8, 0x5D, 0x10, 0x42, 0x68, 0x2D, + 0xB5, 0x24, 0xEB, 0x5C, 0x96, 0x67, 0xC6, 0x74, 0xBD, 0xB5, 0xF7, 0xEE, + 0xDD, 0x19, 0x8F, 0xAA, 0xDE, 0x05, 0xEF, 0xC3, 0x66, 0xBD, 0x76, 0x56, + 0x78, 0x1F, 0xAA, 0x4A, 0x96, 0x65, 0x79, 0x7D, 0xB3, 0x42, 0xC4, 0x44, + 0x26, 0x41, 0x84, 0xA2, 0x28, 0x9A, 0xA6, 0x49, 0xB8, 0xD3, 0xB6, 0xED, + 0x78, 0x20, 0xCD, 0x40, 0xD2, 0xCF, 0x8B, 0x21, 0x2A, 0x2D, 0x9D, 0xF3, + 0xC1, 0x87, 0xA4, 0x32, 0x92, 0xD2, 0xB7, 0x10, 0x5C, 0x0C, 0xD1, 0x3A, + 0x67, 0x8C, 0x4E, 0x5A, 0xE1, 0x46, 0xA9, 0xC9, 0x74, 0x1C, 0x23, 0x34, + 0x6D, 0x33, 0x2C, 0x40, 0x40, 0xE7, 0x3C, 0x00, 0x8C, 0xAA, 0xBC, 0xEF, + 0x9D, 0x94, 0x84, 0x28, 0xBF, 0xFA, 0xE6, 0xD9, 0xC7, 0x1F, 0xBE, 0x23, + 0xE5, 0x50, 0x73, 0x24, 0x46, 0x9F, 0x18, 0x8A, 0xB7, 0xDD, 0x68, 0x09, + 0xF6, 0xD2, 0x78, 0xA9, 0x9B, 0x81, 0x91, 0xD9, 0x39, 0xC7, 0x1C, 0x9D, + 0xB5, 0x48, 0xC4, 0x83, 0x2A, 0x3A, 0x64, 0x03, 0x09, 0x29, 0x26, 0x41, + 0x04, 0xE7, 0x93, 0xDE, 0x1A, 0x58, 0xE7, 0xC1, 0x71, 0x92, 0xB7, 0x65, + 0x06, 0xEB, 0xA3, 0xF7, 0xDE, 0x39, 0x6F, 0xB4, 0x76, 0xCE, 0x15, 0x79, + 0x9E, 0x2C, 0xAE, 0x97, 0xEB, 0xDA, 0x05, 0x0F, 0xC0, 0xE3, 0x32, 0x93, + 0x92, 0x7C, 0x04, 0x96, 0x28, 0x63, 0xC2, 0xB5, 0x7A, 0x44, 0x4A, 0xEF, + 0x42, 0x6B, 0x05, 0x21, 0x22, 0x42, 0xE0, 0x88, 0x3E, 0x18, 0xAD, 0x52, + 0x26, 0x18, 0x42, 0x6C, 0xBB, 0x9E, 0x84, 0x00, 0x01, 0x99, 0xD6, 0x31, + 0x32, 0x82, 0x2F, 0x8B, 0xA2, 0x2A, 0x72, 0x25, 0x09, 0x80, 0x8B, 0x3C, + 0x23, 0x21, 0x8C, 0x92, 0x22, 0x41, 0xDB, 0xC4, 0xA0, 0x0F, 0xE8, 0x43, + 0x90, 0x92, 0x36, 0xDB, 0xA6, 0x6D, 0xFB, 0x14, 0xF5, 0x12, 0x8A, 0xB3, + 0xC8, 0x0D, 0x22, 0xEC, 0x8D, 0x5D, 0xAC, 0xF5, 0xD7, 0xCB, 0x55, 0x2A, + 0x41, 0x94, 0xA2, 0x74, 0x6C, 0x33, 0x6B, 0x44, 0x28, 0x8B, 0x2C, 0xCB, + 0x94, 0x73, 0x41, 0x48, 0x72, 0xDE, 0xF7, 0xBD, 0x75, 0x2E, 0x98, 0x4C, + 0xAD, 0x37, 0x5B, 0xEF, 0x7D, 0xDF, 0xDB, 0x6D, 0xDD, 0x56, 0x65, 0x2E, + 0x04, 0xCE, 0xA6, 0xE3, 0xEF, 0x7D, 0xF4, 0x6E, 0x66, 0xB4, 0xF7, 0xBE, + 0x2A, 0xF3, 0xAE, 0x77, 0x4A, 0x4B, 0x60, 0x38, 0x3C, 0x9C, 0xBF, 0xBE, + 0xB8, 0x5E, 0x6E, 0xEA, 0x10, 0xC2, 0x6C, 0x3A, 0xAE, 0xCA, 0xEC, 0x7B, + 0x1F, 0x3E, 0x4A, 0xD3, 0xB6, 0x8B, 0xEB, 0xF5, 0xFF, 0xF1, 0x7F, 0xFF, + 0xF5, 0xC5, 0xC5, 0xD5, 0xE7, 0x4A, 0x3E, 0x7D, 0x79, 0xF1, 0xDF, 0xFC, + 0xE3, 0xEF, 0x1F, 0xCE, 0x67, 0xBF, 0xF8, 0xEC, 0x29, 0xFD, 0xD1, 0x9F, + 0xFC, 0x2B, 0x81, 0x18, 0x19, 0x12, 0x66, 0x0B, 0x11, 0xF3, 0x2C, 0x89, + 0xDF, 0x0D, 0x32, 0x8C, 0xFB, 0x04, 0x6A, 0x1F, 0x92, 0xFE, 0xB3, 0x45, + 0xE5, 0x6F, 0xFD, 0x68, 0x08, 0x64, 0x31, 0xD1, 0xA9, 0x7E, 0x27, 0x8A, + 0xC5, 0xC8, 0xCC, 0xC1, 0x87, 0xE4, 0x56, 0xED, 0x7C, 0x68, 0x3B, 0xEB, + 0x7D, 0x90, 0x8A, 0x54, 0x9A, 0x4C, 0x23, 0x26, 0xD8, 0x8B, 0x36, 0x8A, + 0x08, 0x93, 0x50, 0x60, 0x9E, 0x69, 0xA3, 0x95, 0x24, 0xAA, 0x8A, 0xBC, + 0x28, 0x92, 0xEE, 0xC6, 0xE0, 0x34, 0x98, 0xCA, 0x43, 0x29, 0xA5, 0xD6, + 0x4A, 0x2B, 0xA5, 0x94, 0x42, 0x21, 0x10, 0x06, 0xA8, 0x3E, 0x91, 0xC8, + 0xB4, 0x49, 0xA9, 0xE5, 0xAD, 0x77, 0x18, 0xF7, 0x17, 0x4B, 0x24, 0x01, + 0x13, 0xC5, 0x0F, 0xDA, 0xAE, 0xFB, 0xE5, 0xAF, 0xBE, 0x1C, 0x15, 0x59, + 0x67, 0xFD, 0xC1, 0xB4, 0x6A, 0x5A, 0xBB, 0x6D, 0xFA, 0xD9, 0xA8, 0xF0, + 0x3E, 0xA4, 0xD6, 0x3E, 0x03, 0x86, 0x08, 0xC1, 0x7B, 0x41, 0x03, 0xFF, + 0xD9, 0x87, 0xD8, 0x74, 0xD6, 0xF6, 0x3E, 0x71, 0x38, 0x88, 0xA8, 0xEB, + 0xBA, 0x51, 0x99, 0xBF, 0xF3, 0xF0, 0x1E, 0x11, 0x01, 0x60, 0x60, 0x26, + 0xA2, 0xCC, 0xE8, 0xCB, 0xAB, 0x65, 0x5D, 0xB7, 0x5A, 0x2B, 0x8E, 0xAC, + 0xB4, 0xEA, 0xBA, 0xAE, 0x69, 0x1A, 0x49, 0x22, 0xCF, 0x8D, 0x52, 0xAA, + 0xEB, 0x3A, 0x29, 0x25, 0x92, 0xCC, 0x8B, 0x5C, 0x4A, 0x5A, 0x6F, 0xEA, + 0x51, 0x99, 0x1F, 0xCE, 0x27, 0x65, 0x61, 0xB2, 0xCC, 0x8C, 0x26, 0x95, + 0x52, 0x8A, 0x43, 0x0C, 0xD6, 0x09, 0x49, 0x82, 0x06, 0x51, 0x20, 0xAD, + 0x95, 0x10, 0x42, 0x90, 0x90, 0x4A, 0xCA, 0x24, 0xB9, 0x81, 0x48, 0x28, + 0x9C, 0x0F, 0x67, 0xE7, 0x97, 0xA7, 0xA7, 0xE7, 0x57, 0xAB, 0x4D, 0x6F, + 0xC3, 0x72, 0xB5, 0x5D, 0xAE, 0x36, 0x67, 0x17, 0xD7, 0x88, 0x42, 0x99, + 0xEC, 0xEC, 0xE2, 0x1A, 0x11, 0x95, 0xD6, 0xCE, 0x87, 0x3B, 0x27, 0xC7, + 0xBD, 0x75, 0x9B, 0xCD, 0xF6, 0xE1, 0x5B, 0x77, 0xAB, 0xAA, 0xF8, 0xF4, + 0xF3, 0x6F, 0xBE, 0x79, 0xF6, 0x6A, 0xBB, 0x6D, 0x5E, 0x3C, 0x7F, 0xF9, + 0xFA, 0xFC, 0xF2, 0xFE, 0xFD, 0xFB, 0x87, 0x87, 0x53, 0xD7, 0x77, 0x57, + 0xD7, 0x8B, 0xE7, 0xCF, 0x4F, 0x3F, 0xFE, 0xF8, 0x83, 0xC7, 0x5F, 0x3F, + 0x01, 0x8E, 0x21, 0x04, 0x41, 0x24, 0x89, 0x24, 0x89, 0x3C, 0x33, 0x80, + 0x98, 0x8A, 0x8B, 0xE0, 0x03, 0x09, 0x31, 0xA9, 0xCA, 0xA4, 0xA7, 0x60, + 0x5D, 0xA8, 0x9B, 0x7E, 0x34, 0xAA, 0x26, 0xE3, 0xAA, 0x6E, 0x5A, 0x04, + 0x88, 0x91, 0xAF, 0xAE, 0x17, 0x31, 0x70, 0x66, 0x8C, 0xD6, 0xCA, 0x39, + 0x9B, 0xE8, 0xF1, 0x79, 0x9E, 0xDD, 0xBF, 0x7F, 0xD2, 0xB6, 0x5D, 0x6E, + 0x8C, 0xB5, 0xCE, 0x7A, 0x5F, 0x55, 0x79, 0x0C, 0xC1, 0xFB, 0x30, 0x1E, + 0x97, 0xDE, 0x7B, 0x14, 0x98, 0x19, 0x1D, 0xE2, 0xBE, 0xC9, 0x45, 0x02, + 0x31, 0x30, 0x78, 0x1F, 0x98, 0x23, 0xA2, 0x40, 0xC0, 0xD4, 0x48, 0xCA, + 0x33, 0x6D, 0xAD, 0xB3, 0xD6, 0x35, 0x4D, 0x5B, 0xD7, 0xED, 0x7C, 0x36, + 0xC9, 0x32, 0xDD, 0xF7, 0x3D, 0x33, 0x74, 0x3B, 0x31, 0xF1, 0x18, 0xE2, + 0x5B, 0xF7, 0xEF, 0xAC, 0x36, 0xDB, 0x3C, 0xCB, 0xEE, 0x9D, 0x1C, 0x0E, + 0xA3, 0x31, 0x00, 0xB1, 0xF3, 0x66, 0x8E, 0xF8, 0x86, 0x75, 0xF9, 0x9D, + 0x45, 0xCE, 0x40, 0x44, 0x9F, 0xFD, 0xE6, 0xF1, 0xCD, 0x62, 0x13, 0x19, + 0xB2, 0x4C, 0x39, 0xE7, 0x7D, 0x08, 0x99, 0x56, 0xA9, 0x20, 0x08, 0x83, + 0x26, 0x30, 0xA4, 0x16, 0x35, 0xC0, 0x1B, 0xB4, 0x94, 0xF5, 0xA1, 0xEB, + 0x5C, 0x3A, 0xB6, 0x95, 0xA4, 0x04, 0x70, 0x4D, 0x8B, 0xD8, 0x87, 0xE0, + 0xBD, 0xB7, 0xCE, 0xA7, 0x1E, 0x1F, 0x60, 0x82, 0x95, 0x04, 0x21, 0x84, + 0x54, 0x8A, 0x77, 0x7E, 0xC6, 0x59, 0xA6, 0x11, 0x31, 0x33, 0x3A, 0xC1, + 0xCA, 0x68, 0x87, 0x57, 0xF7, 0x3E, 0x6C, 0xB6, 0x8D, 0x31, 0x2A, 0xC4, + 0x38, 0x2A, 0x8B, 0x22, 0x33, 0x5D, 0x6F, 0x8B, 0x3C, 0x9B, 0x4F, 0xC6, + 0xA9, 0x3A, 0xD1, 0x5A, 0x93, 0x10, 0x46, 0xA9, 0x94, 0x1B, 0x4A, 0xA2, + 0x04, 0x29, 0x4F, 0x00, 0x4F, 0x66, 0x58, 0xAF, 0xEB, 0x6D, 0xDD, 0xA6, + 0x54, 0x77, 0x53, 0xD7, 0xA9, 0xEC, 0x55, 0x4A, 0x7A, 0x1F, 0x96, 0xAB, + 0x6D, 0xD7, 0xFF, 0xFF, 0x9C, 0xBD, 0xD9, 0x93, 0xA4, 0xD7, 0x75, 0x27, + 0x76, 0xEE, 0x7E, 0xBF, 0x2D, 0xB7, 0xCA, 0xDA, 0xBA, 0xBA, 0x1B, 0x0D, + 0x74, 0x93, 0x20, 0x20, 0x50, 0x24, 0x35, 0x1C, 0xD9, 0x9A, 0x89, 0x91, + 0xE5, 0x79, 0xB3, 0x23, 0x1C, 0xFE, 0x4B, 0xBC, 0x8D, 0xFD, 0x28, 0x51, + 0xB2, 0x23, 0xEC, 0xF9, 0x4F, 0xFC, 0x38, 0x8F, 0x76, 0x38, 0x1C, 0x13, + 0x76, 0xC4, 0x48, 0x23, 0x8D, 0x48, 0x90, 0x04, 0x48, 0x6C, 0xBD, 0x77, + 0x2D, 0x5D, 0x5B, 0x56, 0x6E, 0xDF, 0x76, 0xF7, 0xEB, 0x87, 0x9B, 0x59, + 0x5D, 0x00, 0xA9, 0xB1, 0xC7, 0xF9, 0xD0, 0x40, 0xD7, 0x92, 0x5D, 0x95, + 0xF9, 0x7D, 0xE7, 0x9E, 0xF3, 0x3B, 0xBF, 0xC5, 0x20, 0x48, 0x4A, 0x29, + 0x42, 0x29, 0x6D, 0x5B, 0xE5, 0x5D, 0xA0, 0x94, 0x64, 0x92, 0x55, 0x55, + 0x91, 0x98, 0x1C, 0x89, 0xF6, 0xB5, 0x5C, 0xD6, 0x11, 0x20, 0xCF, 0xE5, + 0x72, 0xD9, 0x18, 0x63, 0x11, 0x80, 0xF3, 0xDE, 0xF9, 0xD0, 0xB4, 0xFD, + 0x93, 0x0F, 0x1E, 0x7E, 0xF4, 0xE1, 0x07, 0x84, 0xE0, 0xA4, 0x71, 0x69, + 0xBA, 0x3E, 0x85, 0x3B, 0x3A, 0xE7, 0x4F, 0xDE, 0x5E, 0x7F, 0xFA, 0xD9, + 0xD7, 0xAB, 0x75, 0xFB, 0xCD, 0xB3, 0xD7, 0x08, 0x21, 0xCE, 0xC5, 0xF5, + 0xCD, 0xB2, 0x57, 0xF6, 0xD9, 0x8B, 0x37, 0x8C, 0xD3, 0x1F, 0x7D, 0xF2, + 0xBD, 0xC3, 0x83, 0xE9, 0xEE, 0x74, 0x74, 0xEF, 0x60, 0x4A, 0x19, 0x7F, + 0xFE, 0xFA, 0xFC, 0xC5, 0xEB, 0x73, 0xF2, 0x5F, 0xFF, 0xB7, 0xFF, 0x7D, + 0x42, 0x4D, 0x43, 0x04, 0x1F, 0x42, 0xD2, 0x40, 0x01, 0x40, 0x5A, 0xFE, + 0x6C, 0x71, 0xF4, 0x77, 0x6F, 0xDE, 0xAD, 0xB4, 0xE8, 0x77, 0x0B, 0xD6, + 0xEF, 0x3E, 0x6E, 0x7B, 0xB1, 0xF4, 0x67, 0x1A, 0xB8, 0xEE, 0x7C, 0x7A, + 0x03, 0xED, 0x27, 0xE3, 0x11, 0xE7, 0xBC, 0xD6, 0xD6, 0x58, 0x8F, 0x10, + 0x24, 0x19, 0x79, 0x08, 0x9B, 0xCD, 0x66, 0x9E, 0x89, 0xDB, 0x19, 0x0A, + 0xBF, 0x33, 0xBD, 0x00, 0xCE, 0x19, 0xE3, 0x2C, 0x5D, 0xB5, 0x89, 0xE7, + 0x9B, 0xBC, 0x31, 0x11, 0x42, 0x8C, 0xA4, 0x51, 0x8F, 0xC4, 0x77, 0xFC, + 0x8D, 0x08, 0x80, 0x30, 0x20, 0x4A, 0x69, 0x0A, 0x24, 0x84, 0x5B, 0x5C, + 0x2E, 0xFA, 0x0D, 0xB9, 0x8C, 0xB2, 0xCD, 0x93, 0xC5, 0x80, 0x29, 0x39, + 0x3B, 0xBB, 0xF8, 0xE2, 0xAB, 0x97, 0x52, 0x50, 0x6D, 0xEC, 0xCE, 0xB0, + 0x4A, 0x66, 0x22, 0xDA, 0x18, 0x4A, 0x70, 0x3A, 0xD9, 0x96, 0x75, 0x1F, + 0x22, 0x58, 0xEF, 0x53, 0xF0, 0xA2, 0xB5, 0xCE, 0x18, 0x67, 0x36, 0xDA, + 0x00, 0xC8, 0xA4, 0xCC, 0xF3, 0x2C, 0x78, 0xBF, 0xAE, 0xDB, 0x2C, 0x13, + 0x83, 0xB2, 0xC0, 0x84, 0x78, 0xEF, 0x39, 0x63, 0x9C, 0x33, 0x8C, 0xD1, + 0x6C, 0xBE, 0x4A, 0xA8, 0x56, 0xD3, 0xB4, 0xC6, 0x18, 0xCE, 0x59, 0x55, + 0x16, 0x52, 0x8A, 0x34, 0x01, 0x01, 0xC2, 0x5D, 0xDB, 0x67, 0x19, 0xEF, + 0x3A, 0x55, 0x16, 0x99, 0x94, 0x7C, 0xBA, 0x33, 0x1C, 0x8D, 0x07, 0x98, + 0x60, 0x29, 0x04, 0x00, 0x68, 0xA5, 0x62, 0x0C, 0x94, 0xF3, 0xE4, 0x80, + 0x4E, 0x36, 0x33, 0x35, 0xDE, 0xC2, 0x37, 0x31, 0xC6, 0x68, 0x8D, 0xEB, + 0xB5, 0x9A, 0x2F, 0x56, 0x37, 0xF3, 0xF5, 0xBA, 0xE9, 0x8D, 0x0D, 0xC6, + 0xD8, 0xBA, 0x6E, 0x9D, 0x0F, 0x32, 0x93, 0x45, 0x91, 0x2F, 0xD7, 0x0D, + 0x21, 0xF4, 0xE0, 0x60, 0x0F, 0x30, 0x05, 0x84, 0x87, 0x55, 0x59, 0x95, + 0xC5, 0x97, 0x4F, 0x5F, 0x5D, 0xCE, 0xE6, 0x87, 0x07, 0xFB, 0x4D, 0xAB, + 0x4E, 0xCE, 0x2E, 0xAB, 0x41, 0xE5, 0x43, 0x5C, 0x2C, 0x97, 0x7B, 0x7B, + 0xD3, 0xC1, 0x68, 0x38, 0xBF, 0x59, 0xAE, 0xE6, 0x37, 0xDE, 0xBB, 0xBE, + 0xEB, 0x77, 0x26, 0xA3, 0x5F, 0x7E, 0xF6, 0xF5, 0x97, 0x5F, 0x3D, 0xBF, + 0x99, 0x2D, 0x26, 0x93, 0xD1, 0x78, 0x34, 0x70, 0xDE, 0xC5, 0x5B, 0xDB, + 0x29, 0x84, 0x29, 0xC5, 0x04, 0xE3, 0x18, 0x63, 0x00, 0x44, 0x29, 0x9B, + 0x8C, 0x06, 0x79, 0x26, 0x8D, 0x75, 0xD6, 0xBA, 0xAA, 0xCC, 0x23, 0x42, + 0x97, 0x97, 0xB3, 0x4E, 0xE9, 0x2C, 0x93, 0xCE, 0xBB, 0x18, 0x22, 0x46, + 0x29, 0x54, 0x8D, 0xE5, 0x59, 0x96, 0x4A, 0xB3, 0x52, 0xC6, 0x5A, 0x97, + 0x58, 0x4B, 0x31, 0xC6, 0xE0, 0x43, 0x59, 0xE6, 0xC6, 0xD8, 0xB4, 0xE7, + 0xCA, 0xB3, 0x4C, 0x69, 0xE5, 0x7D, 0xF2, 0xC8, 0x8C, 0xEB, 0xB6, 0x4F, + 0xF4, 0x26, 0x1F, 0x22, 0x00, 0xAA, 0xCA, 0x6C, 0x50, 0x16, 0x21, 0x46, + 0xA5, 0x74, 0x6A, 0xE8, 0xBC, 0xF7, 0x21, 0xC6, 0xFB, 0x47, 0xFB, 0x08, + 0xE1, 0xA6, 0xED, 0x7C, 0x08, 0x82, 0x31, 0x6B, 0xED, 0x70, 0x50, 0x2A, + 0x6D, 0x6E, 0x16, 0xAB, 0x4F, 0x7E, 0xF0, 0xC1, 0xB6, 0x90, 0x6D, 0x38, + 0x95, 0x5B, 0x77, 0x45, 0x80, 0x04, 0xF5, 0x27, 0x16, 0x50, 0x72, 0xFE, + 0x83, 0x08, 0x00, 0x5F, 0x3D, 0x7D, 0x5D, 0xB7, 0x5D, 0xA2, 0xCA, 0x26, + 0x2C, 0x2F, 0xAD, 0x05, 0xB2, 0x4C, 0xC4, 0x08, 0x82, 0xB3, 0x8D, 0x47, + 0x2B, 0x23, 0x71, 0xC3, 0x0B, 0xA1, 0x84, 0x60, 0xEF, 0x43, 0x8C, 0x41, + 0x0A, 0x66, 0x9D, 0x8F, 0x31, 0x58, 0xEF, 0x29, 0x65, 0x98, 0x20, 0x42, + 0x70, 0x91, 0x4B, 0x82, 0xD1, 0xDE, 0xCE, 0x30, 0x93, 0x5C, 0x1B, 0xCB, + 0x05, 0x0B, 0x21, 0x86, 0x00, 0x18, 0x63, 0xEF, 0x3C, 0x42, 0x28, 0xCB, + 0xB8, 0x14, 0x3C, 0x25, 0x04, 0xA6, 0xF5, 0xBA, 0xF7, 0x81, 0x32, 0x1A, + 0x22, 0x10, 0x4C, 0xAC, 0xF7, 0xD6, 0xBA, 0x4C, 0xCA, 0x10, 0x62, 0xF0, + 0x51, 0x69, 0x33, 0x1E, 0x96, 0x3B, 0xA3, 0x4A, 0x0A, 0xDA, 0xF5, 0xBA, + 0x6E, 0x7A, 0x82, 0x71, 0xEA, 0x7D, 0x7C, 0xF0, 0x89, 0xE5, 0xAE, 0x8C, + 0x05, 0x84, 0x04, 0x67, 0x98, 0x90, 0x54, 0xC2, 0xB4, 0x36, 0x31, 0xC2, + 0xBA, 0x69, 0xAD, 0xF3, 0xDA, 0xD8, 0x18, 0x23, 0x25, 0xB4, 0x57, 0xBA, + 0x53, 0x9B, 0xDC, 0xE8, 0x8D, 0x76, 0x1E, 0x00, 0x63, 0xD4, 0xB4, 0xCA, + 0x5A, 0x9B, 0xC8, 0x25, 0x31, 0x44, 0x4A, 0xE9, 0xBA, 0x6E, 0x9D, 0xF7, + 0x08, 0xE1, 0xB6, 0x57, 0x83, 0xAA, 0x74, 0x3E, 0xD4, 0x4D, 0xEB, 0x7C, + 0x10, 0x9C, 0x3B, 0xEF, 0xFF, 0xE0, 0x07, 0x1F, 0x7C, 0xF2, 0xD1, 0x63, + 0xEF, 0xFD, 0xB2, 0x6E, 0x97, 0xAB, 0x9A, 0x12, 0x52, 0x14, 0x39, 0x44, + 0x38, 0xBB, 0x9C, 0xFD, 0xF5, 0xDF, 0x7D, 0xF6, 0xE2, 0xE5, 0x89, 0x52, + 0xFA, 0xFE, 0xD1, 0x3E, 0x46, 0x78, 0xB1, 0xAC, 0x01, 0xE1, 0xAA, 0xCC, + 0xAF, 0xAE, 0xE7, 0x7D, 0xAF, 0x8C, 0xB1, 0x83, 0x41, 0xF9, 0xDE, 0x83, + 0x83, 0xA3, 0x83, 0xE9, 0x83, 0xA3, 0xFD, 0xE7, 0xAF, 0x4E, 0xBE, 0xFA, + 0xEA, 0x05, 0x20, 0x44, 0xFE, 0xAB, 0xFF, 0xE6, 0x5F, 0xA4, 0x17, 0xB7, + 0xCC, 0xC4, 0x68, 0x58, 0x20, 0x80, 0x5E, 0x99, 0x04, 0xB8, 0x6E, 0xCE, + 0xA2, 0x3B, 0x94, 0xFA, 0xDB, 0xCC, 0x8E, 0xDF, 0x5B, 0xC2, 0x7E, 0x6F, + 0x23, 0x76, 0xFB, 0xF1, 0x5B, 0x58, 0xED, 0xF6, 0x23, 0x09, 0xE8, 0x42, + 0x08, 0x39, 0xEF, 0xBC, 0xF7, 0x80, 0x80, 0x60, 0xCC, 0x39, 0x2D, 0x8A, + 0x4C, 0x08, 0x06, 0x00, 0x84, 0xE0, 0xD4, 0x82, 0x15, 0x79, 0x86, 0xB7, + 0xEC, 0x8D, 0xF4, 0xCC, 0x09, 0x23, 0xA0, 0x24, 0x99, 0x6D, 0x43, 0x32, + 0xA2, 0x72, 0xCE, 0xC1, 0xB6, 0xB1, 0xA2, 0x49, 0x69, 0x1A, 0x12, 0xFB, + 0x0C, 0x82, 0x0F, 0x18, 0x63, 0x92, 0x98, 0xB3, 0xEF, 0xFC, 0x77, 0x53, + 0x2F, 0xB6, 0xD9, 0xB8, 0x63, 0x82, 0x31, 0xA6, 0xB0, 0x15, 0xD3, 0x61, + 0x82, 0x57, 0xEB, 0xF5, 0xCB, 0x17, 0xC7, 0x9C, 0x12, 0x1F, 0x51, 0x2E, + 0x19, 0x23, 0xC4, 0x3B, 0x2F, 0x18, 0xA9, 0x72, 0xD9, 0x29, 0x63, 0xAD, + 0x43, 0x18, 0xCF, 0x97, 0x6D, 0xE2, 0xBD, 0x7A, 0x1F, 0x9C, 0xB3, 0xDE, + 0x07, 0x40, 0xC8, 0x5A, 0xC7, 0x29, 0xE5, 0x9C, 0x1A, 0x6D, 0x38, 0x67, + 0x49, 0x32, 0x92, 0x65, 0x82, 0x31, 0xE2, 0xBC, 0x67, 0x8C, 0x39, 0xEF, + 0xB4, 0x32, 0x75, 0xD3, 0xC6, 0x18, 0x95, 0xD2, 0x18, 0x21, 0xC6, 0x68, + 0x59, 0xE4, 0xFB, 0xFB, 0x53, 0x2E, 0x78, 0x8A, 0x92, 0xF4, 0xCE, 0x0B, + 0x4E, 0xAD, 0x0D, 0x5D, 0xD7, 0x8E, 0x86, 0x65, 0x59, 0xE4, 0x79, 0x2E, + 0xF3, 0x3C, 0x4B, 0x8E, 0xA9, 0x21, 0x84, 0xE0, 0x1D, 0xA6, 0x84, 0x72, + 0x86, 0x60, 0x63, 0x26, 0x8E, 0x31, 0x86, 0x18, 0xAC, 0x73, 0xC9, 0x29, + 0xC1, 0x1A, 0xAB, 0x94, 0x5A, 0xAF, 0xBB, 0xCB, 0xEB, 0xC5, 0xBA, 0xEE, + 0xEB, 0xB6, 0xCF, 0xA4, 0x18, 0x0C, 0x0A, 0x04, 0x88, 0x31, 0xB6, 0xBB, + 0x33, 0x16, 0x82, 0x51, 0x42, 0x19, 0x63, 0x80, 0x40, 0x29, 0x93, 0x65, + 0x32, 0x02, 0x7A, 0xFE, 0xEA, 0x64, 0x34, 0x1C, 0x68, 0xEB, 0x7D, 0x08, + 0xEF, 0x3F, 0x7A, 0x60, 0x9D, 0xFF, 0xE2, 0xAB, 0xE7, 0xC3, 0xE1, 0x70, + 0x34, 0x1E, 0xCD, 0x97, 0xEB, 0x61, 0x55, 0x76, 0x7D, 0x0F, 0x10, 0x87, + 0x55, 0xD9, 0xB6, 0xDD, 0x70, 0x34, 0x8A, 0x80, 0xBA, 0xA6, 0x19, 0x55, + 0x39, 0x46, 0x71, 0x67, 0x32, 0x02, 0x84, 0x92, 0xDF, 0x7F, 0x04, 0xA0, + 0x84, 0x48, 0xC1, 0x9D, 0xF7, 0x89, 0x17, 0xE1, 0x7D, 0x0C, 0x00, 0x89, + 0xA5, 0xBC, 0x5C, 0xD7, 0x6D, 0xA7, 0x7F, 0xF8, 0xF1, 0x93, 0xAA, 0x2A, + 0xBF, 0xFA, 0xFA, 0x39, 0x63, 0xEC, 0x60, 0x6F, 0xBA, 0xAE, 0xDB, 0x10, + 0x42, 0x82, 0xAB, 0x22, 0xA0, 0xAE, 0xED, 0xB2, 0x4C, 0x24, 0x93, 0xBF, + 0x2C, 0x93, 0x5A, 0x6B, 0xCE, 0x36, 0x38, 0x74, 0x26, 0x45, 0xA2, 0x4B, + 0x02, 0x40, 0xDA, 0x45, 0x3B, 0xE7, 0x9D, 0x0F, 0xC6, 0xB8, 0x9D, 0x9D, + 0x51, 0xF0, 0xC1, 0x39, 0xCB, 0x18, 0xB1, 0xC6, 0x11, 0x82, 0xF3, 0x5C, + 0x5A, 0xEB, 0x62, 0x04, 0xCE, 0x19, 0x46, 0xA0, 0x8D, 0x1D, 0x0F, 0x07, + 0x08, 0xA3, 0xA6, 0xED, 0x62, 0x88, 0x8C, 0x51, 0x8C, 0xF1, 0xE1, 0xE1, + 0x5E, 0x08, 0xE1, 0xE2, 0xF2, 0xE6, 0xE1, 0xFD, 0xFD, 0x41, 0x55, 0x3A, + 0xEF, 0x37, 0x47, 0xDA, 0x76, 0x94, 0x44, 0x1B, 0x5F, 0xF7, 0xDB, 0x8F, + 0xA0, 0x88, 0xD2, 0x25, 0x04, 0x9F, 0x7D, 0xF1, 0x74, 0xB9, 0x6E, 0xAD, + 0x0B, 0x79, 0x26, 0x9D, 0x73, 0xDE, 0x47, 0xC6, 0x29, 0xA3, 0x24, 0xB8, + 0x80, 0x31, 0x12, 0x82, 0x1B, 0xE3, 0x92, 0x9E, 0x34, 0xB5, 0x63, 0x94, + 0x12, 0xEF, 0x5D, 0x3A, 0x30, 0xA5, 0xE4, 0xD6, 0x6E, 0x36, 0x95, 0x21, + 0x06, 0x63, 0x0D, 0x46, 0xB8, 0xD7, 0xA6, 0xCC, 0xB3, 0xC9, 0xA0, 0xCA, + 0x32, 0x91, 0x16, 0xF7, 0x69, 0x32, 0xE5, 0x9C, 0x12, 0x82, 0x93, 0x85, + 0x19, 0x42, 0x80, 0x20, 0x26, 0x8C, 0x3C, 0x02, 0x38, 0x1F, 0x9A, 0x3E, + 0xE5, 0x84, 0x06, 0xA5, 0x8D, 0x73, 0x0E, 0x10, 0xF2, 0x3E, 0xF4, 0xBD, + 0xDA, 0xDB, 0x1B, 0x33, 0x4A, 0x43, 0x88, 0x97, 0xB3, 0x65, 0xDD, 0x76, + 0x4D, 0xDB, 0x87, 0x18, 0x39, 0xA5, 0x09, 0x32, 0x0E, 0x31, 0x52, 0x42, + 0x8C, 0x73, 0x18, 0xE1, 0x5C, 0x0A, 0xE7, 0xBC, 0x71, 0xB6, 0x53, 0x2A, + 0xD9, 0x10, 0x05, 0x00, 0x65, 0xEC, 0x7A, 0xDD, 0x39, 0x1F, 0x9C, 0xF7, + 0xDE, 0x7B, 0x6D, 0x2C, 0xC6, 0xC8, 0x5A, 0xDF, 0x75, 0x0A, 0xA1, 0x04, + 0xBF, 0xB8, 0x18, 0x21, 0x42, 0xC4, 0x18, 0x73, 0x46, 0xB7, 0x9B, 0x7D, + 0x93, 0x1C, 0xB4, 0xDA, 0xAE, 0x37, 0xC6, 0x1A, 0x6B, 0x23, 0x20, 0x67, + 0xFD, 0xFE, 0xEE, 0xE4, 0x3F, 0xFE, 0xE9, 0x0F, 0x7F, 0xF0, 0xFD, 0x47, + 0xCB, 0x55, 0x5D, 0xB7, 0xFD, 0x68, 0x50, 0xEC, 0xEE, 0x8C, 0x22, 0x80, + 0x36, 0xEE, 0xF4, 0xFC, 0xFA, 0xE9, 0xF3, 0xD7, 0x94, 0xB2, 0xD9, 0xF5, + 0x8D, 0xD5, 0x56, 0x6B, 0x73, 0x71, 0x75, 0x73, 0x7D, 0xB3, 0x68, 0x3B, + 0x65, 0xAD, 0xED, 0x7B, 0x25, 0x84, 0x68, 0x9A, 0x16, 0x13, 0x9A, 0xC0, + 0xD0, 0x9F, 0xFF, 0xF2, 0x8B, 0xD7, 0x6F, 0xCE, 0x18, 0x63, 0x7B, 0xFB, + 0xBB, 0xE4, 0x7F, 0xFE, 0x9F, 0xFE, 0xC7, 0x22, 0x97, 0x79, 0xC6, 0xA7, + 0xE3, 0x61, 0x91, 0x67, 0x29, 0x2A, 0x5C, 0x70, 0x9A, 0x49, 0x91, 0x00, + 0x54, 0xB4, 0x49, 0x94, 0xD9, 0xB8, 0x8C, 0xC5, 0x6F, 0x1B, 0x81, 0xDD, + 0x16, 0xA6, 0xDF, 0x85, 0xCF, 0x36, 0x67, 0xF2, 0xAD, 0x81, 0xF4, 0x9D, + 0xAF, 0xD9, 0x36, 0x64, 0x90, 0x5A, 0xCD, 0x04, 0xDF, 0x32, 0xC6, 0xA4, + 0x94, 0x52, 0xCA, 0x54, 0x2E, 0x13, 0x30, 0x29, 0x18, 0x13, 0x82, 0xA3, + 0x6D, 0x01, 0x85, 0x0D, 0x5D, 0x3E, 0x39, 0x14, 0x92, 0xB8, 0xF1, 0x65, + 0xF4, 0xDE, 0xFB, 0x5E, 0x19, 0x6B, 0x5C, 0x88, 0x51, 0x30, 0x9E, 0x38, + 0x35, 0x90, 0x38, 0x68, 0xDB, 0x5C, 0xBC, 0xDB, 0xA7, 0x4D, 0x35, 0x34, + 0x02, 0xA4, 0x6C, 0x0E, 0x1F, 0x7C, 0x82, 0x57, 0x30, 0xA6, 0xEF, 0x86, + 0x68, 0x00, 0x8C, 0x51, 0xD7, 0x34, 0x6F, 0x4F, 0x2F, 0x28, 0x46, 0x08, + 0x40, 0x48, 0x1E, 0x42, 0x48, 0x53, 0x0C, 0x20, 0x64, 0x9C, 0x27, 0x94, + 0x2A, 0x6D, 0x97, 0x75, 0x97, 0x16, 0xC0, 0xD6, 0x59, 0xE7, 0x82, 0xB6, + 0x4E, 0x1B, 0xC7, 0x19, 0x49, 0x13, 0xE2, 0xEE, 0xEE, 0x18, 0x63, 0x94, + 0x82, 0xE6, 0xC7, 0xA3, 0x01, 0xC1, 0x49, 0x36, 0x1F, 0x8C, 0x31, 0x89, + 0x4A, 0xAA, 0x7A, 0x2D, 0x25, 0x2F, 0x8B, 0x9C, 0x10, 0x24, 0x25, 0x1F, + 0x0E, 0x4B, 0xC6, 0x39, 0x02, 0x44, 0x39, 0x4B, 0x31, 0x54, 0x31, 0xC2, + 0xCE, 0xCE, 0x78, 0x34, 0x2C, 0x39, 0xA3, 0x42, 0x0A, 0xBC, 0xB5, 0x4B, + 0x02, 0x00, 0xBC, 0x31, 0x51, 0x7A, 0x97, 0x08, 0xE5, 0xBD, 0xB7, 0xD6, + 0xA9, 0xDE, 0x74, 0xAD, 0xB2, 0xC6, 0x2D, 0x96, 0xEB, 0xAB, 0xD9, 0xFA, + 0xE4, 0xFC, 0xE6, 0xEA, 0x66, 0xB5, 0x58, 0xB7, 0x89, 0xD5, 0x3C, 0x1D, + 0x0F, 0xD3, 0x26, 0x41, 0x4A, 0x4E, 0x09, 0x2E, 0xCB, 0xBC, 0xED, 0xF4, + 0x6C, 0xB6, 0x48, 0x7A, 0xAD, 0xAA, 0xCC, 0xAD, 0xF5, 0x79, 0x9E, 0x41, + 0x84, 0x93, 0xD3, 0x0B, 0x21, 0xF8, 0xC1, 0xFE, 0x54, 0x1B, 0x7B, 0x7D, + 0xB3, 0xE0, 0x94, 0x1A, 0x6B, 0x19, 0xE3, 0x45, 0x9E, 0xAD, 0xD7, 0x4D, + 0xD7, 0xF6, 0x9D, 0x52, 0xAB, 0x75, 0xB3, 0x58, 0xAC, 0x46, 0xC3, 0xF2, + 0xE8, 0x70, 0xD7, 0x5B, 0x77, 0x7A, 0x7A, 0xCE, 0x39, 0x0F, 0x3E, 0x18, + 0xA3, 0x19, 0xC6, 0x45, 0x0A, 0xB3, 0xB0, 0x5E, 0x69, 0x03, 0x11, 0x9C, + 0x0F, 0x75, 0xDD, 0x52, 0xC6, 0x9C, 0xF3, 0x52, 0x08, 0xA5, 0xF4, 0xBA, + 0xEE, 0x3E, 0x78, 0xEF, 0x9E, 0xB6, 0x7E, 0x33, 0xBA, 0x25, 0xB3, 0x1A, + 0xE7, 0x9D, 0xF5, 0x7D, 0x0A, 0xC1, 0xB3, 0x0E, 0x21, 0xE4, 0x9D, 0x4B, + 0x4D, 0x4D, 0x9A, 0xA0, 0xD3, 0x8C, 0xD9, 0x2B, 0xBD, 0x39, 0x87, 0x00, + 0x50, 0x32, 0x86, 0xA3, 0xB4, 0xEB, 0x55, 0xC2, 0x98, 0x92, 0xB9, 0x18, + 0xA1, 0x44, 0x1B, 0x9B, 0x8C, 0x15, 0x01, 0x01, 0xA5, 0x24, 0xAD, 0xF9, + 0xE7, 0x8B, 0x55, 0xBA, 0x08, 0x93, 0xE6, 0x05, 0x01, 0x20, 0x04, 0xD6, + 0xD8, 0x55, 0xDD, 0xAE, 0xD6, 0xCD, 0x87, 0x4F, 0x1E, 0x05, 0x1F, 0x52, + 0x53, 0x0B, 0x61, 0xD3, 0x95, 0x45, 0x00, 0x78, 0x67, 0x76, 0xFA, 0x6E, + 0x73, 0x65, 0xB4, 0xF9, 0xD5, 0x6F, 0x9E, 0xAE, 0xD6, 0xED, 0x66, 0xC3, + 0xA3, 0x0D, 0xC6, 0x58, 0x48, 0x8E, 0xB6, 0xE4, 0x1E, 0x00, 0x48, 0xED, + 0x76, 0xB2, 0xB8, 0x23, 0x84, 0x50, 0x82, 0x94, 0xB2, 0x82, 0xD3, 0x08, + 0x68, 0xB5, 0x6E, 0x38, 0x67, 0x36, 0xED, 0x2B, 0xD0, 0xA6, 0xA7, 0x8B, + 0x01, 0xF6, 0x77, 0xC7, 0x45, 0x2E, 0x12, 0x5A, 0x6F, 0xAC, 0xF5, 0x3E, + 0xF9, 0x0E, 0xD2, 0x34, 0x76, 0x84, 0x08, 0x49, 0xDE, 0x48, 0x08, 0xB2, + 0xD6, 0x59, 0xEB, 0x00, 0x91, 0x44, 0xC3, 0x0C, 0x3E, 0x34, 0x4D, 0x6F, + 0xBC, 0xB7, 0xD6, 0x1A, 0xE3, 0x76, 0x26, 0x03, 0xE7, 0xFC, 0xF1, 0xE9, + 0x55, 0xDB, 0x29, 0xA5, 0x8D, 0xD1, 0x36, 0x39, 0xC4, 0x24, 0x20, 0xD8, + 0xFB, 0x40, 0x08, 0x42, 0x18, 0x73, 0x4A, 0x13, 0x69, 0x56, 0x1B, 0xEB, + 0x43, 0x84, 0x08, 0x18, 0xE3, 0x2C, 0x93, 0x55, 0x55, 0x28, 0xE3, 0x86, + 0xC3, 0xAA, 0x1A, 0x94, 0x52, 0xCA, 0xE9, 0x74, 0x1C, 0x43, 0x5C, 0xD5, + 0x5D, 0xDB, 0xF5, 0xD6, 0x79, 0x63, 0x4C, 0x88, 0x51, 0x69, 0xB3, 0x5E, + 0xB7, 0xD6, 0xFA, 0xA4, 0x45, 0x31, 0xC6, 0xAD, 0xD6, 0x8D, 0xB6, 0x2E, + 0xC6, 0x38, 0x1C, 0x94, 0x8C, 0xB2, 0xCB, 0xEB, 0x1B, 0x84, 0x50, 0x99, + 0xCB, 0x8F, 0x3F, 0xFC, 0xE0, 0x9F, 0xFE, 0xF1, 0x1F, 0xEE, 0x4E, 0xC7, + 0x8B, 0xE5, 0xFA, 0xF2, 0x7A, 0x81, 0x00, 0x31, 0x46, 0x7D, 0xF0, 0xC6, + 0xFA, 0xE7, 0x2F, 0x8F, 0x4F, 0xCF, 0x2E, 0x8F, 0xEE, 0x1D, 0x9C, 0x9C, + 0x9C, 0xAD, 0x57, 0x29, 0x8D, 0x45, 0x71, 0x29, 0xB5, 0x36, 0x5D, 0xD7, + 0x5D, 0x5F, 0xCF, 0x9B, 0xBA, 0x29, 0xCB, 0xFC, 0xC9, 0xE3, 0x47, 0x5A, + 0x99, 0xD3, 0xB7, 0x17, 0xBD, 0xD2, 0x5F, 0x3F, 0x7F, 0x73, 0xB0, 0xBF, + 0x5B, 0xE4, 0xB9, 0x52, 0x8A, 0xFC, 0xCB, 0x7F, 0xF9, 0xBF, 0x48, 0xC1, + 0xB3, 0xCD, 0x38, 0x13, 0x39, 0x67, 0x89, 0x17, 0xCA, 0x18, 0x93, 0x52, + 0xA4, 0x43, 0x9E, 0xB1, 0x84, 0x53, 0x93, 0xDB, 0x1A, 0x14, 0xEE, 0x84, + 0xAD, 0xDD, 0x2D, 0x55, 0x77, 0x4B, 0xD8, 0xEF, 0x7E, 0xE4, 0x77, 0xBB, + 0x36, 0xD8, 0x72, 0x6B, 0x29, 0xA5, 0x9C, 0xF3, 0x04, 0x6F, 0xA5, 0xAF, + 0xA1, 0x78, 0xB3, 0x1B, 0x45, 0x5B, 0x6F, 0x37, 0xEF, 0x83, 0xB5, 0x49, + 0x5E, 0x07, 0x00, 0xA0, 0xB4, 0x4D, 0x11, 0xAD, 0x21, 0x44, 0x63, 0x9C, + 0x31, 0x1B, 0x41, 0x96, 0xE0, 0x14, 0x61, 0x94, 0x96, 0xD1, 0xCE, 0xBB, + 0xF4, 0x96, 0x10, 0x4A, 0x10, 0x46, 0x31, 0x26, 0x21, 0x70, 0x08, 0x21, + 0x89, 0x3A, 0x63, 0x5A, 0x12, 0x13, 0x42, 0x51, 0x8A, 0x1C, 0xB8, 0xF3, + 0xD3, 0x61, 0x8C, 0x97, 0xF3, 0xF9, 0xE5, 0xF9, 0x85, 0xD2, 0x4E, 0x30, + 0x82, 0x10, 0xF4, 0xCA, 0x70, 0x86, 0x8D, 0x35, 0xE9, 0x8A, 0x89, 0x00, + 0x6D, 0x67, 0xEA, 0x56, 0xA7, 0x96, 0x36, 0xB9, 0x1F, 0xA6, 0x5B, 0xF4, + 0x83, 0xF7, 0x0E, 0x7D, 0x88, 0x9C, 0xB1, 0x7B, 0xFB, 0xD3, 0x64, 0x39, + 0x30, 0x1E, 0x95, 0x00, 0xC9, 0x71, 0xC9, 0x1B, 0x6D, 0x10, 0xA0, 0x75, + 0xDD, 0x22, 0x04, 0x9C, 0x31, 0x84, 0x91, 0x31, 0xB6, 0xA9, 0xDB, 0xD1, + 0xA0, 0x9C, 0x4C, 0x46, 0x69, 0x9F, 0x4D, 0x29, 0xC5, 0x04, 0x33, 0x46, + 0xB3, 0x5C, 0x4A, 0xC1, 0x29, 0xA3, 0x32, 0x93, 0x9B, 0x49, 0xF9, 0x4E, + 0xB7, 0x7B, 0x7B, 0xBA, 0xC4, 0x18, 0xBD, 0x0F, 0x5A, 0xE9, 0x5E, 0x69, + 0xD5, 0xAB, 0xAE, 0xD7, 0x67, 0xE7, 0xB3, 0xA7, 0xAF, 0x2E, 0xDE, 0x9C, + 0xCD, 0x9C, 0x8F, 0x46, 0xDB, 0xB2, 0xCC, 0x53, 0x2C, 0xC0, 0xA0, 0x2A, + 0x62, 0x8C, 0xB3, 0xC5, 0x5A, 0x1B, 0xD7, 0x2B, 0xA3, 0xB5, 0xBD, 0xBA, + 0x59, 0x34, 0x6D, 0x4F, 0x29, 0xA5, 0x8C, 0x28, 0x65, 0x9C, 0xF3, 0x99, + 0x94, 0xD3, 0xE9, 0x48, 0x4A, 0xB1, 0x5C, 0xD5, 0x57, 0xB3, 0x79, 0x55, + 0x95, 0xA7, 0x67, 0x97, 0xC6, 0x58, 0xEF, 0xC3, 0x6A, 0xB5, 0xDE, 0xDD, + 0xDD, 0xC9, 0x38, 0xE3, 0x52, 0x2C, 0x96, 0x2B, 0x8C, 0x30, 0x02, 0xD8, + 0x99, 0x0C, 0x76, 0x86, 0x05, 0x00, 0xD4, 0x75, 0xD3, 0x77, 0xFD, 0xCE, + 0xCE, 0x88, 0x60, 0x34, 0xA8, 0xF2, 0x24, 0x9E, 0xEF, 0x7B, 0xB5, 0x5A, + 0x77, 0x84, 0x10, 0xEB, 0xFC, 0x7C, 0xB1, 0x96, 0x82, 0x67, 0x92, 0x87, + 0x10, 0x32, 0x29, 0xC6, 0xC3, 0x12, 0x21, 0xB4, 0x33, 0x1D, 0x7F, 0xF2, + 0xD1, 0x93, 0xF9, 0x7C, 0x39, 0xBB, 0x59, 0xC4, 0x18, 0x6F, 0xF5, 0xBD, + 0x8C, 0x31, 0xC6, 0x58, 0x72, 0x03, 0xE8, 0x7A, 0x05, 0x80, 0xD2, 0x29, + 0x22, 0x05, 0xD7, 0xC6, 0xC4, 0x18, 0x31, 0x82, 0x94, 0x29, 0x87, 0x10, + 0x0A, 0x21, 0xEE, 0xED, 0x4E, 0xB3, 0x4C, 0xB4, 0x5D, 0x4F, 0x09, 0x49, + 0xD3, 0x60, 0x8A, 0x65, 0xD0, 0xDA, 0x50, 0xC6, 0x76, 0x26, 0x23, 0x4C, + 0x52, 0xFC, 0x0D, 0x6F, 0xBB, 0xDE, 0x39, 0x5F, 0x16, 0x39, 0xA5, 0x44, + 0x29, 0xC3, 0x68, 0x22, 0xFD, 0x59, 0x42, 0x48, 0xDB, 0xF4, 0x87, 0xFB, + 0xD3, 0xD1, 0xA0, 0x72, 0xCE, 0x6F, 0x16, 0x0B, 0xE9, 0x1A, 0x06, 0xD8, + 0x4A, 0xC8, 0xDF, 0x2D, 0xA9, 0x28, 0xA5, 0x57, 0xB3, 0xF9, 0x57, 0xDF, + 0xBC, 0x9A, 0x4E, 0x27, 0x4A, 0x69, 0xC1, 0xA9, 0xB1, 0x36, 0x95, 0xBB, + 0x98, 0x3A, 0x1D, 0x63, 0x52, 0xE6, 0x66, 0x4A, 0xAC, 0x48, 0xA7, 0x28, + 0x00, 0x58, 0xE7, 0x85, 0x48, 0xFE, 0x88, 0x94, 0x12, 0xE2, 0x7D, 0x50, + 0xC6, 0x58, 0xE7, 0xAD, 0xF5, 0x00, 0xF1, 0x8F, 0x3E, 0x79, 0x72, 0x74, + 0x30, 0xC9, 0x33, 0xD1, 0x2B, 0xE3, 0x7C, 0xD0, 0xD6, 0x16, 0x99, 0xC4, + 0x04, 0x2B, 0x65, 0xB7, 0xF6, 0x0F, 0x1B, 0x4A, 0xA6, 0xE0, 0x4C, 0x6B, + 0x63, 0x5D, 0x00, 0x00, 0x29, 0x12, 0xC6, 0x6F, 0x5C, 0x08, 0x21, 0x44, + 0xA3, 0x6D, 0x6A, 0x00, 0x53, 0xAD, 0xCC, 0xA4, 0xC4, 0x08, 0x19, 0x63, + 0x13, 0xD6, 0x42, 0x28, 0x49, 0x86, 0x57, 0x31, 0x46, 0x8A, 0xB1, 0x60, + 0x8C, 0x12, 0xE4, 0x7C, 0x6C, 0x3A, 0xB5, 0x58, 0x35, 0x94, 0x52, 0x6D, + 0xDC, 0xD5, 0xCD, 0x32, 0xCB, 0xE4, 0xCE, 0x64, 0x24, 0x04, 0xCF, 0xA5, + 0xD8, 0xDF, 0x9D, 0x8C, 0x47, 0x83, 0xC9, 0x78, 0xF8, 0xF0, 0xFE, 0x81, + 0x73, 0xFE, 0xFC, 0xE2, 0x3A, 0x01, 0x64, 0x6D, 0xAF, 0x8C, 0x35, 0xC6, + 0xB9, 0xA6, 0x6D, 0xBD, 0x8F, 0x42, 0xF0, 0xD5, 0xBA, 0x69, 0xBB, 0xBE, + 0x57, 0x5A, 0x69, 0x33, 0x1A, 0x56, 0x21, 0xC2, 0x74, 0x67, 0xFC, 0xA7, + 0xFF, 0xE4, 0x27, 0x3F, 0xF8, 0xDE, 0x7B, 0xC6, 0xD8, 0x97, 0x6F, 0xCE, + 0x66, 0x37, 0x4B, 0xEB, 0x9C, 0x4E, 0xC3, 0x1F, 0x46, 0x6F, 0xCE, 0x2E, + 0x4E, 0x4E, 0xCF, 0x87, 0x55, 0xB9, 0x58, 0xAD, 0xCF, 0x4E, 0x2E, 0x28, + 0xC6, 0x32, 0x93, 0x79, 0x9E, 0x79, 0xEF, 0xAD, 0x31, 0x08, 0x41, 0x96, + 0x49, 0x4A, 0xE9, 0x62, 0xB1, 0x5E, 0xD7, 0x4D, 0xD3, 0xB5, 0x4D, 0xDD, + 0x3D, 0x7B, 0xF1, 0xE6, 0x47, 0x3F, 0xFC, 0x28, 0x46, 0xF8, 0xED, 0x57, + 0xCF, 0xF6, 0x76, 0xA7, 0xF4, 0xF6, 0x78, 0x07, 0x78, 0x87, 0x1A, 0xBD, + 0xAB, 0x59, 0x9B, 0xFC, 0xE4, 0x77, 0x5F, 0x93, 0xDA, 0xB1, 0xBB, 0x1B, + 0x80, 0xFF, 0x1F, 0x8F, 0xB8, 0x15, 0xAF, 0xDF, 0x06, 0x7E, 0x90, 0x3B, + 0x01, 0x97, 0x31, 0x04, 0x08, 0x31, 0x99, 0x78, 0x6F, 0x7C, 0xD1, 0xB6, + 0x4B, 0x4F, 0x6D, 0x6C, 0x42, 0xD0, 0x31, 0xC6, 0x04, 0xA3, 0xC4, 0x15, + 0x82, 0x8D, 0x94, 0x04, 0x51, 0x82, 0x04, 0xA7, 0xA9, 0xCA, 0xF8, 0xE0, + 0x63, 0x8C, 0x18, 0x61, 0xC6, 0x08, 0xDD, 0xFC, 0x3A, 0xE9, 0x78, 0xDD, + 0xFC, 0x16, 0x21, 0x84, 0x18, 0x13, 0xBF, 0x97, 0xA0, 0xBB, 0xC8, 0xDD, + 0x9D, 0x07, 0x25, 0x38, 0x25, 0x1E, 0x50, 0x82, 0x62, 0x08, 0x94, 0x12, + 0x1F, 0x92, 0x96, 0x4D, 0x95, 0x79, 0x16, 0x22, 0x0C, 0xCA, 0xEC, 0x7A, + 0xD1, 0x52, 0x00, 0x40, 0x98, 0x32, 0xAA, 0x8D, 0xE3, 0x3C, 0x1C, 0x1D, + 0xED, 0x8D, 0x06, 0xE5, 0xBA, 0xE9, 0x62, 0x0C, 0x67, 0xE7, 0x97, 0x69, + 0xB3, 0x13, 0x23, 0x2C, 0x97, 0x75, 0x8C, 0x71, 0x32, 0x19, 0x12, 0x82, + 0xDB, 0xB6, 0x9F, 0xDD, 0x2C, 0x29, 0xC6, 0x93, 0xC9, 0x90, 0x52, 0x62, + 0x8C, 0x09, 0xCE, 0x8E, 0x46, 0x43, 0xC2, 0x68, 0xAA, 0xBC, 0xB7, 0xB3, + 0xFC, 0xDD, 0x33, 0x63, 0xAB, 0xBA, 0x07, 0xD8, 0x10, 0x2C, 0xF1, 0x6D, + 0x23, 0xE6, 0x9D, 0x5F, 0xAF, 0x1B, 0xA5, 0x35, 0x63, 0xAC, 0xEF, 0xCD, + 0xF3, 0xE3, 0xCB, 0x9B, 0x45, 0x53, 0x14, 0x05, 0xA5, 0xB6, 0x69, 0xDA, + 0xAA, 0x2A, 0x19, 0x67, 0x21, 0x84, 0x32, 0x97, 0x4A, 0x5B, 0xE3, 0x5C, + 0xD3, 0xE9, 0xA6, 0x5D, 0x15, 0x39, 0x0F, 0x01, 0x62, 0x84, 0x3C, 0xCF, + 0xD2, 0x91, 0x10, 0x7C, 0x02, 0x47, 0xBC, 0x56, 0xBA, 0xCC, 0x33, 0x4E, + 0xE9, 0xD7, 0xCF, 0x5E, 0x11, 0x4A, 0x1E, 0x1C, 0x1D, 0xBE, 0x7C, 0xF9, + 0x0A, 0x63, 0xE2, 0x9C, 0xBB, 0xBA, 0x9E, 0xDD, 0xDB, 0x9F, 0x62, 0x82, + 0xF7, 0x76, 0xA7, 0x5D, 0xD7, 0x0B, 0x46, 0x73, 0x29, 0xB4, 0xB6, 0xE3, + 0x41, 0x41, 0x50, 0x81, 0x20, 0x62, 0x80, 0xFD, 0xBD, 0x69, 0xBA, 0xAB, + 0x63, 0x08, 0xD6, 0x98, 0xD5, 0x6A, 0x7D, 0xFA, 0xF6, 0x12, 0x51, 0x36, + 0x1E, 0x0E, 0x5E, 0x1E, 0x9F, 0x3D, 0xBC, 0x7F, 0x80, 0x10, 0x6A, 0xBA, + 0x5E, 0x08, 0xC6, 0x28, 0xC9, 0x38, 0xF3, 0xDE, 0x7F, 0xFC, 0x83, 0xC7, + 0x2F, 0x5E, 0x1E, 0x27, 0xCD, 0x26, 0xC4, 0x18, 0x62, 0x5C, 0xAD, 0x6B, + 0x40, 0xC0, 0x19, 0xF5, 0xDE, 0x53, 0x9A, 0xC8, 0x8C, 0x91, 0x20, 0x14, + 0x63, 0x14, 0x9C, 0xC6, 0x88, 0x42, 0xF0, 0xCE, 0x79, 0x21, 0x44, 0xDF, + 0x77, 0x45, 0x9E, 0x25, 0x28, 0x4D, 0x70, 0xDE, 0x75, 0x7D, 0xB2, 0xC7, + 0x48, 0x40, 0x08, 0xA5, 0x74, 0xBD, 0x6E, 0x9C, 0x73, 0x83, 0xAA, 0x88, + 0x31, 0x10, 0x4C, 0xF3, 0x4C, 0x5E, 0xCD, 0xE6, 0x55, 0x99, 0xA7, 0x5C, + 0x2B, 0x8C, 0x90, 0xF7, 0x9E, 0x12, 0x42, 0x31, 0x68, 0xE7, 0x5E, 0x9F, + 0xBC, 0xBD, 0x7F, 0x6F, 0x7F, 0x7B, 0x5A, 0xDC, 0x41, 0xF9, 0x23, 0x78, + 0xE4, 0x6F, 0x01, 0xB3, 0x10, 0x20, 0xC9, 0x09, 0x42, 0x8C, 0x37, 0xF3, + 0x05, 0xDD, 0xD0, 0x2C, 0xF0, 0xED, 0xF7, 0x44, 0x04, 0x21, 0x04, 0xAD, + 0x15, 0xC6, 0xC8, 0x87, 0x80, 0x3C, 0x10, 0x82, 0xD3, 0x41, 0x4C, 0x08, + 0xB2, 0x2E, 0x79, 0x6D, 0x7A, 0x82, 0xD0, 0xA0, 0xCA, 0x05, 0xA7, 0xEB, + 0xB6, 0x77, 0xD6, 0xA7, 0x79, 0x22, 0x55, 0xD8, 0x64, 0x27, 0x29, 0x18, + 0x8B, 0x10, 0x9D, 0x75, 0x84, 0xA0, 0xE0, 0x23, 0x21, 0x29, 0x6B, 0xD1, + 0x23, 0x40, 0x18, 0x61, 0x29, 0xA5, 0x69, 0x3A, 0x82, 0x51, 0x4A, 0x74, + 0xEE, 0x95, 0xB1, 0xCE, 0xDD, 0x7A, 0xCC, 0xD4, 0x4D, 0x87, 0x10, 0x4A, + 0xC6, 0x67, 0x21, 0x04, 0xC6, 0xD8, 0xED, 0xF5, 0xC3, 0x28, 0xED, 0xB5, + 0x8D, 0x31, 0x4A, 0xC1, 0x03, 0x80, 0x75, 0x5E, 0x29, 0xD3, 0x2B, 0x15, + 0x63, 0xF8, 0xE4, 0xE3, 0x27, 0xC9, 0x29, 0x88, 0x73, 0x46, 0x09, 0x3E, + 0xBD, 0x98, 0x1D, 0xEC, 0xEF, 0x1C, 0xEE, 0x4D, 0x56, 0xEB, 0x66, 0xB9, + 0xEE, 0xDA, 0xAE, 0xDF, 0x99, 0x8E, 0x7E, 0xF8, 0xC9, 0x87, 0xBF, 0xFE, + 0xFC, 0x6B, 0x1F, 0x42, 0x0C, 0x11, 0x52, 0xD7, 0xEC, 0x63, 0xD3, 0xF6, + 0x79, 0x9E, 0x11, 0x4A, 0x48, 0xA0, 0x46, 0x9B, 0xE5, 0xBA, 0xAE, 0xCA, + 0x12, 0x01, 0xFC, 0xF8, 0x93, 0xEF, 0x4F, 0x27, 0xA3, 0xE5, 0xAA, 0x79, + 0xF6, 0xE2, 0xCD, 0x6A, 0xB9, 0x92, 0x52, 0x60, 0x8C, 0xBA, 0x4E, 0xF9, + 0xB0, 0x4B, 0x19, 0xC5, 0x80, 0xFE, 0xE8, 0xC7, 0x1F, 0x33, 0x4A, 0xFF, + 0xF5, 0xFF, 0xF5, 0xB7, 0x9C, 0x11, 0x84, 0x71, 0x51, 0x64, 0xBD, 0xD2, + 0x04, 0xA3, 0xE1, 0xB0, 0x04, 0x40, 0xCE, 0x5A, 0x4A, 0x30, 0x00, 0x3A, + 0x39, 0x3E, 0x15, 0x52, 0x00, 0xE0, 0x10, 0xA2, 0x52, 0xEA, 0xF1, 0x07, + 0x0F, 0x08, 0xC1, 0xE7, 0x97, 0x33, 0xF2, 0x57, 0x7F, 0xF5, 0x57, 0x70, + 0xA7, 0x63, 0x4A, 0xBB, 0xC5, 0xF4, 0xD7, 0xDB, 0xC3, 0x3F, 0x06, 0x17, + 0x82, 0x8F, 0xA9, 0x8B, 0x89, 0xB7, 0xE1, 0x42, 0xDF, 0xEA, 0xB9, 0xFE, + 0x83, 0xAB, 0x58, 0x8C, 0x18, 0xFD, 0x03, 0xD5, 0x30, 0xC4, 0x04, 0xA5, + 0xE2, 0x4D, 0xCE, 0x4A, 0xB2, 0xBC, 0x8D, 0xCE, 0xBB, 0x10, 0xC2, 0x26, + 0x2E, 0x6C, 0x13, 0x92, 0x1A, 0x9D, 0x0B, 0x89, 0xF8, 0xC7, 0x28, 0xCE, + 0x24, 0xCF, 0xA4, 0xD8, 0x8A, 0x4A, 0x10, 0x25, 0x84, 0xB1, 0xB4, 0x06, + 0xDA, 0x18, 0xCC, 0x26, 0x11, 0x4C, 0x7A, 0x47, 0x6F, 0x65, 0x06, 0x98, + 0xFC, 0x8E, 0xEE, 0x3D, 0x46, 0x88, 0x01, 0x63, 0x32, 0xBF, 0xB9, 0x39, + 0x79, 0x73, 0xEA, 0x3C, 0x48, 0x41, 0x24, 0xA7, 0x94, 0x60, 0x41, 0xB1, + 0xB5, 0xAE, 0x28, 0x8A, 0xBE, 0x57, 0x8C, 0x92, 0xB2, 0x2A, 0xB9, 0xE0, + 0xC6, 0x7A, 0x21, 0xC5, 0xDE, 0xEE, 0x78, 0x67, 0x67, 0x94, 0x65, 0x22, + 0x85, 0x03, 0xE6, 0x99, 0x40, 0x18, 0x55, 0x55, 0xB5, 0x33, 0x19, 0x0D, + 0x07, 0x65, 0x99, 0x67, 0xE3, 0xD1, 0xA0, 0x28, 0x24, 0x63, 0x0C, 0x42, + 0x58, 0x37, 0x2D, 0xC6, 0xA4, 0x2C, 0x0B, 0x42, 0x70, 0x9E, 0x09, 0xC1, + 0xE9, 0x60, 0x50, 0x1D, 0xDC, 0xDB, 0xDB, 0x04, 0x97, 0xDE, 0x69, 0x60, + 0xF1, 0xD6, 0x86, 0xFB, 0xB6, 0x0B, 0xBB, 0xFB, 0x1A, 0x86, 0x10, 0xB4, + 0xD6, 0x8B, 0xC5, 0x7A, 0xB9, 0x5C, 0xAF, 0x56, 0x89, 0x60, 0x6D, 0x5F, + 0x9D, 0xCE, 0xCE, 0xAF, 0x16, 0x8C, 0x31, 0x63, 0x2D, 0x63, 0x54, 0x4A, + 0x79, 0x4B, 0x29, 0xF0, 0xDE, 0x6B, 0xEB, 0xEA, 0x56, 0x3B, 0x1F, 0x39, + 0x67, 0x42, 0xB0, 0x32, 0xCF, 0xA5, 0x94, 0x00, 0xF1, 0xF2, 0x6A, 0x06, + 0x08, 0x7B, 0xE7, 0xBA, 0xB6, 0x9D, 0x8C, 0x06, 0xD3, 0x49, 0x55, 0xB7, + 0x2D, 0xC4, 0x90, 0x92, 0x09, 0xB5, 0x36, 0xEB, 0x75, 0x6D, 0x8D, 0x1E, + 0x54, 0x25, 0x46, 0x88, 0x10, 0x3A, 0x1E, 0x0D, 0xF6, 0xA6, 0xE3, 0xF9, + 0x7C, 0x79, 0xEF, 0x70, 0xF7, 0x7B, 0x8F, 0x1F, 0x32, 0x82, 0x53, 0xA0, + 0x06, 0xC1, 0xA4, 0x2C, 0xF3, 0x3C, 0x13, 0xDE, 0xFB, 0xD9, 0x7C, 0x75, + 0xB3, 0x58, 0x73, 0x29, 0x87, 0x83, 0x6A, 0x36, 0x5F, 0x36, 0xAD, 0xDA, + 0xDF, 0x9B, 0x62, 0x8C, 0xAA, 0xB2, 0x28, 0x8B, 0x1C, 0x21, 0xB4, 0x58, + 0x35, 0x08, 0x64, 0x54, 0x67, 0x17, 0x00, 0x00, 0x20, 0x00, 0x49, 0x44, + 0x41, 0x54, 0xA1, 0x4C, 0x30, 0xEB, 0x1C, 0xC2, 0x88, 0x52, 0x72, 0x7C, + 0xFC, 0x56, 0x48, 0x4E, 0x30, 0xF6, 0xCE, 0x87, 0x10, 0x38, 0xA3, 0x69, + 0x2C, 0x50, 0x4A, 0x13, 0x8C, 0xBC, 0x0F, 0x45, 0x99, 0x59, 0xBB, 0xE9, + 0x35, 0xFA, 0x5E, 0x01, 0x40, 0x8A, 0xE3, 0xA4, 0x94, 0xC5, 0x08, 0xCB, + 0xD5, 0x8A, 0x31, 0xEE, 0x9C, 0x15, 0x82, 0x7B, 0xE7, 0x04, 0xE7, 0x94, + 0xB1, 0x18, 0x21, 0xCB, 0x44, 0xDF, 0xEB, 0xA4, 0x4F, 0xB3, 0xCE, 0xEE, + 0x4C, 0x46, 0xDA, 0xD8, 0x5E, 0x9B, 0x10, 0x62, 0xCA, 0xBE, 0x4B, 0xFD, + 0xBC, 0x75, 0x8E, 0x31, 0x6A, 0xAD, 0x7D, 0xF2, 0xC1, 0x03, 0xD8, 0xCA, + 0x65, 0xE0, 0x96, 0x53, 0x06, 0xB7, 0x07, 0x7A, 0x62, 0xC6, 0x46, 0xC6, + 0xC8, 0xAB, 0xE3, 0xB7, 0xF3, 0xF9, 0x2A, 0x09, 0xDA, 0xD1, 0xD6, 0xCD, + 0x46, 0x30, 0x86, 0x09, 0x76, 0x3E, 0x48, 0x21, 0x92, 0x68, 0x25, 0x49, + 0xC7, 0xE3, 0xD6, 0x74, 0xAF, 0xD7, 0xD6, 0xFB, 0xE8, 0x43, 0x50, 0xDA, + 0x64, 0x52, 0x60, 0x82, 0x39, 0xA3, 0x92, 0xB3, 0x41, 0x95, 0x8D, 0x87, + 0xE5, 0xEE, 0x64, 0xB8, 0xD9, 0x60, 0x62, 0x9C, 0x0C, 0x39, 0x8C, 0xB1, + 0xCE, 0x7B, 0xC9, 0x68, 0x88, 0xD1, 0xF9, 0x90, 0x70, 0xBD, 0xA4, 0x43, + 0x4A, 0xCC, 0xDE, 0x24, 0x19, 0x5E, 0x37, 0xBD, 0x75, 0x5E, 0x6B, 0xA3, + 0x95, 0x4D, 0x78, 0x99, 0x0F, 0x21, 0x79, 0xD2, 0x4A, 0xC9, 0x23, 0x84, + 0x04, 0x96, 0x11, 0x82, 0xA5, 0x14, 0x79, 0x2E, 0x53, 0x0F, 0x81, 0x00, + 0x18, 0xA3, 0xD6, 0xB9, 0x5E, 0x99, 0x10, 0x20, 0x84, 0xB0, 0x58, 0xD5, + 0x84, 0xD2, 0x07, 0x87, 0x7B, 0x31, 0x86, 0xB6, 0xEB, 0x27, 0xE3, 0x11, + 0x25, 0x68, 0xB1, 0x5C, 0x4B, 0x21, 0x62, 0xDC, 0xE4, 0x5A, 0x1D, 0xEC, + 0x4D, 0x09, 0xA3, 0x00, 0xD0, 0x2B, 0xED, 0x7D, 0x28, 0xF3, 0xBC, 0xDF, + 0x44, 0xDB, 0x81, 0xF7, 0xC1, 0xBB, 0x90, 0x54, 0x19, 0xDA, 0x98, 0x3C, + 0xCF, 0x46, 0xA3, 0x4A, 0x08, 0x7E, 0x79, 0x39, 0x5B, 0x2C, 0xD7, 0x89, + 0xE6, 0xE9, 0x7D, 0xE8, 0x55, 0xCF, 0xB9, 0xC8, 0xF3, 0x7C, 0x30, 0x28, + 0xC6, 0x83, 0xC1, 0xEB, 0x93, 0xF3, 0xAE, 0x37, 0x01, 0x62, 0x59, 0xE4, + 0x42, 0x48, 0x63, 0xDD, 0xA0, 0x2A, 0x23, 0xC0, 0xB0, 0x2A, 0xD2, 0xA5, + 0x9E, 0x3C, 0x1D, 0x18, 0xE7, 0x3B, 0xD3, 0xA9, 0x73, 0xBE, 0x6E, 0xDA, + 0x83, 0xBD, 0xC9, 0x93, 0xF7, 0x1F, 0xDC, 0x3F, 0xDC, 0xA3, 0xDF, 0x19, + 0x55, 0x22, 0xA4, 0x6E, 0x28, 0x09, 0x35, 0x52, 0x19, 0xF1, 0xDE, 0x27, + 0x38, 0x7E, 0x63, 0xDA, 0xC3, 0xB9, 0xA0, 0x5C, 0xFC, 0x87, 0xD6, 0xAF, + 0xEF, 0x3C, 0x7E, 0x6F, 0x05, 0xDC, 0xF4, 0xEB, 0x49, 0x3D, 0xB1, 0xA5, + 0xB0, 0xA5, 0x46, 0x11, 0x00, 0x30, 0xC2, 0x79, 0x96, 0xA5, 0x65, 0x79, + 0xF4, 0x1B, 0xDE, 0x2C, 0x21, 0x21, 0xC4, 0x90, 0xD1, 0x0D, 0xC7, 0x38, + 0x51, 0x6A, 0x11, 0x00, 0x25, 0x18, 0x93, 0x3B, 0x85, 0x16, 0xC5, 0x64, + 0xEF, 0x91, 0xFA, 0x97, 0x6F, 0x55, 0xE1, 0xDB, 0x02, 0xB1, 0x3D, 0x75, + 0x53, 0x89, 0x00, 0x88, 0x10, 0x3C, 0xA7, 0xA4, 0xD3, 0x1E, 0x01, 0x14, + 0xB9, 0x04, 0x00, 0x02, 0x01, 0xE3, 0x2C, 0xCD, 0xAD, 0x79, 0x59, 0x64, + 0x55, 0xE5, 0x01, 0x87, 0x80, 0x02, 0xA6, 0x55, 0x59, 0x10, 0x4A, 0x09, + 0xAB, 0x95, 0xD2, 0xBD, 0x32, 0xBB, 0x3B, 0xA3, 0xFD, 0xFD, 0x7D, 0xA5, + 0xCD, 0xD1, 0xE1, 0x8E, 0x52, 0x3D, 0xC1, 0x68, 0x77, 0x3A, 0x49, 0xB6, + 0x45, 0x6B, 0xAD, 0x62, 0x84, 0x6A, 0x50, 0x31, 0x46, 0xFC, 0xC6, 0xE3, + 0xC1, 0x30, 0xCE, 0x92, 0x53, 0xE0, 0xED, 0x11, 0xB2, 0x45, 0xEB, 0x22, + 0x7C, 0x57, 0x95, 0xB5, 0x01, 0x0A, 0x01, 0x40, 0x2B, 0x7D, 0x71, 0x79, + 0xB3, 0x5C, 0xB5, 0x09, 0x5B, 0xF1, 0xDE, 0x5D, 0xCF, 0x57, 0xD7, 0xF3, + 0xB5, 0x31, 0xAE, 0x28, 0x8A, 0xE8, 0x7C, 0xDB, 0xF5, 0xC3, 0x41, 0x55, + 0x14, 0x39, 0x42, 0xC0, 0x19, 0x25, 0x18, 0x96, 0xEB, 0x4E, 0x1B, 0x97, + 0xE7, 0x42, 0x2B, 0xBD, 0x5C, 0xF6, 0x55, 0x15, 0x54, 0x6F, 0xD6, 0x75, + 0xBD, 0x5C, 0x2E, 0x76, 0x77, 0xC6, 0x9C, 0x33, 0x6B, 0xD4, 0xC5, 0xE5, + 0x6C, 0xBA, 0x33, 0xC8, 0x05, 0x37, 0x36, 0x54, 0x55, 0x41, 0x18, 0x3D, + 0xDC, 0xDF, 0x1B, 0x0E, 0x4A, 0x67, 0xCD, 0xE9, 0xD9, 0x05, 0xC6, 0x58, + 0x70, 0x1E, 0x7C, 0x60, 0x8C, 0xFC, 0xE8, 0x0F, 0x3F, 0xCA, 0x33, 0x31, + 0x18, 0x56, 0x42, 0xF0, 0xBE, 0x6D, 0xAF, 0xAF, 0x6F, 0x9A, 0x65, 0x3D, + 0x9E, 0x0C, 0x1F, 0x1C, 0xED, 0xC7, 0xE0, 0x8D, 0x36, 0x37, 0xF3, 0xD5, + 0xF5, 0xF5, 0xA2, 0x28, 0x8B, 0x87, 0x0F, 0xEE, 0x65, 0x59, 0x46, 0x08, + 0x06, 0x08, 0x5F, 0x7C, 0xF5, 0xFC, 0xC9, 0xE3, 0x87, 0x3B, 0xA3, 0xC1, + 0x68, 0x50, 0xF6, 0xBD, 0xAE, 0x3B, 0x35, 0x9D, 0x0C, 0xCF, 0xCE, 0xAF, + 0x18, 0xA5, 0x59, 0x2E, 0x11, 0x40, 0x88, 0x01, 0x21, 0x80, 0x08, 0x4D, + 0xD3, 0x0A, 0xCE, 0x39, 0x67, 0x21, 0x04, 0x07, 0x08, 0x00, 0xBA, 0x5E, + 0x79, 0xE7, 0xA4, 0x14, 0x21, 0x84, 0x3C, 0x97, 0xCE, 0xF9, 0xBE, 0xB7, + 0x02, 0x13, 0x08, 0xD1, 0xC5, 0xC4, 0x71, 0xC5, 0xC3, 0xE1, 0x20, 0x15, + 0xBB, 0x10, 0x02, 0xC2, 0x28, 0xB1, 0x52, 0x52, 0xD0, 0xAA, 0xD6, 0x86, + 0x10, 0x5C, 0xD7, 0x8D, 0x94, 0xBC, 0xED, 0x95, 0x14, 0x3C, 0x0D, 0x6B, + 0x52, 0x8A, 0xBE, 0x57, 0x42, 0x8A, 0x18, 0x62, 0xD3, 0xB4, 0xAB, 0x75, + 0x33, 0x1E, 0x55, 0x21, 0xB8, 0x8D, 0x40, 0x1C, 0x6F, 0x7C, 0xE2, 0xD1, + 0x36, 0xF1, 0x0B, 0x60, 0x83, 0xF4, 0xCF, 0x66, 0xCB, 0x64, 0x42, 0x67, + 0x8C, 0xC7, 0x84, 0x58, 0xEF, 0x42, 0x08, 0x92, 0x33, 0x67, 0x7D, 0x0A, + 0x5C, 0x03, 0x40, 0xDE, 0x5B, 0xE7, 0x29, 0xDA, 0xF2, 0xC3, 0x09, 0xC6, + 0x29, 0xB9, 0x79, 0x77, 0x32, 0x84, 0x18, 0x92, 0x8F, 0x23, 0x00, 0x14, + 0x99, 0x48, 0x35, 0xA5, 0x2C, 0x32, 0xEF, 0x3D, 0xA1, 0x1B, 0xCB, 0x96, + 0x04, 0xBF, 0xB8, 0x10, 0x8C, 0xB5, 0xC9, 0x1F, 0x30, 0x81, 0x6E, 0x18, + 0x6E, 0xD7, 0xEE, 0x80, 0x00, 0x69, 0x63, 0x56, 0x75, 0x63, 0xAC, 0x63, + 0x94, 0xBA, 0xE0, 0x82, 0x8F, 0x78, 0xDB, 0xA6, 0x85, 0x08, 0xBD, 0x52, + 0x31, 0xC6, 0xB2, 0x28, 0x92, 0x8E, 0x1D, 0x62, 0x54, 0x4A, 0x4B, 0xC9, + 0x9D, 0x77, 0x19, 0xE6, 0x18, 0x63, 0x80, 0x0D, 0x14, 0x3E, 0x1C, 0x54, + 0x75, 0xD3, 0xFD, 0xFD, 0xCF, 0x7F, 0xF3, 0xE5, 0x97, 0xCF, 0x62, 0x84, + 0xAE, 0x57, 0xDF, 0x7F, 0xFC, 0xF0, 0x27, 0x3F, 0xFA, 0xC1, 0x62, 0x59, + 0xAF, 0x1B, 0x35, 0x19, 0x55, 0xE3, 0x51, 0x95, 0xDC, 0x03, 0x8F, 0x0E, + 0xF7, 0x8A, 0x3C, 0xA7, 0x04, 0x2D, 0x57, 0xB5, 0xB5, 0x7E, 0x32, 0x1E, + 0xB5, 0x5D, 0xA7, 0x94, 0x4E, 0x13, 0x52, 0x9E, 0xE7, 0x9C, 0x33, 0x82, + 0xD1, 0xD1, 0xE1, 0xBE, 0x14, 0xBC, 0x6D, 0xFB, 0x57, 0xC7, 0x6F, 0xB5, + 0x36, 0x99, 0x14, 0x10, 0x43, 0x26, 0x45, 0x9E, 0x65, 0x28, 0xC6, 0xB6, + 0x6D, 0xEB, 0x06, 0x32, 0x29, 0x17, 0x8B, 0x95, 0xF7, 0x3E, 0xCB, 0x64, + 0xDF, 0x27, 0x22, 0x35, 0x74, 0x4A, 0xF7, 0x5D, 0xA7, 0xBA, 0x0E, 0x63, + 0xEC, 0xAC, 0x37, 0xC8, 0x02, 0x42, 0x8C, 0xF1, 0xC5, 0x72, 0xD5, 0x34, + 0xCD, 0xA0, 0xAA, 0x7E, 0xF1, 0xE9, 0x6F, 0xFE, 0xE8, 0x27, 0x9F, 0x54, + 0x45, 0x46, 0xEF, 0xDE, 0x1E, 0x00, 0x31, 0x71, 0x82, 0xC0, 0xBB, 0x18, + 0x43, 0x3A, 0x60, 0x21, 0x42, 0x88, 0xC1, 0x19, 0xBB, 0xC9, 0x7F, 0xA4, + 0x24, 0xC4, 0x20, 0x01, 0x08, 0x65, 0xF8, 0x0E, 0x6A, 0xF6, 0x0F, 0x3D, + 0x6E, 0x57, 0x9C, 0x77, 0x1B, 0x8A, 0xBB, 0x9F, 0xFD, 0xEE, 0x5F, 0x13, + 0x08, 0x7F, 0x77, 0xBF, 0x19, 0x63, 0x04, 0x48, 0x37, 0xCF, 0xA6, 0xEC, + 0x22, 0x48, 0x4C, 0xF5, 0xE0, 0x03, 0xE0, 0x88, 0x19, 0x45, 0x5B, 0x0B, + 0xFF, 0xE4, 0xF6, 0x15, 0x21, 0x40, 0x84, 0x10, 0x30, 0x21, 0x64, 0xAB, + 0x22, 0xDD, 0x4A, 0x2F, 0x31, 0xBE, 0x25, 0x91, 0x6D, 0x8B, 0xF8, 0x66, + 0x21, 0x80, 0x08, 0x03, 0x48, 0x10, 0xC6, 0xE6, 0xD5, 0x48, 0x9B, 0x69, + 0x46, 0x51, 0x99, 0x8B, 0xE4, 0xED, 0xC5, 0x19, 0xC7, 0xD6, 0x76, 0x9D, + 0xA6, 0x8C, 0x8F, 0x26, 0x13, 0x26, 0xE4, 0xBA, 0x31, 0x79, 0x91, 0xF5, + 0x0E, 0x3A, 0x6D, 0x57, 0xD7, 0x8B, 0xE1, 0x68, 0x70, 0xB4, 0x33, 0x4E, + 0xE6, 0x49, 0xCB, 0xE5, 0x6A, 0x5D, 0x77, 0x93, 0x61, 0xBE, 0xBB, 0x37, + 0x96, 0x8C, 0x63, 0x82, 0x13, 0x3D, 0x35, 0x04, 0xA0, 0x8C, 0x75, 0x5D, + 0x6F, 0x8C, 0xC9, 0x33, 0x11, 0x00, 0x13, 0xC6, 0xAA, 0xB2, 0x20, 0x1B, + 0xFE, 0xFD, 0xB7, 0xAA, 0x7C, 0xDC, 0x92, 0x4E, 0x12, 0x67, 0x38, 0xB1, + 0x55, 0x12, 0x51, 0xA6, 0xED, 0xFA, 0xE5, 0xB2, 0x59, 0xAE, 0xBB, 0xF9, + 0xAA, 0xCD, 0xA4, 0x54, 0xAA, 0x3B, 0xBF, 0x5E, 0x38, 0x1F, 0x8B, 0x22, + 0xE7, 0x3C, 0xAE, 0x56, 0x8D, 0x94, 0xA2, 0x28, 0x0A, 0xEB, 0x42, 0xD3, + 0xF5, 0xCE, 0x79, 0xA3, 0xB5, 0x14, 0x1C, 0x61, 0xCC, 0x18, 0xBD, 0x9A, + 0xCD, 0x8B, 0x2C, 0x13, 0x42, 0xAC, 0xD6, 0xCD, 0xAF, 0x3E, 0xFD, 0xCD, + 0x60, 0x58, 0xFC, 0xF3, 0xFF, 0xE4, 0x8F, 0xF3, 0x4C, 0x40, 0x84, 0x9D, + 0x51, 0xE1, 0x9C, 0x5B, 0x2C, 0x57, 0x5D, 0x6F, 0x19, 0xE7, 0xC3, 0x61, + 0x75, 0x78, 0xB8, 0xC7, 0x19, 0x25, 0x14, 0x9F, 0x5F, 0x5C, 0xDF, 0x7F, + 0x70, 0x14, 0x43, 0xD4, 0xBD, 0x7A, 0xEF, 0xC1, 0x61, 0xF0, 0x3E, 0xD9, + 0x40, 0x1E, 0x9F, 0x5E, 0xC4, 0x18, 0x05, 0x23, 0x79, 0x59, 0x64, 0x45, + 0x5E, 0x64, 0x02, 0x63, 0xEC, 0x7D, 0x74, 0xD6, 0x7A, 0xE7, 0x8D, 0xB1, + 0xCE, 0xB9, 0x75, 0xDD, 0xF4, 0xC6, 0x9D, 0x9E, 0x5D, 0x02, 0xC2, 0x22, + 0xCF, 0xBF, 0xF8, 0xE6, 0xF5, 0xD1, 0xC1, 0x74, 0x6F, 0x77, 0x92, 0x09, + 0x16, 0x21, 0x1A, 0x63, 0x0E, 0xF7, 0x76, 0x32, 0x29, 0x4F, 0x4E, 0xCF, + 0x4F, 0xCF, 0x2E, 0xB3, 0x4C, 0x68, 0x6F, 0x12, 0x95, 0x64, 0xB5, 0x5A, + 0x1D, 0x1E, 0xEE, 0x0F, 0xAA, 0x72, 0xBE, 0xAC, 0x39, 0xA3, 0xC3, 0xAA, + 0xEC, 0x95, 0x4A, 0xB2, 0x5F, 0xAD, 0xB5, 0x31, 0x0E, 0x00, 0x12, 0x2B, + 0x95, 0x4B, 0x79, 0x74, 0x6F, 0xDF, 0x1A, 0x6B, 0x9D, 0x6F, 0x9A, 0x36, + 0x55, 0x01, 0x88, 0x31, 0x84, 0x00, 0x10, 0x19, 0xA3, 0x69, 0xBA, 0xD4, + 0xC6, 0x26, 0x9A, 0x8E, 0x51, 0x16, 0x01, 0x50, 0x42, 0xAC, 0xF3, 0x79, + 0x2E, 0xBB, 0x2E, 0x70, 0x4A, 0x43, 0x8C, 0x75, 0xDD, 0x7C, 0xF3, 0xFC, + 0xD5, 0x3F, 0xFB, 0x93, 0x3F, 0xB2, 0xD6, 0xC2, 0xED, 0x7B, 0x91, 0x9C, + 0x00, 0xDF, 0xB1, 0x32, 0x00, 0x23, 0xA4, 0x8D, 0x59, 0xAE, 0x6B, 0x63, + 0xAC, 0x0B, 0x91, 0x60, 0xDC, 0xF5, 0x7D, 0x42, 0x2D, 0xAD, 0xF7, 0x55, + 0x91, 0x77, 0xBD, 0x4A, 0xC0, 0x62, 0x4C, 0xF4, 0x5D, 0x96, 0x5C, 0x80, + 0x90, 0x77, 0x5E, 0x0A, 0x96, 0x49, 0x9E, 0x4E, 0x97, 0xBE, 0xD7, 0x09, + 0x85, 0x36, 0x46, 0x71, 0x46, 0xAD, 0x0F, 0x37, 0x8B, 0x3A, 0xED, 0x85, + 0xD2, 0x4B, 0x87, 0x10, 0xB2, 0xCE, 0x09, 0xC1, 0x29, 0x42, 0x6D, 0xD7, + 0xA7, 0x0A, 0x95, 0x56, 0x1C, 0x8C, 0xB1, 0xAD, 0x51, 0x17, 0xD4, 0x75, + 0xA7, 0x92, 0x5C, 0x9F, 0x31, 0x82, 0x08, 0x22, 0xD1, 0x79, 0x87, 0x31, + 0x4E, 0x42, 0xEB, 0x10, 0x62, 0xF0, 0xA1, 0xED, 0x7A, 0xCE, 0x29, 0x65, + 0x34, 0xB9, 0x9B, 0x75, 0xBD, 0x76, 0xDE, 0xE7, 0x52, 0x00, 0x40, 0x99, + 0x67, 0xB9, 0x94, 0x04, 0xE3, 0xE5, 0xBA, 0x9D, 0xCF, 0x17, 0xCE, 0x9A, + 0xD3, 0xB3, 0x65, 0x88, 0x91, 0x33, 0xFE, 0x37, 0x7F, 0xF7, 0xEB, 0xEB, + 0xD9, 0xE2, 0x47, 0x3F, 0xFC, 0x90, 0x31, 0xA2, 0xB4, 0x09, 0x31, 0x16, + 0x99, 0x30, 0xD6, 0xCC, 0xE6, 0xCB, 0xC5, 0xB2, 0x11, 0x32, 0xFB, 0xE4, + 0xDE, 0x41, 0x08, 0xE1, 0xC5, 0xEB, 0xD3, 0x64, 0x09, 0xAB, 0xB4, 0xC1, + 0x09, 0xC5, 0xC3, 0xF0, 0xE0, 0xE8, 0xE0, 0xDE, 0xC1, 0x74, 0xCB, 0xB6, + 0x5B, 0x61, 0x4C, 0x94, 0x36, 0x8C, 0x51, 0xCA, 0x28, 0xA7, 0x24, 0x2F, + 0x72, 0x67, 0xFD, 0xAA, 0x69, 0x62, 0x84, 0xE5, 0xAA, 0x16, 0x9C, 0x75, + 0x9D, 0x83, 0x04, 0x6E, 0x46, 0x6F, 0x95, 0x25, 0x18, 0xA7, 0xEC, 0xD4, + 0x08, 0x4E, 0x69, 0x43, 0x08, 0x71, 0xEB, 0x7A, 0x32, 0x1E, 0x29, 0x4A, + 0xFB, 0x5E, 0x49, 0x5E, 0xAE, 0xD7, 0x35, 0x82, 0x48, 0x7E, 0xF6, 0xB3, + 0x9F, 0x41, 0x0C, 0x11, 0x42, 0x9A, 0xA7, 0xC2, 0xD6, 0xB4, 0x6C, 0x83, + 0x1E, 0x7B, 0x1F, 0x82, 0xB7, 0xC6, 0x5A, 0x67, 0x83, 0x0B, 0x01, 0x22, + 0xA5, 0x34, 0x89, 0x84, 0x92, 0xFA, 0xF1, 0x3B, 0xED, 0xC3, 0xBF, 0xBF, + 0x4E, 0xDD, 0xDE, 0xA5, 0xFF, 0x9E, 0x99, 0x74, 0xE3, 0x0B, 0xB9, 0x7D, + 0xC4, 0x10, 0xA2, 0x0F, 0xB7, 0x1B, 0xD0, 0xCD, 0x3F, 0x84, 0x22, 0x42, + 0x9B, 0x73, 0x31, 0xBD, 0xA1, 0xA9, 0x8A, 0x71, 0xC1, 0x18, 0xA7, 0x08, + 0x01, 0x21, 0x14, 0x6F, 0xA3, 0x98, 0xD2, 0xAF, 0x72, 0xDB, 0xC2, 0x7C, + 0x87, 0xDF, 0x7B, 0xFB, 0x63, 0xC4, 0x18, 0x21, 0x6E, 0x62, 0x0D, 0x53, + 0x19, 0xC2, 0x84, 0x38, 0x6B, 0xCE, 0xDF, 0x9E, 0x4B, 0x4E, 0x4B, 0x49, + 0xF3, 0x22, 0x93, 0x52, 0xF0, 0x4D, 0xA1, 0x04, 0xC6, 0xF9, 0x60, 0x58, + 0x7D, 0xF9, 0xF4, 0xF8, 0xC5, 0xEB, 0x8B, 0xB3, 0xCB, 0x79, 0xDB, 0x76, + 0x65, 0x59, 0x62, 0x4A, 0xEF, 0xED, 0x8D, 0xEF, 0x1D, 0xEC, 0x8C, 0x06, + 0x05, 0xC1, 0x70, 0x3D, 0x5B, 0xEE, 0xED, 0x4E, 0xEE, 0x1F, 0xED, 0x55, + 0x65, 0x99, 0xB8, 0xB9, 0x18, 0xA3, 0x44, 0xF7, 0x25, 0x18, 0xAF, 0x57, + 0xB5, 0x10, 0x82, 0x30, 0xB9, 0x5E, 0xD5, 0xF7, 0x0F, 0x77, 0x8E, 0xEE, + 0xED, 0x12, 0x4A, 0xBF, 0xF3, 0xCA, 0x7C, 0xC7, 0x01, 0x29, 0x84, 0xE0, + 0x9D, 0x73, 0x2E, 0x3A, 0xE7, 0x4F, 0xCF, 0xAE, 0xDE, 0x9C, 0x5C, 0x5D, + 0xDD, 0xAC, 0xAE, 0x6F, 0xD6, 0x08, 0x21, 0x1F, 0x62, 0xAB, 0x4C, 0x4A, + 0x51, 0x33, 0xDA, 0x58, 0x6B, 0x23, 0x44, 0x4C, 0x70, 0xDB, 0x75, 0x84, + 0x12, 0x63, 0x6D, 0x9E, 0xC9, 0xA4, 0x5F, 0xC8, 0x32, 0xD9, 0xF5, 0xBD, + 0xD2, 0x26, 0x13, 0x5C, 0x4A, 0xE9, 0xAC, 0x2B, 0x4B, 0xF9, 0xFE, 0xC3, + 0x7B, 0x93, 0xD1, 0x20, 0x97, 0x42, 0x4A, 0x4A, 0x30, 0xCE, 0xA4, 0x50, + 0xCA, 0x52, 0x46, 0x66, 0x37, 0x4B, 0xE7, 0xBC, 0x73, 0xEE, 0xF9, 0xAB, + 0x93, 0x61, 0x55, 0x55, 0x65, 0x3E, 0x1E, 0x0D, 0x28, 0xC1, 0x8C, 0x12, + 0x29, 0xC5, 0xE1, 0xFE, 0x4E, 0x62, 0xAE, 0x27, 0x4E, 0x3F, 0xC6, 0x38, + 0x05, 0x67, 0x1C, 0x1D, 0xEC, 0x32, 0xCE, 0x00, 0x81, 0xEA, 0x75, 0xDB, + 0x2B, 0x99, 0x49, 0x4A, 0x69, 0xD7, 0x76, 0xBF, 0xFA, 0xEC, 0xAB, 0x37, + 0x6F, 0xCE, 0x2E, 0xAF, 0x6F, 0x9C, 0x73, 0x82, 0x8B, 0xA7, 0xCF, 0x5F, + 0xBF, 0x7C, 0x75, 0xE2, 0x63, 0x7C, 0x70, 0x6F, 0x8F, 0x11, 0xEA, 0x9C, + 0xAF, 0xBB, 0x3E, 0xCF, 0xB2, 0xB3, 0xF3, 0x4B, 0xB3, 0xB1, 0x0C, 0x73, + 0x18, 0x61, 0x6D, 0x4C, 0xBA, 0x24, 0xB4, 0xB2, 0x71, 0xF3, 0x1E, 0x6D, + 0x7C, 0x2F, 0x9C, 0x73, 0x00, 0x88, 0x0B, 0x1E, 0x82, 0x17, 0x5C, 0x58, + 0xE7, 0x1F, 0xDE, 0x3F, 0xCC, 0x32, 0x79, 0x35, 0x9B, 0xF7, 0xBD, 0x22, + 0x84, 0x22, 0x8C, 0x13, 0x33, 0x03, 0x20, 0xDE, 0xA2, 0xAB, 0xE9, 0x15, + 0x56, 0xCA, 0x84, 0x08, 0x9D, 0x52, 0x99, 0x10, 0x08, 0xA1, 0x3C, 0x93, + 0x4A, 0x1B, 0xA5, 0x4D, 0x91, 0x67, 0x18, 0xC1, 0x72, 0xB9, 0xBE, 0x77, + 0xB8, 0x3B, 0xA8, 0x8A, 0x94, 0x78, 0x82, 0xD3, 0x85, 0x89, 0x10, 0x4A, + 0x19, 0x17, 0x80, 0x00, 0x22, 0x21, 0xA4, 0xEB, 0xFB, 0xCF, 0x7E, 0xF3, + 0x4C, 0x19, 0x97, 0xB4, 0xC0, 0xCE, 0x79, 0xCE, 0x79, 0x08, 0x41, 0x70, + 0x36, 0xAC, 0x4A, 0xE7, 0x5D, 0x62, 0x63, 0x45, 0x04, 0x84, 0x20, 0xC1, + 0x99, 0xF7, 0x1E, 0x23, 0x74, 0xB0, 0x3B, 0x1D, 0x56, 0x39, 0x46, 0x80, + 0x31, 0x72, 0x3E, 0x32, 0x4A, 0x10, 0xE0, 0xAE, 0x57, 0x18, 0xE3, 0x4E, + 0x19, 0x6D, 0x7C, 0xDB, 0xAB, 0xE4, 0x20, 0xB6, 0x58, 0xD7, 0x9C, 0xD3, + 0x54, 0xA9, 0x01, 0x01, 0x63, 0x4C, 0x30, 0x9E, 0xA2, 0x6A, 0xD2, 0x7E, + 0x0C, 0x21, 0x94, 0x8C, 0xF3, 0x43, 0xF0, 0xF3, 0x55, 0xA3, 0x8D, 0xE3, + 0x9C, 0x02, 0xA0, 0x18, 0x21, 0x19, 0xFE, 0x58, 0xE7, 0x28, 0x65, 0x4A, + 0xEB, 0x44, 0xB3, 0x48, 0xF6, 0xC5, 0xB0, 0x31, 0x5F, 0x25, 0x5D, 0xAF, + 0x28, 0x25, 0x89, 0xD1, 0x56, 0x96, 0xC5, 0xB0, 0x2A, 0x5F, 0xBC, 0x3E, + 0x39, 0x3D, 0x3B, 0xA7, 0x84, 0x68, 0xEB, 0xB2, 0x2C, 0xAB, 0xD7, 0xCD, + 0x62, 0x55, 0x03, 0x44, 0x63, 0xAD, 0x71, 0x9E, 0x31, 0x26, 0x38, 0xCB, + 0x24, 0xEF, 0x94, 0xFE, 0xC5, 0xAF, 0xBE, 0x22, 0x04, 0x8F, 0x86, 0x55, + 0x55, 0xE5, 0x00, 0xF1, 0xFE, 0xBD, 0xFD, 0x61, 0x55, 0x36, 0x6D, 0xC7, + 0x18, 0x77, 0xDE, 0xA7, 0x0B, 0x20, 0x93, 0x62, 0x77, 0x67, 0xB4, 0x5A, + 0xD7, 0xF7, 0x0E, 0x76, 0xDF, 0x1C, 0xBF, 0x75, 0x2E, 0x08, 0xC1, 0x9C, + 0x73, 0xCE, 0x39, 0x84, 0x31, 0xE7, 0x4C, 0x4A, 0xC1, 0xE8, 0x46, 0x9E, + 0x91, 0x76, 0xC7, 0x7D, 0xDF, 0x03, 0x82, 0x22, 0x97, 0x89, 0x00, 0x98, + 0x42, 0x18, 0x12, 0x4B, 0x2E, 0x89, 0x3D, 0x39, 0xA5, 0x75, 0xB3, 0x8E, + 0x10, 0x8B, 0x4C, 0x52, 0x42, 0x26, 0xC3, 0x8A, 0x51, 0x42, 0xFE, 0xF2, + 0x67, 0x3F, 0x8B, 0x77, 0xEA, 0xD7, 0x96, 0xDC, 0x90, 0x40, 0x70, 0x8A, + 0x08, 0x86, 0x18, 0x9D, 0x75, 0xDE, 0x79, 0x9B, 0x6C, 0x95, 0x10, 0x20, + 0x8C, 0xA5, 0xCC, 0x28, 0xE3, 0x70, 0x67, 0xC6, 0x81, 0x7F, 0xB8, 0x9C, + 0xDD, 0xED, 0x32, 0xEE, 0x16, 0x8E, 0xBB, 0x15, 0xF0, 0x2E, 0xE8, 0x86, + 0xBE, 0xFD, 0x6D, 0x9B, 0xFF, 0x92, 0xED, 0xB0, 0x19, 0x37, 0x3E, 0x17, + 0xE9, 0x48, 0x24, 0x34, 0x39, 0xA3, 0x6D, 0xBC, 0x9F, 0x30, 0xA6, 0x18, + 0x6D, 0xB9, 0x14, 0x77, 0x60, 0xBE, 0x5B, 0xEF, 0xD9, 0xDB, 0x5E, 0x2F, + 0xDE, 0xF1, 0xE1, 0xB8, 0xDB, 0xA0, 0xBD, 0xFB, 0x11, 0x10, 0x0E, 0xCE, + 0x34, 0xCB, 0x45, 0xE2, 0x2B, 0x67, 0x92, 0x27, 0xE7, 0xA2, 0xB2, 0xCC, + 0x9D, 0x8F, 0x22, 0xCB, 0x3B, 0x1B, 0x5F, 0x9F, 0x5C, 0xAD, 0x9B, 0xAE, + 0xEF, 0xD5, 0xEE, 0xEE, 0xCE, 0x68, 0x50, 0x3E, 0x3C, 0xDA, 0x1D, 0x0F, + 0x2B, 0x4A, 0xF1, 0xA0, 0x2A, 0x00, 0x60, 0x30, 0x28, 0xDF, 0x7F, 0x74, + 0xAF, 0xC8, 0x33, 0x8C, 0x49, 0xE2, 0xAC, 0xAD, 0x96, 0xF5, 0xF9, 0xC5, + 0xAC, 0xA9, 0x1B, 0x6B, 0x2D, 0x13, 0x1C, 0x10, 0x5E, 0x2C, 0x97, 0xBA, + 0x6F, 0x1F, 0x3D, 0x38, 0xA8, 0x86, 0x83, 0xBB, 0x2F, 0xC0, 0xDD, 0x59, + 0xF2, 0xB6, 0x17, 0x4B, 0xDA, 0xE6, 0x64, 0x88, 0x78, 0x79, 0xBD, 0xF2, + 0x21, 0xCE, 0x97, 0x4D, 0xDB, 0xF6, 0x79, 0x2E, 0x95, 0xF1, 0x21, 0x24, + 0xB0, 0x19, 0xA5, 0x50, 0x5B, 0xC1, 0xF9, 0x68, 0x38, 0x98, 0x4C, 0x46, + 0x52, 0xB0, 0xF1, 0x70, 0x90, 0xA6, 0x95, 0x3C, 0xCF, 0xAC, 0xF5, 0x29, + 0x8E, 0xB0, 0xEB, 0x7A, 0x4A, 0x49, 0x5E, 0xE4, 0xBB, 0x3B, 0xC3, 0x94, + 0x37, 0xE1, 0x37, 0x37, 0x7C, 0xCC, 0x33, 0xC1, 0x19, 0x89, 0x00, 0x3E, + 0x80, 0x73, 0xCE, 0x18, 0x67, 0x8C, 0x4D, 0xF2, 0x32, 0x4A, 0xC8, 0xC1, + 0xFE, 0x74, 0x6F, 0x2F, 0x8D, 0xC9, 0x31, 0x93, 0xA2, 0x6D, 0x3B, 0x8C, + 0xC0, 0x58, 0xE3, 0xFD, 0xE6, 0x38, 0x4C, 0x2C, 0x4D, 0xCE, 0xB9, 0xCC, + 0x78, 0xF0, 0x1E, 0x10, 0x72, 0x3E, 0x9C, 0x5F, 0xCC, 0xDE, 0x5E, 0x5C, + 0xE7, 0x59, 0x86, 0x30, 0x9E, 0x2F, 0x16, 0x6F, 0x8E, 0xCF, 0xE6, 0xF3, + 0x55, 0x88, 0xE1, 0xE2, 0xE2, 0xEA, 0xFC, 0xFC, 0x3A, 0xD1, 0x53, 0x8C, + 0x75, 0x97, 0x57, 0x37, 0x21, 0xC2, 0x7A, 0x5D, 0x63, 0x8C, 0x92, 0x28, + 0x95, 0x10, 0x6A, 0x8C, 0x51, 0x4A, 0xA5, 0x25, 0xAF, 0xD2, 0x46, 0xF5, + 0x3A, 0xDD, 0xC3, 0xE9, 0xB5, 0x4A, 0x6F, 0xB7, 0x75, 0x76, 0xBA, 0x33, + 0x7E, 0x7B, 0x7E, 0x7D, 0x76, 0x71, 0x25, 0x85, 0x20, 0x98, 0x84, 0x18, + 0xB3, 0x2C, 0xA3, 0x94, 0xA4, 0xFD, 0x63, 0x96, 0x89, 0x22, 0xCF, 0x19, + 0xA3, 0x4A, 0x29, 0x6B, 0x5D, 0xA2, 0x3B, 0x50, 0x46, 0x9D, 0xF3, 0xDB, + 0x20, 0x0C, 0xD4, 0x29, 0x55, 0x16, 0x39, 0x21, 0xB8, 0xEB, 0xFA, 0xF5, + 0xBA, 0x7E, 0xFC, 0xE8, 0x41, 0x22, 0x25, 0xA4, 0xCF, 0x6F, 0xAE, 0x97, + 0x88, 0x92, 0x6E, 0x89, 0x53, 0x7A, 0x75, 0x3D, 0xFF, 0xEC, 0xCB, 0xE7, + 0x82, 0x73, 0x00, 0x40, 0x98, 0x60, 0x8C, 0xF3, 0x5C, 0x02, 0x20, 0x8A, + 0x11, 0xA5, 0x04, 0x23, 0xA4, 0x94, 0x02, 0x04, 0x80, 0xB1, 0x60, 0x8C, + 0x11, 0x1C, 0x22, 0x38, 0xEF, 0x29, 0xC1, 0x04, 0xE3, 0x5E, 0xA9, 0x22, + 0x97, 0x75, 0xDB, 0xED, 0xEE, 0x0C, 0x31, 0x46, 0x4A, 0x9B, 0x18, 0x40, + 0x69, 0x0B, 0x08, 0x22, 0x40, 0x0A, 0x94, 0x5A, 0xAE, 0x5B, 0xEB, 0x7D, + 0x59, 0xE4, 0x69, 0x28, 0x4E, 0x9B, 0x50, 0x4A, 0x09, 0x22, 0x98, 0x52, + 0xEA, 0xBC, 0xB7, 0xCE, 0x59, 0x1F, 0x20, 0x42, 0xDD, 0x74, 0x6D, 0xAF, + 0x63, 0x8C, 0x99, 0x94, 0x6D, 0xAB, 0x08, 0x21, 0x29, 0xF2, 0x02, 0x23, + 0xEC, 0x83, 0x4F, 0x37, 0x0B, 0xDE, 0x44, 0x9E, 0xA1, 0xE0, 0x3D, 0x26, + 0x24, 0xC6, 0xD0, 0xF5, 0x4A, 0x4A, 0x19, 0x7C, 0x70, 0xDE, 0x37, 0x6D, + 0xD7, 0x34, 0xDD, 0xD9, 0xC5, 0xB5, 0xB3, 0x4E, 0x6B, 0x9B, 0x72, 0x91, + 0x11, 0xC6, 0xC9, 0x5F, 0xFE, 0xF1, 0xA3, 0x87, 0x1F, 0x7D, 0xF8, 0xC1, + 0xFD, 0x7B, 0xBB, 0x07, 0xBB, 0x93, 0x75, 0xDD, 0x7E, 0xF6, 0xC5, 0xB3, + 0xB3, 0xF3, 0x1B, 0x82, 0xE1, 0xCF, 0xFE, 0xC9, 0x4F, 0x76, 0x27, 0x43, + 0x29, 0xA5, 0xD6, 0x26, 0xCF, 0xB3, 0xB6, 0xEB, 0xAC, 0xF3, 0x07, 0x7B, + 0xD3, 0xD1, 0xB0, 0xCC, 0x33, 0xB1, 0x3F, 0x9D, 0x1C, 0xEC, 0xEF, 0x54, + 0x65, 0x71, 0x71, 0x35, 0x3B, 0x7B, 0x7B, 0x35, 0x9D, 0x0C, 0x43, 0x08, + 0xC6, 0x58, 0x8C, 0xB1, 0x31, 0x96, 0x73, 0xB6, 0x33, 0x1A, 0x16, 0x99, + 0xA4, 0x94, 0x24, 0x1A, 0x7C, 0xDB, 0x76, 0x08, 0xC1, 0x70, 0x50, 0x4E, + 0xC7, 0xC3, 0x9D, 0xF1, 0x30, 0xB1, 0xA0, 0xDB, 0xB6, 0x83, 0x18, 0x31, + 0x02, 0x63, 0x8C, 0x73, 0x8E, 0x50, 0xF2, 0xFD, 0xC7, 0x8F, 0x86, 0x83, + 0x32, 0x93, 0xBC, 0xC8, 0xE4, 0x70, 0x50, 0x70, 0xC6, 0xE8, 0xD6, 0x01, + 0x3F, 0x6E, 0x5D, 0xBF, 0x02, 0x4E, 0x31, 0x96, 0x08, 0xC5, 0xE0, 0x82, + 0x73, 0xC1, 0xDB, 0x18, 0x37, 0xD9, 0xEE, 0xCE, 0x78, 0xAD, 0x6D, 0x55, + 0xE5, 0xE9, 0x37, 0xB4, 0xC6, 0x38, 0xEF, 0xF0, 0xD6, 0xEF, 0x90, 0xDC, + 0x9A, 0x7B, 0xFD, 0xBE, 0x25, 0xE0, 0x77, 0xC0, 0xB8, 0x54, 0x92, 0xFE, + 0xA1, 0xD6, 0xEC, 0x5B, 0x5F, 0x76, 0x7B, 0x67, 0x6F, 0x6A, 0xDF, 0xB7, + 0xCA, 0x0D, 0xC1, 0x14, 0x10, 0x22, 0x94, 0x6E, 0x73, 0x53, 0xEE, 0x3E, + 0x35, 0xA1, 0x18, 0x00, 0x90, 0x4F, 0xAE, 0xC3, 0x18, 0x01, 0x40, 0x72, + 0x8E, 0xBC, 0xE5, 0xD6, 0xC2, 0x3B, 0x62, 0x5A, 0x8A, 0x01, 0xC6, 0x9B, + 0xA9, 0x01, 0x13, 0x82, 0x31, 0xC4, 0x98, 0x71, 0xE6, 0x43, 0xA4, 0x94, + 0x62, 0x4C, 0xB2, 0x2C, 0x33, 0xC6, 0xFA, 0x00, 0x65, 0x59, 0x1A, 0x60, + 0xD7, 0xB3, 0x15, 0x65, 0xB4, 0xC8, 0xE5, 0xDE, 0xEE, 0xCE, 0x64, 0x5C, + 0x0D, 0x2A, 0x39, 0x28, 0xB3, 0x94, 0x68, 0x67, 0x8C, 0x13, 0x42, 0x16, + 0x65, 0xC1, 0x18, 0x4D, 0x9C, 0x4C, 0xA3, 0x8D, 0xB1, 0x66, 0xBE, 0x58, + 0x7B, 0xEF, 0x39, 0x17, 0x3E, 0xC4, 0xA2, 0x28, 0xCE, 0xCE, 0x2F, 0x9C, + 0xF3, 0xFB, 0x07, 0xFB, 0x59, 0x91, 0xA3, 0x3B, 0x65, 0xF7, 0xEE, 0x9F, + 0xA9, 0x27, 0x8D, 0xC1, 0x6B, 0x63, 0xB5, 0xD2, 0x4A, 0x9B, 0xF3, 0xCB, + 0x9B, 0xF9, 0xB2, 0x73, 0x21, 0x6A, 0x6D, 0x97, 0xAB, 0x1A, 0x10, 0x6A, + 0x3B, 0xD3, 0x2B, 0x8D, 0x08, 0x1E, 0x0D, 0x87, 0x08, 0x41, 0xD7, 0x6B, + 0x67, 0xB9, 0x90, 0xF2, 0xFA, 0x66, 0x01, 0x10, 0x87, 0x83, 0x41, 0x08, + 0x71, 0x3E, 0x5F, 0x29, 0xAD, 0x23, 0x20, 0x1F, 0x62, 0xD7, 0xF5, 0x55, + 0x59, 0x88, 0x2C, 0xD3, 0xC6, 0x45, 0x40, 0x48, 0x50, 0x99, 0x49, 0x4E, + 0x49, 0x48, 0x51, 0xDB, 0x08, 0x49, 0x21, 0x38, 0xE7, 0x01, 0xD0, 0x6A, + 0xDD, 0xD5, 0xDA, 0x3C, 0x7F, 0xFE, 0xFA, 0xE8, 0xE8, 0x30, 0x86, 0xE8, + 0xBD, 0xB7, 0x08, 0xFA, 0x5E, 0x55, 0x55, 0x3E, 0xA8, 0xAA, 0xBE, 0xEF, + 0x01, 0x90, 0xCC, 0xB3, 0xF5, 0x72, 0x15, 0x9C, 0x6D, 0xD7, 0x75, 0x55, + 0xE6, 0x7B, 0xD3, 0x51, 0xDF, 0xAB, 0xCB, 0xAB, 0x39, 0xA3, 0x6C, 0xD5, + 0xB4, 0xC9, 0xAB, 0x52, 0x69, 0xA3, 0x8D, 0x1D, 0x0C, 0x4A, 0xA3, 0x4D, + 0x49, 0x98, 0x77, 0x3C, 0x78, 0x8D, 0x29, 0x61, 0x94, 0x08, 0x46, 0xBF, + 0x7E, 0xFA, 0x0A, 0x61, 0xFC, 0xD3, 0x1F, 0x7F, 0x5C, 0x14, 0xD9, 0x47, + 0x1F, 0x3E, 0x2A, 0xCA, 0x7C, 0xB5, 0xAA, 0x57, 0xAB, 0x55, 0x59, 0x16, + 0xCB, 0x65, 0xF2, 0xF9, 0xF1, 0x99, 0xE0, 0x80, 0xB1, 0x73, 0x8E, 0x52, + 0xEA, 0x63, 0x72, 0x61, 0x09, 0x8C, 0x26, 0x07, 0x37, 0x4F, 0x30, 0x31, + 0xD6, 0xB5, 0x5D, 0x0F, 0x08, 0x92, 0xDC, 0x67, 0x30, 0xAC, 0x7A, 0xA5, + 0xA7, 0x93, 0x61, 0x5D, 0xD7, 0x5A, 0x6B, 0x84, 0x90, 0x0F, 0x81, 0x32, + 0x42, 0x09, 0x59, 0xA6, 0xFC, 0x2D, 0x42, 0x8C, 0xB5, 0x29, 0x07, 0xC4, + 0xF9, 0xE0, 0x43, 0xF0, 0xDE, 0xA3, 0x18, 0x9B, 0xA6, 0xF3, 0x3E, 0x30, + 0x4A, 0xDF, 0x9C, 0x5E, 0xFE, 0xE2, 0xD7, 0x5F, 0xFE, 0xB3, 0x3F, 0xF9, + 0x71, 0xDF, 0xEB, 0xBB, 0xE7, 0xDF, 0x16, 0x86, 0x41, 0x84, 0xE2, 0xD9, + 0x7C, 0x95, 0x4C, 0xD0, 0x12, 0x7C, 0x3C, 0x1A, 0x0E, 0x22, 0x02, 0xC6, + 0x59, 0xF0, 0xCE, 0x59, 0x9B, 0xB0, 0x73, 0x82, 0x01, 0x6D, 0x2F, 0xBF, + 0x24, 0xEA, 0x3C, 0xBF, 0x9A, 0x5F, 0xCD, 0x16, 0x65, 0x99, 0x0F, 0xAB, + 0x72, 0xB5, 0xEE, 0x31, 0x26, 0x83, 0x32, 0x2B, 0x32, 0x39, 0x5F, 0x36, + 0x21, 0x04, 0xE7, 0x62, 0x8C, 0x71, 0x19, 0x5A, 0xE7, 0xD7, 0x4A, 0x1B, + 0x4C, 0x70, 0x04, 0x94, 0x4B, 0x4E, 0x08, 0x49, 0x46, 0xA9, 0x08, 0x23, + 0xDD, 0x1B, 0x4F, 0x43, 0x32, 0xEF, 0x88, 0x21, 0xBA, 0xE8, 0xBA, 0x5E, + 0x13, 0x82, 0x69, 0x20, 0x69, 0xBA, 0x44, 0x18, 0x9C, 0xF5, 0x08, 0xA1, + 0xB0, 0xC9, 0x24, 0x43, 0x31, 0xC6, 0x10, 0x03, 0xA3, 0x22, 0x42, 0xF4, + 0x3E, 0x24, 0x51, 0x5B, 0x99, 0xE7, 0x99, 0x14, 0xD6, 0x58, 0x8C, 0xB1, + 0x14, 0xE2, 0xFC, 0x62, 0xB6, 0x5C, 0xAD, 0x31, 0xC6, 0x3B, 0x93, 0xC9, + 0x8F, 0x7F, 0xF4, 0x71, 0x8C, 0xB1, 0x2A, 0x0B, 0x21, 0xD8, 0xAB, 0xD7, + 0xA7, 0xFF, 0xF6, 0x6F, 0x7F, 0xB1, 0xAE, 0xEB, 0xEF, 0x3D, 0x79, 0x1F, + 0x62, 0x78, 0x7B, 0x71, 0xBD, 0x5A, 0x37, 0xD7, 0x37, 0x8B, 0xB6, 0xEB, + 0x8E, 0xDF, 0xCE, 0xBA, 0x5E, 0x7D, 0xFA, 0xEB, 0x2F, 0xDF, 0x7B, 0x70, + 0xF8, 0xD1, 0x87, 0x1F, 0x08, 0x29, 0xD6, 0xEB, 0xB7, 0x99, 0xE4, 0x65, + 0x91, 0xBD, 0xF7, 0xE0, 0xE0, 0x93, 0x0F, 0xDF, 0xBF, 0xBC, 0x9E, 0xFF, + 0xFA, 0xB7, 0x4F, 0xDB, 0xAE, 0xB7, 0xCE, 0x85, 0x10, 0xA5, 0x90, 0x89, + 0x3B, 0xD2, 0x75, 0xEA, 0x6A, 0xB6, 0xD8, 0x19, 0x0D, 0xF2, 0x14, 0x37, + 0x91, 0x89, 0xB2, 0xC8, 0x29, 0xC1, 0x49, 0x00, 0xC0, 0x39, 0x4B, 0xB7, + 0x92, 0xD6, 0x9A, 0x12, 0xA4, 0xB5, 0x49, 0x22, 0x50, 0x40, 0xF0, 0xA3, + 0x4F, 0x3E, 0xFC, 0xDE, 0xE3, 0x47, 0x57, 0xD7, 0xD7, 0x28, 0x42, 0x9E, + 0xCB, 0x41, 0x95, 0x8B, 0xB4, 0xE8, 0x0D, 0x21, 0x06, 0xEF, 0xA2, 0xF7, + 0x1B, 0x90, 0x9B, 0xB0, 0xE0, 0x21, 0x46, 0xEF, 0x8C, 0x31, 0x1B, 0x68, + 0x0C, 0x45, 0x88, 0x31, 0x44, 0xEF, 0x3C, 0x25, 0x44, 0x70, 0x81, 0xF1, + 0x06, 0xCD, 0xB1, 0xC6, 0x01, 0x80, 0x0F, 0x1E, 0x01, 0x12, 0x9C, 0x23, + 0x8C, 0x30, 0x20, 0xCA, 0x58, 0x5A, 0x38, 0xC2, 0xB7, 0xC7, 0xB7, 0xEF, + 0xD4, 0x2A, 0x00, 0xF8, 0x5D, 0x4F, 0x81, 0x2D, 0xDC, 0x9F, 0xBA, 0xBC, + 0xC4, 0xDE, 0x89, 0x21, 0xFA, 0x18, 0x42, 0x0C, 0x11, 0x6D, 0x83, 0x97, + 0x30, 0x4E, 0x3E, 0x99, 0x18, 0x21, 0x9C, 0x8C, 0xF7, 0xB7, 0x42, 0xDE, + 0x08, 0xDB, 0x3C, 0x11, 0x00, 0x88, 0x90, 0x3C, 0xCE, 0x29, 0x49, 0x76, + 0x8C, 0x11, 0x41, 0x0A, 0xBD, 0xC7, 0x9B, 0x79, 0x0D, 0x6D, 0xD2, 0xBC, + 0x13, 0xCA, 0x8E, 0x01, 0x61, 0x88, 0x31, 0x35, 0xF2, 0x80, 0xC0, 0x6A, + 0x85, 0x10, 0x62, 0x9C, 0x0A, 0xC1, 0x85, 0x10, 0x45, 0x55, 0x31, 0x63, + 0x97, 0x8D, 0x51, 0x3E, 0x1A, 0xEB, 0x29, 0x21, 0x45, 0x9E, 0x97, 0x45, + 0xCE, 0x28, 0xD9, 0x19, 0x0F, 0xA5, 0xE4, 0x69, 0xF5, 0x9E, 0x36, 0x4A, + 0x08, 0x21, 0x88, 0x60, 0xB4, 0x75, 0xD6, 0xF6, 0x21, 0x74, 0x9D, 0x32, + 0xDA, 0x60, 0x8C, 0xAB, 0x41, 0x85, 0x31, 0xD1, 0xC6, 0x36, 0x75, 0xC3, + 0x29, 0xDD, 0x9D, 0x8C, 0x3E, 0x78, 0x74, 0xAF, 0x28, 0x8B, 0x77, 0x95, + 0xEB, 0xDD, 0xBD, 0x92, 0x74, 0xC9, 0xC1, 0x18, 0x7D, 0x35, 0x5B, 0xF4, + 0xCA, 0x00, 0x42, 0x5D, 0x6F, 0x2E, 0x66, 0xEB, 0x75, 0xDD, 0x69, 0xE3, + 0x9C, 0x0F, 0x84, 0xD0, 0xE9, 0xEE, 0x64, 0x3E, 0x5F, 0xCD, 0x6E, 0x16, + 0x8C, 0x71, 0x04, 0xF8, 0xDE, 0xBD, 0x7D, 0x84, 0xC9, 0xE9, 0xD9, 0xC5, + 0xBA, 0xED, 0xFA, 0xBE, 0x37, 0xDA, 0x6A, 0x65, 0xBA, 0xAE, 0xEF, 0xBA, + 0xF6, 0xDE, 0xBD, 0xC3, 0x17, 0x6F, 0x4E, 0x43, 0x88, 0xDE, 0x7B, 0x4E, + 0xE9, 0x64, 0x3C, 0xC0, 0x08, 0x4D, 0xC6, 0x43, 0x3A, 0x9D, 0x5C, 0x5D, + 0x2F, 0x01, 0x22, 0xA5, 0x64, 0x32, 0xAE, 0xAC, 0x75, 0xEB, 0x65, 0xED, + 0xBC, 0x57, 0xC6, 0x8D, 0x47, 0x83, 0xCB, 0xEB, 0x79, 0x88, 0x31, 0x2F, + 0x72, 0x4A, 0xE9, 0xCD, 0xCD, 0x02, 0x10, 0xCC, 0x30, 0x16, 0x82, 0x3F, + 0x7A, 0xEF, 0x68, 0x34, 0x1C, 0x28, 0xAD, 0xC7, 0xC3, 0x41, 0x55, 0xE4, + 0xD7, 0x97, 0xD7, 0xAB, 0xC5, 0x6A, 0x32, 0x2C, 0xA4, 0xE4, 0x11, 0x13, + 0x21, 0xF8, 0xAB, 0xD3, 0x8B, 0xE3, 0xD3, 0xAB, 0xA3, 0xC3, 0xBD, 0x44, + 0x4C, 0x89, 0x08, 0x4D, 0x26, 0xE3, 0xF5, 0xBA, 0xD6, 0x7D, 0xC7, 0x18, + 0x3B, 0xD8, 0x2B, 0x01, 0x00, 0x62, 0xE8, 0xBB, 0x7E, 0x77, 0x32, 0x34, + 0xBD, 0xFA, 0xEC, 0xF3, 0x2F, 0x0F, 0x0F, 0xF6, 0x22, 0xC2, 0x5C, 0x8A, + 0xF7, 0x1E, 0x1E, 0xFD, 0xFC, 0x17, 0x33, 0x29, 0xBC, 0xE0, 0xCC, 0x58, + 0x97, 0xAE, 0x08, 0xB2, 0x65, 0x62, 0xCB, 0x4C, 0x58, 0xEB, 0xAC, 0x35, + 0x04, 0x23, 0x44, 0x48, 0x70, 0xB6, 0x2C, 0xB2, 0xC9, 0x78, 0x50, 0x37, + 0x6D, 0x9E, 0xC9, 0x36, 0x86, 0xB6, 0xEB, 0x10, 0x86, 0x7F, 0xF4, 0xE3, + 0x3F, 0xC8, 0xA5, 0xF8, 0xDB, 0xBF, 0xFF, 0xD5, 0xC1, 0xDE, 0x74, 0x36, + 0x5F, 0xF6, 0x5D, 0x1F, 0x43, 0x18, 0x54, 0x85, 0x94, 0x32, 0x49, 0x32, + 0x63, 0x0C, 0xD6, 0xDA, 0x24, 0xC5, 0x4D, 0x61, 0xDD, 0xC6, 0xBA, 0x1C, + 0xA0, 0x28, 0x64, 0xDB, 0x29, 0x42, 0xE8, 0xD7, 0xCF, 0x8E, 0x7F, 0xF0, + 0xE4, 0xE1, 0xC1, 0xFE, 0x4E, 0xAF, 0x0C, 0xC1, 0x28, 0xC6, 0x98, 0x0E, + 0xCB, 0xB0, 0xF1, 0xC2, 0x86, 0xF9, 0x72, 0x05, 0x08, 0x73, 0xCE, 0xDB, + 0xAE, 0x8B, 0x00, 0x6D, 0xD7, 0x13, 0x8C, 0x11, 0xC6, 0x10, 0x83, 0x52, + 0xE9, 0xFE, 0x71, 0x9C, 0xC9, 0xE0, 0x43, 0xC2, 0xBF, 0x63, 0x88, 0xCE, + 0xA7, 0x68, 0xFA, 0xB0, 0x6E, 0x3A, 0x8C, 0x49, 0x88, 0xD1, 0xFB, 0x90, + 0xB4, 0x19, 0x98, 0x10, 0x8E, 0x90, 0x71, 0xCE, 0x1B, 0xAB, 0xB5, 0x49, + 0x2E, 0xDE, 0x9C, 0xB0, 0x9B, 0xF9, 0x2A, 0x8E, 0x07, 0xB9, 0xE4, 0x8C, + 0x91, 0x10, 0x63, 0x70, 0xC1, 0x24, 0xE8, 0x00, 0xB3, 0x00, 0x21, 0xC4, + 0xD8, 0x34, 0xFD, 0xBA, 0x69, 0x19, 0xE3, 0x8C, 0x12, 0xEB, 0x3D, 0xE3, + 0x29, 0x3E, 0x12, 0xE1, 0x80, 0x22, 0xA0, 0x2D, 0xFD, 0x08, 0x18, 0xA3, + 0x04, 0xA3, 0xA6, 0xED, 0x19, 0x63, 0x92, 0xF3, 0x10, 0x43, 0x55, 0x16, + 0x5A, 0x99, 0x08, 0x51, 0x72, 0xC6, 0x19, 0x9D, 0xAF, 0x56, 0x5A, 0x9B, + 0x22, 0x93, 0x9C, 0xD3, 0xCF, 0x3E, 0xFF, 0xD2, 0x3A, 0xF7, 0xE8, 0xE1, + 0xFD, 0xBD, 0xBD, 0x9D, 0xF1, 0x68, 0x60, 0x8C, 0x99, 0x2F, 0x96, 0x37, + 0xF3, 0xE5, 0xC3, 0xA3, 0xBD, 0x47, 0x0F, 0x0E, 0xFF, 0xF7, 0xFF, 0xF3, + 0xDF, 0x18, 0xE3, 0xFA, 0x5E, 0x7D, 0xFE, 0xC5, 0xB3, 0x47, 0x0F, 0xEF, + 0xBD, 0x7E, 0x73, 0xFA, 0xE0, 0xC1, 0x21, 0x06, 0xF8, 0xDE, 0x07, 0x0F, + 0x87, 0x83, 0x8A, 0x53, 0xEC, 0x9C, 0xE7, 0x8C, 0x9E, 0x9C, 0x5D, 0x9C, + 0xBC, 0xBD, 0x3E, 0x7D, 0x7B, 0x95, 0x66, 0x05, 0x6D, 0x6C, 0x08, 0x8A, + 0x10, 0x9C, 0x49, 0x99, 0x42, 0x66, 0xA4, 0x14, 0x94, 0x92, 0xBE, 0x8F, + 0x52, 0x30, 0x8C, 0x09, 0x63, 0xAC, 0x2A, 0x0B, 0x9D, 0xB0, 0x30, 0xEF, + 0x8B, 0x5C, 0x66, 0x99, 0x18, 0x56, 0x45, 0xAF, 0x4D, 0x99, 0xE7, 0xCE, + 0x59, 0x4A, 0x69, 0x55, 0x64, 0xE7, 0x17, 0x97, 0xA9, 0x17, 0x1B, 0x94, + 0x39, 0x20, 0xA0, 0x18, 0x91, 0xBF, 0xF8, 0x8B, 0x3F, 0x4F, 0xB0, 0x53, + 0x82, 0x30, 0x51, 0xBA, 0xC5, 0x13, 0x7B, 0x2B, 0x04, 0x1F, 0x12, 0xA7, + 0x3A, 0xC4, 0x10, 0x9C, 0x0F, 0xC9, 0xA7, 0x2C, 0x2B, 0x72, 0x2E, 0x44, + 0x82, 0x9C, 0x93, 0x63, 0x54, 0x4A, 0x7E, 0x86, 0x44, 0x2E, 0xC5, 0x89, + 0xF0, 0xF0, 0x0E, 0xA2, 0xFA, 0xFD, 0x85, 0xEC, 0x16, 0x05, 0xFB, 0x3D, + 0x78, 0x7F, 0x8C, 0x31, 0xDC, 0x42, 0xAC, 0x11, 0xA2, 0xF7, 0xCE, 0xB9, + 0xE0, 0x7D, 0x4C, 0xCB, 0x2C, 0x92, 0x12, 0x75, 0xF0, 0xA6, 0xDD, 0xDF, + 0x4C, 0x88, 0xDB, 0xDC, 0xB7, 0xB8, 0xD1, 0xC6, 0x25, 0x0D, 0x12, 0x6C, + 0xF6, 0x8F, 0x9B, 0xA3, 0x74, 0x43, 0xB5, 0xBC, 0xFD, 0xA6, 0xDB, 0x9F, + 0x25, 0xED, 0x40, 0x37, 0xAB, 0xF6, 0x8D, 0x7F, 0x1E, 0xD2, 0x4D, 0xDD, + 0x35, 0x35, 0xA5, 0x2C, 0xCB, 0x32, 0x4A, 0x31, 0xA1, 0x74, 0xB6, 0xEC, + 0x5B, 0xED, 0x8D, 0xF3, 0x4A, 0x9B, 0x18, 0xC1, 0x3A, 0x27, 0x39, 0x3F, + 0xD8, 0xDF, 0x29, 0x8A, 0x5C, 0x48, 0x81, 0x11, 0x4A, 0x66, 0x41, 0x31, + 0x46, 0xE7, 0xBC, 0x0F, 0x5E, 0x5B, 0x1B, 0x01, 0x8C, 0xB1, 0x3A, 0xF9, + 0xFF, 0x08, 0x56, 0x96, 0x39, 0xE7, 0xCC, 0x28, 0xDD, 0x6B, 0x35, 0x1A, + 0x94, 0x87, 0xFB, 0xE3, 0xC1, 0xA0, 0x44, 0x77, 0x4C, 0x41, 0x62, 0x22, + 0xC1, 0xF8, 0x80, 0x62, 0xB0, 0x46, 0x9D, 0x9E, 0x5D, 0x7D, 0xF6, 0xE5, + 0xCB, 0x17, 0xAF, 0xCF, 0x7D, 0x80, 0xA6, 0xD3, 0x6F, 0xDE, 0x5E, 0xF7, + 0xCA, 0x7A, 0x1F, 0xCB, 0xB2, 0xC8, 0xA4, 0x20, 0x84, 0x0C, 0x87, 0x03, + 0x63, 0xDD, 0x72, 0xDD, 0x58, 0xEB, 0x11, 0x26, 0x5D, 0xDF, 0x3B, 0x1F, + 0xDE, 0xBE, 0xBD, 0xCA, 0x32, 0xD1, 0xB7, 0xDD, 0xC5, 0xC5, 0xEC, 0xF4, + 0xEC, 0xBC, 0xC8, 0x05, 0xA7, 0x78, 0x3E, 0x5F, 0xDE, 0xDC, 0xAC, 0xCF, + 0x2F, 0xAE, 0x5E, 0xBF, 0x39, 0x59, 0x2E, 0x57, 0x14, 0x83, 0xEA, 0xFB, + 0xC5, 0x62, 0xD5, 0xB6, 0xDD, 0x7A, 0xBD, 0x5E, 0x2E, 0x57, 0x27, 0x27, + 0xE7, 0xAB, 0x75, 0xDB, 0x36, 0x9D, 0x56, 0x3A, 0x2B, 0x0A, 0xC6, 0xC4, + 0x7C, 0xDD, 0xD4, 0x75, 0xAB, 0x8C, 0x3B, 0x39, 0xBB, 0xF8, 0xC5, 0xA7, + 0x9F, 0xBF, 0x3E, 0x7E, 0xDB, 0x76, 0xE6, 0xF8, 0xF4, 0xA2, 0x6E, 0xD5, + 0x17, 0x5F, 0x3E, 0x2B, 0x72, 0x39, 0x1C, 0x56, 0x75, 0xDD, 0x70, 0xC6, + 0x26, 0x3B, 0xA3, 0xA3, 0xA3, 0x7D, 0xCE, 0xE8, 0x9B, 0xE3, 0xB7, 0x2E, + 0xC0, 0xEE, 0xEE, 0xAE, 0xF5, 0x81, 0x32, 0x36, 0x1C, 0x56, 0x08, 0xE1, + 0xA6, 0xEB, 0xD3, 0x80, 0x3F, 0x9B, 0x2D, 0x3A, 0x65, 0x86, 0x83, 0xC2, + 0x18, 0x5B, 0xE4, 0x19, 0x67, 0x84, 0x50, 0xB2, 0x33, 0x1E, 0x49, 0xC1, + 0x11, 0xC0, 0xC5, 0xC5, 0xAC, 0xAA, 0x4A, 0x21, 0xF8, 0xCD, 0x62, 0xE5, + 0xAC, 0x5D, 0xAE, 0xD6, 0x5B, 0x53, 0x72, 0x00, 0x14, 0x05, 0xE7, 0xC9, + 0xDC, 0x06, 0x21, 0x9C, 0xC2, 0x09, 0x37, 0x38, 0x1A, 0xC6, 0x00, 0x68, + 0x34, 0x1C, 0x24, 0xC3, 0x99, 0xBE, 0xD7, 0x21, 0xC6, 0xE9, 0x64, 0xBC, + 0xB7, 0x3B, 0xB9, 0xB8, 0x9C, 0x11, 0x4A, 0x9B, 0xA6, 0x09, 0x31, 0x24, + 0xB7, 0x19, 0x9C, 0x58, 0x63, 0x21, 0x14, 0x79, 0x46, 0x09, 0xE9, 0x94, + 0xD2, 0xC6, 0x0D, 0x87, 0x15, 0x41, 0xD8, 0x79, 0x6F, 0xAC, 0xCB, 0xA4, + 0x28, 0x8A, 0xBC, 0x6E, 0x3A, 0xC1, 0x58, 0xD7, 0x2B, 0xA5, 0xF5, 0x74, + 0x32, 0xCC, 0x33, 0x11, 0x63, 0xC4, 0x5B, 0x5E, 0x7F, 0xBA, 0x82, 0x30, + 0x42, 0x9F, 0x7E, 0xFE, 0x74, 0xBE, 0xAC, 0x11, 0x8A, 0x31, 0x44, 0x2E, + 0x78, 0x5A, 0x88, 0x27, 0xBF, 0x79, 0x46, 0x49, 0x62, 0xE4, 0x4B, 0xC9, + 0x93, 0x45, 0x9E, 0x60, 0x04, 0x22, 0xB8, 0xB0, 0xC9, 0x8A, 0x8E, 0x01, + 0x36, 0x22, 0x6D, 0x88, 0x21, 0x82, 0xD2, 0xB6, 0x69, 0xFB, 0xE4, 0xC0, + 0x0E, 0x00, 0xD6, 0x59, 0x8C, 0x49, 0xF0, 0xDE, 0x79, 0x8F, 0x11, 0x9E, + 0x4E, 0x86, 0x52, 0x70, 0x6B, 0xDD, 0x96, 0x42, 0x14, 0x43, 0x08, 0xDE, + 0x85, 0x10, 0x42, 0xAF, 0x8C, 0xD2, 0xD6, 0x58, 0xEF, 0xB6, 0x14, 0x5E, + 0xBB, 0x21, 0x91, 0x6D, 0x6E, 0x64, 0xEF, 0x1D, 0xA7, 0x2C, 0x21, 0xCE, + 0xC6, 0x5A, 0x00, 0x44, 0x08, 0x49, 0xAC, 0x7D, 0x80, 0x98, 0x9C, 0x2C, + 0x31, 0x02, 0xAD, 0x4D, 0xD3, 0x76, 0x94, 0xD2, 0x22, 0x17, 0x07, 0x07, + 0xFB, 0xD6, 0xB9, 0xAA, 0xCC, 0x23, 0x80, 0xCC, 0x44, 0x26, 0x05, 0x63, + 0xF4, 0x7A, 0xB6, 0x18, 0x0F, 0x87, 0x52, 0xB0, 0x7F, 0xFC, 0x93, 0x8F, + 0x57, 0x4D, 0xBF, 0x98, 0xAF, 0xDB, 0xB6, 0x7B, 0x73, 0x7A, 0x2E, 0x84, + 0xDC, 0x9D, 0xEE, 0x7C, 0xF8, 0xF8, 0x61, 0x26, 0x79, 0x02, 0x80, 0xFE, + 0xF6, 0xEF, 0x3F, 0xFF, 0xF2, 0x9B, 0xE7, 0x93, 0xD1, 0xE0, 0xB3, 0x2F, + 0x9E, 0x09, 0x21, 0xD6, 0x75, 0x27, 0x04, 0x13, 0x9C, 0x33, 0x4A, 0xC6, + 0xA3, 0x01, 0x63, 0xCC, 0x18, 0x93, 0x09, 0x3E, 0x1D, 0x0F, 0xF7, 0x76, + 0xC7, 0x45, 0x2E, 0xF2, 0x4C, 0x60, 0x8C, 0x11, 0x02, 0x1F, 0x42, 0x96, + 0xC9, 0x3C, 0x97, 0x21, 0x04, 0x82, 0xC9, 0x83, 0xFB, 0xFB, 0x0F, 0xEF, + 0xEF, 0x4F, 0x27, 0xA3, 0x87, 0xF7, 0x0F, 0xF7, 0xA6, 0xE3, 0x22, 0x93, + 0xE3, 0xD1, 0x20, 0x97, 0xDC, 0x1A, 0x27, 0x04, 0xCB, 0x33, 0x91, 0x67, + 0x22, 0xA4, 0xB4, 0x8D, 0x9F, 0xFD, 0xEC, 0x2F, 0x92, 0x5F, 0x02, 0x20, + 0x84, 0x30, 0xA1, 0x8C, 0x11, 0x4A, 0x31, 0xA1, 0x08, 0x23, 0x4C, 0x28, + 0x46, 0x38, 0x01, 0x68, 0x08, 0x01, 0xC1, 0x1B, 0xDB, 0x9C, 0x2C, 0xCB, + 0x31, 0x41, 0xE9, 0xE5, 0x10, 0x42, 0x48, 0x29, 0x38, 0xE7, 0xE9, 0x2D, + 0xA1, 0x8C, 0x11, 0xF6, 0x0E, 0x4F, 0xFD, 0xFF, 0xF8, 0xF8, 0xCE, 0xBC, + 0x99, 0x2E, 0x14, 0x78, 0xE7, 0xED, 0xBA, 0xAD, 0x2C, 0xDB, 0xF5, 0x70, + 0x22, 0x5B, 0xA5, 0x8F, 0x44, 0x84, 0xB7, 0xFA, 0x91, 0xF4, 0xD5, 0x1B, + 0xDE, 0x33, 0xA0, 0x98, 0xB8, 0x3E, 0x77, 0xDB, 0x9C, 0x77, 0x83, 0x2C, + 0x22, 0xDB, 0xDA, 0xBD, 0xD9, 0x8C, 0xA2, 0xCD, 0x73, 0x6E, 0x63, 0xA4, + 0x01, 0x61, 0x42, 0x55, 0xBD, 0xD0, 0xAA, 0x8F, 0x01, 0xB2, 0x5C, 0x58, + 0x1F, 0xDF, 0xBC, 0x5D, 0x36, 0xCA, 0xA7, 0x3D, 0x51, 0xAF, 0x94, 0xF7, + 0x31, 0x02, 0x12, 0x82, 0xE7, 0x99, 0x48, 0x32, 0xE0, 0x34, 0xBF, 0xC4, + 0x08, 0xD6, 0x79, 0x6D, 0x4C, 0xFA, 0xFF, 0x10, 0xA2, 0x77, 0x01, 0x21, + 0xC4, 0x18, 0xE5, 0x82, 0x73, 0x46, 0x19, 0x21, 0x21, 0x86, 0xAA, 0xCC, + 0xF7, 0xF7, 0x26, 0xD5, 0xB0, 0xA2, 0x84, 0xC4, 0xED, 0x00, 0x9D, 0xC8, + 0x32, 0x8C, 0x10, 0x6B, 0xF5, 0xC5, 0xE5, 0xEC, 0xD3, 0xCF, 0x5F, 0xFC, + 0xF2, 0xF3, 0x17, 0x57, 0x37, 0x2B, 0x4A, 0xD9, 0xF5, 0x62, 0x7D, 0x7E, + 0xB5, 0xC0, 0x08, 0x65, 0x59, 0xCE, 0x18, 0x4D, 0xAF, 0x9A, 0xB1, 0x6E, + 0xBE, 0xA8, 0x4F, 0xCF, 0x2E, 0x7E, 0xFE, 0xE9, 0xE7, 0x4A, 0x69, 0xCE, + 0x59, 0xDD, 0x76, 0x6F, 0x8E, 0xDF, 0x5E, 0x5E, 0xCD, 0x54, 0xD7, 0xFF, + 0xF6, 0x8B, 0x6F, 0x56, 0x75, 0x53, 0xE4, 0x39, 0x25, 0xF0, 0xE8, 0xFE, + 0xC1, 0x7C, 0xB9, 0x3E, 0x7B, 0x7B, 0x49, 0x08, 0x79, 0x70, 0xFF, 0xB0, + 0x2A, 0x8B, 0xE1, 0xA0, 0x8C, 0x11, 0x08, 0x25, 0xB9, 0x60, 0x28, 0xC6, + 0x24, 0xA4, 0x48, 0x5A, 0xC5, 0xD1, 0x68, 0xE8, 0x9C, 0xF7, 0x11, 0x96, + 0xEB, 0xF6, 0xF9, 0x8B, 0x63, 0x6B, 0x7D, 0x26, 0x84, 0x73, 0x61, 0xBA, + 0xBB, 0xB3, 0xB7, 0x3B, 0xB9, 0x59, 0xAC, 0xDE, 0xBC, 0x39, 0xB9, 0xBC, + 0xBC, 0x7E, 0xF5, 0xE6, 0xF4, 0xC9, 0x07, 0x0F, 0x19, 0x25, 0x5D, 0xD7, + 0x59, 0x63, 0x38, 0xA3, 0x32, 0x2F, 0x44, 0x96, 0x2B, 0xA5, 0xAF, 0x67, + 0x0B, 0x6B, 0xED, 0xA0, 0x2A, 0xEB, 0xA6, 0xBD, 0x9E, 0xCD, 0x93, 0xF1, + 0x61, 0xDB, 0xA9, 0xB6, 0xEB, 0x38, 0xA3, 0x9C, 0x33, 0x8C, 0x50, 0x8C, + 0xA1, 0x1A, 0x54, 0x55, 0x59, 0x3A, 0xE7, 0xBB, 0xAE, 0xC7, 0x84, 0x24, + 0x76, 0xF8, 0x87, 0x8F, 0xDF, 0x13, 0x52, 0x5C, 0xCF, 0x96, 0x4A, 0x29, + 0x8C, 0xB1, 0xDB, 0xA4, 0x07, 0x21, 0x84, 0x21, 0xA5, 0xC7, 0x27, 0x51, + 0x9A, 0x10, 0x2C, 0x2F, 0x72, 0xC1, 0x59, 0xDD, 0x34, 0x79, 0x96, 0x85, + 0x10, 0x84, 0xE0, 0xBB, 0x3B, 0xE3, 0xF9, 0x62, 0x95, 0x32, 0xC4, 0x9C, + 0x0B, 0xDF, 0x3C, 0x7B, 0xD9, 0x34, 0xAD, 0x94, 0x82, 0x52, 0x6A, 0xB4, + 0x49, 0x96, 0xAA, 0x29, 0x20, 0x46, 0x69, 0x4D, 0x29, 0xAD, 0xAA, 0xC2, + 0xFB, 0x60, 0x8D, 0xBD, 0xD5, 0x93, 0xA7, 0xE4, 0x51, 0x6D, 0xAC, 0xE0, + 0xCC, 0x58, 0x7B, 0x7A, 0x7E, 0xDD, 0x2B, 0xFD, 0x87, 0x1F, 0x3F, 0xB6, + 0xD6, 0xA5, 0x41, 0x24, 0x5D, 0x45, 0x08, 0x21, 0x88, 0xE1, 0x17, 0x9F, + 0x7F, 0x53, 0x37, 0x7D, 0x3A, 0x22, 0x13, 0x17, 0xC4, 0x5A, 0xBB, 0xBD, + 0xD8, 0x20, 0x86, 0x90, 0x3C, 0xD3, 0x01, 0x80, 0x60, 0x44, 0x09, 0x62, + 0x94, 0x60, 0x4C, 0x30, 0x21, 0xC9, 0x54, 0x7D, 0xE3, 0x14, 0x16, 0xA3, + 0xF3, 0xA1, 0x6D, 0xBB, 0xE4, 0x8C, 0xEA, 0x7D, 0xF0, 0xDE, 0xDF, 0xD6, + 0x3B, 0xAD, 0x0D, 0x26, 0x78, 0x58, 0x15, 0x49, 0x16, 0x90, 0x64, 0x4C, + 0xD6, 0x38, 0x6D, 0x5C, 0xA7, 0x0D, 0xC1, 0x38, 0xC6, 0x60, 0x7D, 0x68, + 0x7B, 0xE5, 0xBD, 0x4F, 0x61, 0x3D, 0x21, 0x80, 0x31, 0x36, 0x19, 0x43, + 0x85, 0xE0, 0x11, 0xC2, 0x21, 0x06, 0xCE, 0x68, 0x51, 0x66, 0xD6, 0x58, + 0xCE, 0x39, 0x63, 0x84, 0x31, 0x8A, 0x30, 0xA4, 0xEE, 0x52, 0x6B, 0xA3, + 0x8D, 0x6D, 0x9A, 0x16, 0x10, 0x2E, 0x8B, 0x7C, 0xBE, 0x58, 0x95, 0x65, + 0x59, 0x96, 0x25, 0xC2, 0xF8, 0x7B, 0x1F, 0x3C, 0x7C, 0xFC, 0xDE, 0x51, + 0x9E, 0x8B, 0xC9, 0x64, 0x7C, 0x7E, 0x71, 0x4D, 0x09, 0xBD, 0xBE, 0x59, + 0x44, 0x04, 0xC6, 0xFA, 0x37, 0x27, 0x6F, 0xCB, 0x3C, 0x3B, 0xD8, 0xDF, + 0x3B, 0x38, 0x3C, 0x58, 0xAD, 0xEB, 0x07, 0x47, 0xFB, 0x84, 0xE0, 0xA6, + 0x53, 0x17, 0x97, 0xF3, 0xB3, 0xF3, 0xAB, 0x1F, 0x7E, 0xF4, 0x64, 0x3A, + 0x1D, 0x5F, 0x5D, 0xCD, 0xA5, 0x94, 0x29, 0x61, 0x7A, 0x50, 0x16, 0xCE, + 0x6F, 0xC2, 0xB3, 0x29, 0x25, 0xA3, 0x61, 0x35, 0x1A, 0x96, 0x83, 0x2A, + 0x1B, 0x94, 0x05, 0x67, 0x14, 0xA5, 0x13, 0x2B, 0x02, 0x17, 0xAC, 0x69, + 0x7B, 0xA3, 0x37, 0x59, 0xD7, 0x79, 0x9E, 0x31, 0x46, 0x29, 0x41, 0x21, + 0x06, 0xC6, 0x18, 0xA5, 0xC4, 0x18, 0x5B, 0x94, 0x59, 0x55, 0x66, 0x99, + 0x14, 0x89, 0xFF, 0xCC, 0x28, 0x25, 0x7F, 0xF9, 0xB3, 0xBF, 0xD8, 0x84, + 0xF6, 0xA1, 0x84, 0xF1, 0x13, 0x42, 0xEF, 0x46, 0x7F, 0x63, 0x82, 0x92, + 0x2F, 0x18, 0xE2, 0x9C, 0x61, 0x82, 0x29, 0xA1, 0x42, 0x4A, 0x92, 0x60, + 0x75, 0x42, 0xEF, 0xF2, 0x24, 0x36, 0x0B, 0x41, 0xF8, 0x56, 0x93, 0xF5, + 0x0E, 0xE3, 0xFF, 0x7F, 0xDB, 0x03, 0xC0, 0xB6, 0x1B, 0x01, 0x94, 0x78, + 0x35, 0x11, 0x50, 0x04, 0x14, 0xD3, 0xD1, 0x17, 0x51, 0xA4, 0x94, 0x30, + 0xCA, 0x31, 0xC2, 0x11, 0x60, 0x0B, 0x86, 0xC5, 0xAD, 0x3B, 0x6C, 0xDA, + 0x8B, 0x6F, 0xB7, 0x07, 0x1B, 0xEA, 0xD5, 0xB7, 0xB8, 0x57, 0xDB, 0x7F, + 0x0B, 0x27, 0xFB, 0xE2, 0x2D, 0x74, 0x9B, 0xAE, 0x39, 0x8C, 0x31, 0x4E, + 0xEE, 0x3D, 0x10, 0x23, 0x40, 0x24, 0x04, 0x39, 0x67, 0x66, 0x97, 0x57, + 0xCB, 0x5A, 0xF9, 0x88, 0x22, 0x62, 0xD7, 0x2B, 0xED, 0x81, 0x94, 0x45, + 0x16, 0x82, 0xDF, 0x54, 0x3A, 0x8C, 0x38, 0xA5, 0x59, 0x2E, 0x72, 0x29, + 0x93, 0x11, 0x6D, 0x9A, 0x80, 0xFC, 0x66, 0x77, 0xB2, 0x69, 0x02, 0xD3, + 0x31, 0x89, 0x30, 0x22, 0x14, 0x33, 0x4A, 0x29, 0xC1, 0x94, 0xD2, 0x4C, + 0x8A, 0xAA, 0x2A, 0x64, 0x26, 0x10, 0xDA, 0x58, 0x8D, 0xC7, 0x10, 0x31, + 0x44, 0x82, 0xD1, 0x7A, 0x5D, 0xBF, 0x7C, 0x7D, 0xF6, 0xD5, 0xD3, 0x93, + 0x4F, 0x3F, 0x7F, 0x71, 0xB3, 0xEA, 0x12, 0x02, 0xAD, 0xB5, 0xE3, 0x8C, + 0x15, 0x79, 0x66, 0x8D, 0x5D, 0xAE, 0x9A, 0xE0, 0xCC, 0x62, 0xB9, 0x0E, + 0x80, 0xBF, 0xFC, 0xE6, 0xC5, 0xC9, 0xE9, 0xE5, 0xC9, 0xD9, 0xF9, 0x74, + 0x3A, 0x8E, 0x31, 0x5E, 0x5E, 0xDD, 0x34, 0x6D, 0xAF, 0x94, 0xE6, 0x8C, + 0xBD, 0x7D, 0x7B, 0x19, 0x63, 0xCC, 0xB3, 0x2C, 0xCF, 0xB2, 0xE0, 0xBD, + 0xF7, 0xE1, 0x7A, 0xB6, 0xE8, 0x3A, 0x35, 0x1A, 0x0D, 0x26, 0x93, 0x51, + 0x9E, 0xE7, 0xD6, 0xB9, 0xE9, 0x78, 0xB8, 0xBF, 0x3B, 0xB9, 0x7F, 0x6F, + 0xEF, 0x60, 0x7F, 0x37, 0xC6, 0xC8, 0xA5, 0xE0, 0x82, 0xE7, 0x59, 0xEE, + 0xBC, 0x7F, 0x7B, 0x39, 0x6B, 0xDA, 0xBE, 0x69, 0xBB, 0xE1, 0x60, 0xB0, + 0xBB, 0x3B, 0xE5, 0x9C, 0x9D, 0x5F, 0x5C, 0x2F, 0x57, 0xEB, 0x97, 0xAF, + 0x4E, 0xD6, 0xAB, 0x15, 0x42, 0x68, 0x50, 0xE6, 0x9C, 0xD2, 0xB3, 0xF3, + 0xCB, 0x4F, 0x3E, 0x7A, 0x32, 0x1C, 0x94, 0xAB, 0xBA, 0xED, 0x3A, 0x85, + 0x10, 0xA6, 0x94, 0x51, 0xC6, 0xDA, 0x4E, 0xB5, 0x9D, 0x5A, 0x2D, 0xD7, + 0x6D, 0xDD, 0x2A, 0xAD, 0x11, 0xC6, 0x83, 0x41, 0xE5, 0xBD, 0xEF, 0xBB, + 0x9E, 0x73, 0x96, 0x17, 0x39, 0x63, 0x34, 0xCB, 0x32, 0xC6, 0x58, 0x8C, + 0xB1, 0xEB, 0xFB, 0xBE, 0xD7, 0xC1, 0x07, 0x21, 0xB8, 0xB1, 0xF6, 0xCB, + 0xAF, 0x9E, 0xED, 0x4D, 0x77, 0x76, 0x77, 0x77, 0x6E, 0x6E, 0x96, 0x00, + 0x60, 0x8C, 0x21, 0x1B, 0x6D, 0x56, 0xA4, 0x94, 0xA6, 0xE8, 0x46, 0x8C, + 0x91, 0xD6, 0x36, 0x7A, 0x9F, 0x4B, 0x41, 0x30, 0x56, 0x5A, 0x03, 0x20, + 0x29, 0x45, 0xE2, 0x31, 0x21, 0x84, 0xBA, 0xBE, 0xFF, 0xE9, 0x4F, 0xFE, + 0x60, 0x3C, 0xAC, 0xBE, 0x7E, 0xFA, 0x72, 0x50, 0x55, 0x18, 0x63, 0x6D, + 0x4C, 0xB2, 0x1A, 0x47, 0xC9, 0xDD, 0x04, 0xE3, 0x5E, 0xA9, 0xAA, 0x2C, + 0x11, 0x46, 0xD7, 0x37, 0x0B, 0x29, 0xA4, 0x77, 0x5E, 0x69, 0x9B, 0x0C, + 0x94, 0x93, 0x47, 0xA0, 0xB1, 0x0E, 0x01, 0x9C, 0x5F, 0xDE, 0xF8, 0xE0, + 0xFF, 0xE0, 0xC3, 0x47, 0xC9, 0x63, 0x0E, 0x20, 0x4A, 0xCE, 0x87, 0x55, + 0xD6, 0x74, 0xDD, 0xDF, 0xFC, 0xFC, 0xCB, 0x34, 0x34, 0x61, 0x8C, 0x09, + 0xC6, 0xC6, 0xDA, 0x10, 0x02, 0xE7, 0x3C, 0xC4, 0x68, 0xB4, 0xA1, 0x04, + 0x27, 0xA0, 0x07, 0x20, 0x32, 0x46, 0x04, 0x67, 0x45, 0x91, 0x13, 0x42, + 0x28, 0x46, 0x99, 0xE0, 0x22, 0x13, 0x9C, 0x51, 0x46, 0x49, 0x08, 0xD1, + 0x79, 0xDF, 0x76, 0x3D, 0x42, 0x28, 0xCB, 0x64, 0xAA, 0xD1, 0xC9, 0xD7, + 0xD3, 0x85, 0x40, 0x09, 0x21, 0x04, 0x17, 0x85, 0x10, 0x8C, 0x39, 0xEF, + 0x29, 0x26, 0x5A, 0xDB, 0xBA, 0xED, 0x51, 0x8A, 0xB6, 0x45, 0x40, 0x08, + 0xA9, 0xDB, 0xCE, 0x59, 0x07, 0x08, 0xE5, 0x99, 0x8C, 0x21, 0x12, 0x8C, + 0xCA, 0x22, 0xDB, 0x9B, 0x8E, 0x19, 0xA5, 0x75, 0xD3, 0xE6, 0x79, 0x46, + 0x30, 0x26, 0x94, 0xA4, 0xB2, 0x15, 0x63, 0x64, 0x9C, 0x15, 0x99, 0x44, + 0x31, 0xD6, 0x6D, 0x6F, 0xAD, 0xED, 0xB5, 0x6E, 0x9B, 0x0E, 0x23, 0xF4, + 0xF8, 0x83, 0x47, 0x93, 0x9D, 0x91, 0x31, 0xEE, 0xFC, 0xFC, 0xBA, 0x2C, + 0xCB, 0xA4, 0x61, 0xBA, 0xBA, 0x59, 0xC4, 0x00, 0x55, 0x21, 0x6F, 0x6E, + 0x56, 0xC7, 0xA7, 0xE7, 0x27, 0x67, 0xE7, 0xBF, 0xFC, 0xF5, 0x57, 0x97, + 0x57, 0x37, 0x31, 0xC6, 0x22, 0xCF, 0x92, 0x4D, 0x96, 0x0F, 0x41, 0x6B, + 0xFB, 0xCD, 0xF3, 0x37, 0xFF, 0xF6, 0xDF, 0xFD, 0xEA, 0xF3, 0x2F, 0xBE, + 0x39, 0xD8, 0x1D, 0xFF, 0xA7, 0xFF, 0xEC, 0xA7, 0xFF, 0xEE, 0x17, 0xBF, + 0x61, 0x9C, 0xAF, 0x56, 0x75, 0xF0, 0x1E, 0x00, 0x06, 0x65, 0x4E, 0x09, + 0xE9, 0x95, 0xAA, 0x9B, 0x96, 0x51, 0xF6, 0xF0, 0xFE, 0xFE, 0xCE, 0x64, + 0xC0, 0x19, 0x4D, 0xF2, 0xC7, 0x64, 0xD0, 0x16, 0x62, 0xB4, 0xD6, 0x49, + 0xC1, 0xCB, 0x22, 0xD3, 0xC6, 0x22, 0x80, 0x4C, 0xF2, 0x18, 0xA3, 0xE4, + 0x9C, 0x31, 0xAA, 0xB4, 0x01, 0x00, 0x42, 0x88, 0xE0, 0x4C, 0x6E, 0x0A, + 0x18, 0xF1, 0x21, 0x86, 0xE0, 0xC9, 0x5F, 0xFE, 0xE5, 0xCF, 0x36, 0x88, + 0xD1, 0x26, 0x7E, 0x3C, 0xF9, 0xF7, 0x6F, 0xAA, 0x40, 0x04, 0x00, 0x4C, + 0x92, 0x41, 0x42, 0x62, 0xE5, 0x31, 0x21, 0x98, 0x10, 0x38, 0x41, 0x97, + 0x1B, 0x8E, 0x57, 0x8C, 0x31, 0x04, 0xEF, 0x21, 0x42, 0xF4, 0xEE, 0xB6, + 0x30, 0xC5, 0x10, 0x62, 0xF0, 0x46, 0xF7, 0x56, 0x2B, 0xBC, 0x89, 0x29, + 0x8E, 0x5B, 0x0F, 0xFD, 0x6F, 0xD7, 0xAF, 0xDB, 0x7A, 0x07, 0x00, 0x9B, + 0xC3, 0xEE, 0x16, 0x3D, 0x4B, 0x75, 0x27, 0x26, 0x18, 0x0B, 0xB6, 0x5F, + 0x16, 0x20, 0x6C, 0xA3, 0xA0, 0xB7, 0xD4, 0x9E, 0x6D, 0x10, 0x4B, 0x1A, + 0x72, 0xEF, 0x3E, 0x7F, 0xDC, 0xF6, 0xE2, 0x08, 0xE3, 0x4D, 0x0D, 0xBB, + 0xD3, 0xBB, 0xA5, 0x4E, 0x74, 0xDB, 0x00, 0x42, 0x04, 0x20, 0x84, 0x5E, + 0x5E, 0x5E, 0x7E, 0xF6, 0xD9, 0xD7, 0xBD, 0x89, 0xC6, 0x43, 0xA7, 0xBD, + 0x76, 0x91, 0x32, 0x56, 0xE4, 0x79, 0x8C, 0xE0, 0x7C, 0xF0, 0x31, 0xA4, + 0x7D, 0xAA, 0x94, 0x3C, 0xA5, 0x8D, 0xDE, 0xFE, 0x22, 0xA9, 0x78, 0xA5, + 0x95, 0xFF, 0x2D, 0x32, 0x92, 0xBA, 0x3D, 0x8C, 0x71, 0x88, 0x11, 0x21, + 0x9C, 0x38, 0x04, 0x18, 0x93, 0x34, 0xEF, 0x78, 0xEB, 0x19, 0x21, 0x14, + 0xC3, 0xAA, 0x6E, 0x7E, 0xF3, 0xF5, 0xAB, 0x7F, 0xF3, 0x77, 0xBF, 0xF9, + 0xFA, 0xD9, 0xE9, 0x8B, 0xE3, 0x0B, 0x21, 0x65, 0x32, 0x0E, 0xCA, 0xA4, + 0xA4, 0x14, 0x4B, 0x29, 0x9A, 0xB6, 0x7B, 0x73, 0xF2, 0x76, 0x36, 0x9B, + 0xDD, 0xDC, 0xAC, 0x1C, 0xA0, 0x8B, 0xEB, 0x45, 0xD3, 0x74, 0x4D, 0xD7, + 0x5B, 0x63, 0x38, 0x63, 0xEF, 0xBF, 0xFF, 0x70, 0x6F, 0x7F, 0xCF, 0x38, + 0x77, 0x73, 0x33, 0xBF, 0xB9, 0x99, 0x03, 0xC4, 0xF1, 0xA0, 0xE2, 0x9C, + 0xAF, 0xD6, 0x75, 0xF0, 0x61, 0xB9, 0xAA, 0x63, 0x84, 0xBD, 0xE9, 0x38, + 0x06, 0x7F, 0x73, 0xB3, 0x38, 0x3D, 0x7D, 0xBB, 0x58, 0x2C, 0xF7, 0xA6, + 0x93, 0xF1, 0xA0, 0x1C, 0x0F, 0x0B, 0x82, 0xB1, 0x0F, 0x00, 0x08, 0x9F, + 0xBD, 0xBD, 0xB4, 0x2E, 0xAC, 0xEB, 0xCE, 0xFA, 0xF8, 0xF5, 0xD3, 0x57, + 0x31, 0x80, 0x36, 0xF6, 0x57, 0xBF, 0xFE, 0xE2, 0x97, 0x9F, 0x7D, 0xD1, + 0x2B, 0xBD, 0xAE, 0x6B, 0x4E, 0xF0, 0x74, 0x32, 0x2C, 0xF2, 0xCC, 0x79, + 0x2F, 0x04, 0x6F, 0xDA, 0xFE, 0xF8, 0xE4, 0x3C, 0x44, 0x78, 0xF1, 0xF2, + 0x98, 0x31, 0xD6, 0x34, 0xAD, 0x75, 0x9E, 0x32, 0x7A, 0x78, 0xB8, 0xB7, + 0xBF, 0xB7, 0xB3, 0xB3, 0x33, 0x4E, 0xA6, 0x43, 0x42, 0x8A, 0x2C, 0xCB, + 0x8E, 0x8E, 0x0E, 0x8B, 0x42, 0x16, 0xB9, 0x18, 0x8F, 0x06, 0x3E, 0x84, + 0xB8, 0x09, 0x67, 0x40, 0xCE, 0x79, 0x63, 0xED, 0xB2, 0x6E, 0xDA, 0x4E, + 0x75, 0x5D, 0x1F, 0x9C, 0xFB, 0xED, 0x57, 0xCF, 0x31, 0xA1, 0x1F, 0x7C, + 0xF0, 0x60, 0xB5, 0xAA, 0xDB, 0xAE, 0xBF, 0x7D, 0x79, 0xB3, 0x4C, 0xA6, + 0x04, 0x49, 0x8C, 0x09, 0xE7, 0x4C, 0x8A, 0xE4, 0x95, 0xE9, 0x19, 0xA5, + 0x8C, 0x52, 0xEB, 0x9D, 0xB5, 0x1E, 0x63, 0x64, 0x8C, 0xDD, 0xD9, 0x19, + 0xFF, 0xF4, 0x8F, 0x3E, 0x16, 0x52, 0x28, 0x65, 0xB4, 0xD6, 0x79, 0x26, + 0x31, 0x46, 0x89, 0x67, 0x2F, 0x04, 0xE7, 0x9C, 0xDD, 0x3B, 0xD8, 0x6B, + 0xBB, 0xBE, 0x69, 0x3B, 0x6B, 0x5C, 0x8A, 0x59, 0xA0, 0x8C, 0x02, 0x02, + 0xE7, 0x3D, 0xE7, 0x2C, 0xCB, 0x84, 0xD6, 0xC6, 0x5A, 0x0B, 0x31, 0x22, + 0x84, 0xDF, 0x9C, 0x5C, 0x4C, 0x46, 0xE5, 0xE3, 0xF7, 0x0E, 0xBD, 0xF7, + 0x65, 0x2E, 0x4F, 0xCF, 0xAF, 0x9E, 0xBE, 0x3C, 0xFD, 0x9B, 0x9F, 0x7F, + 0x71, 0x71, 0xBD, 0x48, 0x55, 0xAC, 0xEB, 0xFA, 0x10, 0x63, 0xD8, 0x5A, + 0x7A, 0x59, 0x6B, 0xB5, 0x56, 0x00, 0x50, 0x96, 0xC5, 0x76, 0xCB, 0x84, + 0xA4, 0xE0, 0x5C, 0xF0, 0x4D, 0xDB, 0x0E, 0xD1, 0x6D, 0xDD, 0xA9, 0xAD, + 0x73, 0xA9, 0x8D, 0x12, 0x82, 0x3B, 0xBF, 0x09, 0xD3, 0xF5, 0xDE, 0xA7, + 0x02, 0xC1, 0x28, 0xE1, 0x8C, 0xA5, 0xA3, 0x98, 0x71, 0x06, 0x00, 0xBD, + 0xD2, 0x4D, 0xA7, 0xEA, 0xA6, 0xCB, 0x32, 0x89, 0x23, 0x38, 0xEF, 0x93, + 0xFF, 0x84, 0x0F, 0x01, 0x01, 0x2A, 0x72, 0x29, 0x04, 0xAD, 0x8A, 0x8C, + 0x53, 0xD2, 0xB4, 0x3D, 0x42, 0xB8, 0x2C, 0x8A, 0x00, 0x31, 0xBD, 0xC8, + 0x14, 0x13, 0x4C, 0x08, 0x00, 0x08, 0xC6, 0xDA, 0xAE, 0x77, 0xD6, 0xF7, + 0xDA, 0xE4, 0x99, 0xE8, 0x7A, 0xB5, 0x5A, 0xD5, 0xD6, 0xC7, 0xB7, 0x17, + 0xB3, 0x3C, 0xCB, 0xCA, 0x22, 0xFF, 0xE8, 0x07, 0x8F, 0x8D, 0x31, 0x82, + 0xF3, 0x67, 0x2F, 0x8E, 0x2F, 0xAE, 0x66, 0x52, 0x88, 0x9B, 0xC5, 0xF2, + 0xD9, 0xF3, 0x37, 0x42, 0x08, 0x2E, 0xB8, 0x52, 0x0A, 0x21, 0xB4, 0xAE, + 0x1B, 0x04, 0x68, 0x38, 0x1A, 0x32, 0x42, 0x96, 0xEB, 0xFA, 0x57, 0xBF, + 0xFE, 0xA2, 0xAE, 0x1B, 0xA5, 0x0D, 0x25, 0xE4, 0xE8, 0x68, 0xEF, 0xCD, + 0xC9, 0xF9, 0x7A, 0x55, 0xAF, 0x9B, 0x76, 0xB1, 0x5A, 0x0B, 0xC1, 0x27, + 0xA3, 0x72, 0x34, 0x2C, 0x47, 0xC3, 0x6A, 0x34, 0xA8, 0xA6, 0x93, 0xE1, + 0xDE, 0x74, 0x54, 0x16, 0x92, 0x92, 0x8D, 0x61, 0x43, 0x9A, 0x25, 0x09, + 0x46, 0x6D, 0xA7, 0x39, 0x63, 0xC3, 0x41, 0x8E, 0x10, 0x26, 0x04, 0x53, + 0x8A, 0x29, 0x21, 0xDE, 0xF9, 0xB6, 0x53, 0x5D, 0xAF, 0x19, 0xA5, 0x65, + 0x91, 0x71, 0x46, 0x53, 0xA1, 0xEF, 0xB5, 0x56, 0xC6, 0x3A, 0xEF, 0xC9, + 0x5F, 0xFC, 0xF9, 0x9F, 0xA7, 0x46, 0x08, 0xBE, 0xC5, 0xA9, 0x7A, 0x17, + 0x81, 0x99, 0x1A, 0x2D, 0x94, 0x2C, 0x70, 0x28, 0x23, 0x94, 0xDE, 0x72, + 0x67, 0x9D, 0xB5, 0xCE, 0x98, 0xE0, 0x1D, 0x42, 0x10, 0x82, 0x37, 0xAA, + 0x77, 0x56, 0x13, 0x42, 0x10, 0xC6, 0xDE, 0x19, 0x67, 0x75, 0xDF, 0x34, + 0x6D, 0xD3, 0x76, 0x6D, 0xA7, 0xBA, 0x4E, 0x29, 0x65, 0xAD, 0xC5, 0x04, + 0x41, 0x08, 0x28, 0xA5, 0x21, 0xDD, 0x65, 0x6C, 0xC4, 0x88, 0xB6, 0xF0, + 0x7F, 0xDA, 0x51, 0xA6, 0xB5, 0xE3, 0x6D, 0xE4, 0xE7, 0x06, 0x96, 0x00, + 0x84, 0xE0, 0xDD, 0x1A, 0x61, 0x53, 0xAE, 0xD0, 0xED, 0xF8, 0xB9, 0x7D, + 0x82, 0xDB, 0xE6, 0x7F, 0xFB, 0xA3, 0xC2, 0x36, 0x67, 0x00, 0x10, 0x24, + 0x56, 0xD0, 0xB6, 0x80, 0x92, 0xAD, 0x3B, 0xCB, 0x76, 0x0D, 0x4A, 0x48, + 0x5B, 0xD7, 0x5F, 0x7E, 0xF9, 0x2C, 0x04, 0xA0, 0x8C, 0x30, 0xC6, 0x9D, + 0x0B, 0xD6, 0x05, 0x46, 0xE9, 0x3B, 0xE5, 0x23, 0xC1, 0x98, 0x60, 0x4A, + 0x89, 0x10, 0x7C, 0xB3, 0x8E, 0xDA, 0x3E, 0xC2, 0x36, 0x4F, 0x3C, 0xD1, + 0x20, 0x7D, 0xCA, 0x43, 0x44, 0x18, 0x21, 0xE4, 0xAC, 0x4F, 0x37, 0x0C, + 0xC6, 0x18, 0x22, 0x38, 0xEF, 0x9D, 0x75, 0x31, 0x46, 0xC6, 0xC8, 0x7C, + 0xB1, 0xFA, 0xC5, 0x67, 0x4F, 0x3F, 0xFD, 0xCD, 0xCB, 0x57, 0x6F, 0xAE, + 0xA4, 0xCC, 0x76, 0x76, 0x76, 0xA4, 0xE0, 0x45, 0x9E, 0x23, 0x88, 0x59, + 0x26, 0x19, 0xA5, 0xF3, 0xE5, 0xFA, 0x57, 0xBF, 0xF9, 0x06, 0x10, 0xFE, + 0xE7, 0x7F, 0xFA, 0x1F, 0xFD, 0xE1, 0x27, 0x1F, 0xBE, 0xBD, 0x98, 0xBD, + 0x3E, 0x3D, 0x97, 0x52, 0xBC, 0xF7, 0xF0, 0x88, 0x10, 0xE6, 0x43, 0x58, + 0xAE, 0xD6, 0xEB, 0xBA, 0x7D, 0xF1, 0xFA, 0x98, 0x20, 0x18, 0x95, 0xD9, + 0x64, 0x58, 0x1E, 0xEE, 0x4E, 0x08, 0xC2, 0x17, 0xD7, 0x37, 0xDA, 0x18, + 0x63, 0x9C, 0xB1, 0x06, 0x01, 0x68, 0x63, 0x32, 0xC1, 0x9F, 0x3C, 0xBA, + 0x2F, 0x05, 0xDF, 0x9D, 0x8C, 0x26, 0xA3, 0x2A, 0x84, 0xE8, 0x7D, 0xB8, + 0x9A, 0xCD, 0x9F, 0x3E, 0x7B, 0x53, 0xB7, 0xCA, 0x39, 0xBF, 0xAC, 0x9B, + 0xCB, 0xEB, 0x45, 0xDB, 0x29, 0xCE, 0xF9, 0x62, 0xB5, 0xFE, 0xE2, 0xAB, + 0xA7, 0x8B, 0xC5, 0x4A, 0x4A, 0xE9, 0xBD, 0x47, 0x10, 0x87, 0x83, 0xA2, + 0xED, 0x35, 0x42, 0x90, 0xCB, 0xAC, 0xED, 0x15, 0x00, 0xBA, 0x59, 0xD4, + 0xBF, 0xFE, 0xED, 0xD3, 0xD7, 0xC7, 0x6F, 0xCF, 0x2F, 0xAE, 0xEB, 0xBA, + 0xDD, 0xDD, 0x9D, 0x24, 0x12, 0x40, 0x52, 0x8C, 0xED, 0xEC, 0x8C, 0x76, + 0xA7, 0x93, 0xE9, 0xCE, 0x78, 0x34, 0xAC, 0x8A, 0x22, 0xAB, 0xCA, 0xB2, + 0xEB, 0x3A, 0xEF, 0x42, 0x6A, 0x46, 0x18, 0x21, 0xC1, 0x87, 0xC5, 0x72, + 0x35, 0x5F, 0x2C, 0x75, 0xDF, 0x37, 0xEB, 0xA6, 0x69, 0x1A, 0x42, 0xB0, + 0x76, 0xE1, 0xF2, 0x6A, 0xD6, 0xB4, 0x2D, 0x21, 0xA4, 0x6D, 0x3B, 0x4E, + 0x29, 0x40, 0x4C, 0x29, 0x88, 0xCE, 0x79, 0xB6, 0xB9, 0xB1, 0x63, 0x8C, + 0x91, 0x12, 0xE2, 0x9C, 0xCB, 0xF3, 0x9C, 0x72, 0xBE, 0x5E, 0x37, 0xBB, + 0xD3, 0x49, 0x12, 0x78, 0x78, 0xEF, 0x17, 0xCB, 0xFA, 0x9B, 0xA7, 0x2F, + 0x9E, 0x3C, 0x7E, 0x94, 0x4B, 0x61, 0x8C, 0x1D, 0x0E, 0x06, 0x75, 0xD3, + 0xA4, 0x51, 0x2E, 0x93, 0x62, 0x77, 0x3A, 0xB1, 0xD6, 0x61, 0x84, 0x93, + 0x6D, 0xA9, 0xB1, 0x36, 0x02, 0xC4, 0x18, 0x18, 0x49, 0x74, 0x8D, 0x28, + 0x18, 0xEB, 0x95, 0x06, 0x84, 0xAA, 0x32, 0x6F, 0xDA, 0xEE, 0xD9, 0xCB, + 0xB3, 0x41, 0x99, 0x4D, 0x77, 0x46, 0xFF, 0xC7, 0xFF, 0xFD, 0xF7, 0xFF, + 0xEB, 0xBF, 0xFA, 0xD7, 0x4F, 0x5F, 0x9E, 0x8D, 0x86, 0x83, 0xD9, 0xCD, + 0x32, 0xA1, 0x1C, 0xC6, 0x98, 0x14, 0xDB, 0x9A, 0x30, 0x32, 0xCA, 0x48, + 0x0C, 0x41, 0x72, 0x9E, 0x3C, 0x8A, 0x09, 0x42, 0x9C, 0x33, 0x4E, 0xC8, + 0x76, 0xE6, 0xF5, 0xEB, 0xB6, 0x77, 0x3E, 0x19, 0xF0, 0x19, 0x88, 0xD1, + 0xF9, 0x60, 0x9D, 0x4F, 0x59, 0xEB, 0x49, 0x29, 0x99, 0x20, 0x3C, 0xA5, + 0x0D, 0x67, 0x54, 0x0A, 0x59, 0xB7, 0x5D, 0x91, 0x67, 0x8C, 0x92, 0xE4, + 0x8E, 0x2D, 0x38, 0x0B, 0x71, 0x43, 0xE6, 0x36, 0xD6, 0xA7, 0x26, 0x2B, + 0xFA, 0x90, 0xAE, 0xCC, 0xB6, 0xE9, 0xD2, 0x42, 0x36, 0xCB, 0x57, 0x37, + 0xC4, 0xC7, 0x00, 0x00, 0x20, 0x00, 0x49, 0x44, 0x41, 0x54, 0x33, 0x29, + 0xE4, 0x7A, 0xBD, 0x2E, 0xF2, 0xEC, 0xE1, 0x83, 0xC3, 0xF1, 0x78, 0xD4, + 0x75, 0xBD, 0xF3, 0x1E, 0x23, 0x44, 0x30, 0x49, 0x08, 0xE0, 0x9F, 0xFC, + 0xA3, 0x4F, 0x3E, 0x78, 0xF4, 0x60, 0xB9, 0x58, 0x9D, 0xBC, 0xBD, 0x64, + 0x8C, 0x3E, 0x38, 0xBA, 0x57, 0xE4, 0x79, 0xAF, 0xFA, 0x3C, 0xCF, 0xDE, + 0x1C, 0x9F, 0xAD, 0xEB, 0x8E, 0x12, 0xF4, 0xE6, 0xF8, 0xEC, 0xF5, 0xF1, + 0xD9, 0xF1, 0xE9, 0x79, 0x3A, 0xE9, 0xD3, 0xE0, 0x95, 0xF4, 0x4F, 0x18, + 0xA1, 0xAE, 0xEF, 0x27, 0x93, 0x31, 0x21, 0xA4, 0xEB, 0xDA, 0xFD, 0xBD, + 0x69, 0x91, 0xE7, 0xC6, 0xDA, 0xAA, 0x2C, 0xE6, 0x8B, 0x95, 0x31, 0xCE, + 0x5A, 0x5B, 0xE4, 0xD9, 0xC1, 0xEE, 0x78, 0x32, 0x1E, 0xEE, 0xED, 0x4E, + 0x86, 0x83, 0x62, 0x3C, 0xAA, 0x46, 0x83, 0x52, 0x0A, 0xB6, 0x9D, 0xE2, + 0xDE, 0xA9, 0x59, 0x8C, 0x75, 0x37, 0x8B, 0x15, 0x42, 0x48, 0x0A, 0x9E, + 0xAC, 0xD9, 0x04, 0x67, 0x09, 0xD3, 0x4C, 0xFE, 0x57, 0xE9, 0x2E, 0x73, + 0xDE, 0x2B, 0x6D, 0x3B, 0xA5, 0x17, 0xCB, 0x26, 0x69, 0xB3, 0xA8, 0x33, + 0x3A, 0xC6, 0xB8, 0x91, 0x4F, 0x53, 0x96, 0x66, 0x2B, 0x74, 0x67, 0x1C, + 0xDB, 0x74, 0x49, 0x00, 0x90, 0xFA, 0x8E, 0x18, 0xBD, 0x73, 0x40, 0x29, + 0x42, 0xC8, 0x69, 0xA3, 0xB5, 0x46, 0x08, 0x52, 0x82, 0x90, 0xD1, 0x1A, + 0x10, 0xB2, 0xD6, 0x31, 0xCE, 0x9C, 0xB1, 0xEB, 0xA6, 0xD5, 0xDA, 0x6E, + 0x12, 0xD8, 0x52, 0x5E, 0x24, 0x67, 0xA5, 0x52, 0x55, 0x59, 0xF0, 0x2C, + 0xA7, 0x18, 0x36, 0x39, 0x2E, 0xDB, 0x8A, 0x02, 0x00, 0x10, 0xC3, 0x36, + 0xFC, 0xF4, 0xAE, 0x63, 0x0A, 0x7A, 0xA7, 0x1D, 0x47, 0x90, 0x56, 0x8A, + 0xA9, 0xCE, 0x6E, 0x5B, 0x21, 0x04, 0x77, 0xB8, 0xA3, 0x89, 0xEA, 0x06, + 0x9B, 0x6A, 0xE8, 0x11, 0x20, 0x0C, 0xD8, 0xDF, 0xC2, 0xB4, 0x5B, 0x20, + 0x6C, 0x53, 0x10, 0xB7, 0x93, 0x6F, 0xAA, 0xDB, 0x08, 0x21, 0xA3, 0xF5, + 0xD3, 0x6F, 0x9E, 0x5B, 0xE3, 0xA4, 0x10, 0x31, 0x84, 0x80, 0x93, 0x02, + 0x04, 0x6E, 0xF7, 0x9B, 0xDB, 0x5A, 0x09, 0x89, 0x5D, 0x1D, 0x42, 0x40, + 0x09, 0xA7, 0xDB, 0x56, 0xCF, 0x5B, 0xBC, 0x16, 0x00, 0x42, 0x88, 0x1E, + 0x3C, 0xC6, 0x18, 0x02, 0x68, 0x63, 0xD3, 0x8F, 0x90, 0x1C, 0x3E, 0x31, + 0xC6, 0x84, 0xE0, 0xB6, 0x53, 0x9F, 0x7E, 0xFE, 0xCD, 0xAB, 0xE3, 0x2B, + 0x00, 0x5C, 0x94, 0x79, 0x59, 0xE6, 0x83, 0xB2, 0x68, 0xBA, 0xCE, 0x7B, + 0x7F, 0x7D, 0x35, 0xDB, 0xDD, 0x9B, 0xF6, 0x4A, 0x7F, 0xF5, 0xCD, 0xF3, + 0xBE, 0xD7, 0x7F, 0xFA, 0x4F, 0xFF, 0xF1, 0x64, 0x3C, 0xA8, 0x9B, 0xEE, + 0xE2, 0x5A, 0xF3, 0x2C, 0x1B, 0x0E, 0x87, 0x83, 0xAA, 0xBA, 0xB9, 0x59, + 0xCC, 0x6E, 0x16, 0xC9, 0x78, 0xC3, 0xFB, 0xF8, 0x83, 0xEF, 0x3F, 0xA9, + 0xD7, 0xF5, 0xE3, 0x07, 0x7B, 0xCE, 0x98, 0xAF, 0x9E, 0xBF, 0xD9, 0x19, + 0x8F, 0x8E, 0xF6, 0xA7, 0x97, 0xB3, 0x65, 0x80, 0x98, 0x89, 0x94, 0x1C, + 0x8C, 0x01, 0xA1, 0xF1, 0xB0, 0x98, 0x8E, 0xAB, 0xAE, 0x37, 0x4D, 0xA7, + 0x2E, 0xAE, 0xE6, 0x52, 0xC8, 0xA6, 0xEF, 0x97, 0xEB, 0xC6, 0x5D, 0xDE, + 0x60, 0x42, 0x64, 0x96, 0x3D, 0x7C, 0x70, 0xF4, 0xF6, 0xFC, 0xE2, 0xFA, + 0xFA, 0x26, 0xC4, 0x18, 0x23, 0x8C, 0xC7, 0xA3, 0xBA, 0x69, 0x42, 0x08, + 0xA3, 0x41, 0xA5, 0x8C, 0x4B, 0x7C, 0x17, 0x6D, 0xAD, 0x77, 0xBE, 0x55, + 0x5D, 0xD2, 0x28, 0x97, 0x45, 0x7E, 0x35, 0x5B, 0xBE, 0x39, 0xBD, 0x54, + 0xD6, 0xFF, 0x97, 0xFF, 0xF9, 0x9F, 0x19, 0x63, 0x62, 0x8C, 0x65, 0x91, + 0x05, 0x1B, 0x01, 0x62, 0x62, 0x33, 0x11, 0x4C, 0xA4, 0xE4, 0x4F, 0x9E, + 0xBC, 0x7F, 0x72, 0x72, 0x7E, 0x71, 0x7E, 0x95, 0x98, 0x68, 0xBA, 0xEF, + 0xA3, 0xB3, 0xA3, 0xB2, 0xC8, 0x32, 0x99, 0x2C, 0x76, 0x7B, 0xA5, 0xA8, + 0xF3, 0x40, 0xD9, 0x7C, 0xBE, 0x96, 0x82, 0xE7, 0x99, 0xB0, 0xDA, 0x00, + 0x4A, 0x11, 0x4D, 0xD4, 0x87, 0x8D, 0x99, 0x0F, 0x66, 0xCC, 0xF9, 0x50, + 0x77, 0x1D, 0x21, 0xA4, 0xD7, 0xE6, 0x83, 0xA3, 0x83, 0xFB, 0x47, 0xFB, + 0xBF, 0xFD, 0xF2, 0x59, 0x72, 0x19, 0xCC, 0xB2, 0xEC, 0xF4, 0xEC, 0x62, + 0xBE, 0x58, 0x74, 0xBD, 0x7A, 0x70, 0x74, 0x48, 0x08, 0x36, 0x46, 0xC7, + 0x10, 0x03, 0x04, 0x00, 0x58, 0x2C, 0x57, 0x75, 0xD3, 0x51, 0x42, 0xAA, + 0x22, 0xF7, 0xDE, 0x2B, 0x6D, 0xA8, 0xF7, 0xCA, 0xD8, 0x18, 0xA1, 0x2A, + 0x8B, 0x4E, 0xA9, 0xBE, 0xD7, 0xC9, 0xF6, 0xAB, 0x53, 0x2A, 0x93, 0xE2, + 0xD1, 0x83, 0xC3, 0xF9, 0x7C, 0xF9, 0xAF, 0xFE, 0xB7, 0xBF, 0x1E, 0xFE, + 0xF5, 0xAF, 0x9A, 0xA6, 0xBF, 0x7F, 0xB8, 0xBF, 0x37, 0x1D, 0xCD, 0x97, + 0xEB, 0x24, 0xBD, 0xB6, 0x89, 0x14, 0xB2, 0xE5, 0x2A, 0x1A, 0x63, 0x32, + 0x2A, 0x93, 0xB9, 0x7E, 0x8C, 0x01, 0x63, 0xE4, 0x22, 0x50, 0x8C, 0x00, + 0x81, 0x31, 0x76, 0x63, 0x3D, 0x16, 0x02, 0x42, 0x29, 0x39, 0xD0, 0x86, + 0x24, 0x9E, 0x71, 0x4E, 0x6B, 0x13, 0x62, 0x00, 0x84, 0x18, 0xA5, 0x4D, + 0xD3, 0x86, 0x18, 0x09, 0xC6, 0x99, 0x94, 0xCA, 0xE8, 0x44, 0x00, 0x16, + 0x82, 0xAF, 0xEB, 0xA6, 0xED, 0x34, 0xA5, 0x04, 0x22, 0x68, 0x6D, 0x93, + 0x77, 0x50, 0x08, 0xD1, 0x5A, 0xDD, 0x29, 0xC5, 0x19, 0xEB, 0x3B, 0x85, + 0x09, 0x76, 0x3E, 0x7E, 0xEF, 0xF1, 0x4E, 0xAF, 0xD4, 0x72, 0x35, 0xF3, + 0x5B, 0xF3, 0xCE, 0xD5, 0xBA, 0xD9, 0x99, 0x8C, 0x7A, 0xA5, 0xEB, 0xA6, + 0xD5, 0xC6, 0x08, 0xCE, 0xBD, 0x73, 0xB9, 0x64, 0x52, 0xB0, 0x34, 0x4D, + 0xAB, 0xBE, 0xFF, 0xD5, 0xE7, 0x5F, 0x4C, 0xC6, 0xC3, 0xE9, 0xCE, 0xB8, + 0x5E, 0xB7, 0x9F, 0x7C, 0xF4, 0x3D, 0x4A, 0xB1, 0x14, 0xFC, 0xBD, 0xFB, + 0x87, 0x7F, 0xF7, 0xF3, 0xCF, 0xB4, 0x36, 0x8C, 0x52, 0xEF, 0x5D, 0xAF, + 0x54, 0x9E, 0x49, 0x84, 0x68, 0x82, 0x1A, 0xCB, 0xAA, 0x7A, 0x73, 0x7C, + 0xBA, 0x5A, 0x2E, 0xC7, 0x93, 0xF1, 0xBD, 0xA3, 0x83, 0xDD, 0x9D, 0xF1, + 0xBA, 0x6E, 0x5E, 0xBE, 0x3E, 0xCB, 0x04, 0x2D, 0x27, 0x43, 0x8C, 0xD0, + 0xC3, 0xA3, 0x7D, 0xC1, 0x59, 0x12, 0xC6, 0xA7, 0x69, 0x91, 0x26, 0xA3, + 0xAD, 0x3B, 0x0F, 0x84, 0x90, 0x75, 0xBE, 0xEB, 0x35, 0xC1, 0x48, 0x30, + 0x1A, 0x63, 0xF0, 0x3E, 0x10, 0x8C, 0x39, 0xA3, 0xA9, 0x27, 0xC0, 0x18, + 0x27, 0x17, 0xE8, 0x10, 0xA3, 0x52, 0xC6, 0x18, 0xEB, 0x9C, 0xCF, 0x32, + 0x91, 0xC2, 0xCC, 0xA9, 0x33, 0x3A, 0x0D, 0x87, 0x84, 0xD2, 0x5B, 0x55, + 0x23, 0x24, 0x2E, 0xC2, 0xF6, 0x8E, 0xDD, 0x8C, 0x66, 0x31, 0x26, 0x1F, + 0xD4, 0xE0, 0x6C, 0xF4, 0xCE, 0xB9, 0xD0, 0x2B, 0x65, 0x9D, 0x33, 0xD6, + 0xA5, 0x24, 0x85, 0x94, 0xA0, 0x19, 0x62, 0xC0, 0x08, 0xA5, 0x30, 0x2E, + 0x04, 0x88, 0x52, 0xE2, 0xBC, 0xB7, 0xD6, 0x23, 0x84, 0xAC, 0xF5, 0x18, + 0xA1, 0xB2, 0xC8, 0x09, 0xC6, 0xC9, 0xCC, 0xE4, 0x5B, 0x1B, 0x4B, 0x84, + 0x20, 0x99, 0xE5, 0xC7, 0xF8, 0x2D, 0x5E, 0xC6, 0xA6, 0x94, 0xE2, 0xA4, + 0x89, 0x83, 0xC4, 0xC7, 0xD8, 0x92, 0x15, 0xD0, 0x1D, 0x69, 0xC1, 0xB7, + 0x96, 0x06, 0x1B, 0xEE, 0x22, 0x06, 0x14, 0x92, 0x00, 0x60, 0xFB, 0x59, + 0xB4, 0x9D, 0xA4, 0xBF, 0xB5, 0x51, 0x8D, 0xC1, 0x02, 0x60, 0x4C, 0xD9, + 0xF9, 0xD9, 0x99, 0xB5, 0x36, 0xCB, 0xA5, 0x35, 0x0E, 0x45, 0xDC, 0xA9, + 0x9E, 0x10, 0x5A, 0xE6, 0x2C, 0x6E, 0xA3, 0x33, 0x63, 0x84, 0x64, 0x27, + 0x0B, 0x18, 0x52, 0x49, 0xF2, 0xC8, 0xC7, 0x08, 0x04, 0x13, 0x42, 0xD0, + 0x46, 0xDF, 0x77, 0xFB, 0x53, 0x01, 0x84, 0x2D, 0x1D, 0x37, 0x19, 0x10, + 0x45, 0x80, 0x0C, 0x0B, 0xEF, 0xFD, 0x72, 0xBD, 0x7A, 0x7B, 0x31, 0x7F, + 0xFE, 0xF2, 0x24, 0x44, 0xC4, 0x05, 0xF5, 0xDE, 0xC6, 0x16, 0x38, 0xA5, + 0x2F, 0x5E, 0x1D, 0x97, 0x83, 0x8A, 0x51, 0xFA, 0xEA, 0xE4, 0xFC, 0xCD, + 0xF9, 0xF5, 0xE5, 0xE5, 0xAC, 0x5E, 0xAD, 0x47, 0xE3, 0xE1, 0x8B, 0xD7, + 0xA7, 0x2F, 0x5E, 0xC5, 0x93, 0xD3, 0x73, 0xA5, 0xCC, 0xAA, 0x6E, 0xD2, + 0x88, 0xD4, 0xD4, 0xAD, 0x90, 0x72, 0x32, 0x19, 0x0D, 0xAA, 0xAA, 0x6E, + 0xDA, 0xB7, 0xE7, 0x17, 0xCE, 0xBA, 0x17, 0xDE, 0xEE, 0xED, 0x0C, 0x93, + 0x39, 0xA7, 0xE0, 0x9C, 0x73, 0x8A, 0x10, 0x1A, 0x0D, 0xCA, 0x64, 0x1A, + 0x65, 0x8D, 0x3F, 0xBF, 0x5C, 0x4C, 0x77, 0x86, 0xF3, 0x75, 0x73, 0x7E, + 0x35, 0x4F, 0x71, 0x4D, 0x8B, 0x75, 0xEB, 0x7C, 0x88, 0x31, 0xEA, 0x5E, + 0xDD, 0x2C, 0x56, 0x75, 0xD3, 0x4E, 0xC6, 0xA3, 0x3C, 0xCF, 0x39, 0xA3, + 0x8B, 0xE5, 0x6A, 0xB9, 0x5A, 0x3B, 0x6B, 0xF7, 0xF6, 0x76, 0xF2, 0x22, + 0x9B, 0x5D, 0xCF, 0x09, 0xC1, 0x5A, 0xDB, 0xF4, 0x96, 0xA5, 0xD2, 0x23, + 0x84, 0x28, 0x8A, 0xBC, 0xEF, 0x54, 0x91, 0x67, 0xBF, 0xFD, 0xF2, 0x39, + 0x25, 0xE4, 0xBF, 0xF8, 0xCF, 0xFE, 0x34, 0xB1, 0x82, 0x53, 0x4D, 0xF7, + 0xC1, 0x1B, 0x63, 0x43, 0x30, 0x08, 0x81, 0x10, 0xFC, 0xC9, 0x93, 0x47, + 0x0F, 0xDF, 0x3B, 0x5A, 0xCC, 0x57, 0x75, 0xDD, 0xAC, 0x96, 0xEB, 0x62, + 0x58, 0x09, 0x21, 0x06, 0xC3, 0xC1, 0xFD, 0xA3, 0xFD, 0x57, 0xAF, 0x8F, + 0xDB, 0xB6, 0x57, 0xCA, 0x5C, 0xDE, 0xAC, 0xE6, 0xF3, 0xE5, 0xD5, 0xD5, + 0xAC, 0x28, 0xB2, 0x5C, 0xF0, 0xB4, 0x3B, 0xC7, 0x18, 0x41, 0x0C, 0xC9, + 0xE7, 0x2B, 0xC6, 0xC8, 0x39, 0x87, 0x18, 0xB9, 0x10, 0xFB, 0x7B, 0x93, + 0xC7, 0xEF, 0x1D, 0xDD, 0xBF, 0xB7, 0x67, 0x8C, 0x7E, 0x7D, 0x7C, 0xCE, + 0x28, 0xBD, 0xBA, 0xBE, 0x19, 0x0C, 0xAA, 0x4C, 0xCA, 0xAE, 0x53, 0xAB, + 0x75, 0x93, 0x4B, 0x31, 0x9B, 0x2F, 0x92, 0x65, 0x23, 0x65, 0xAC, 0xAE, + 0xDB, 0x18, 0xA3, 0x0F, 0xFE, 0x72, 0x76, 0x23, 0xA5, 0xB8, 0x77, 0x30, + 0xBD, 0xBE, 0x59, 0x30, 0xC6, 0xBC, 0x0F, 0x8B, 0xE5, 0xFA, 0xDE, 0xE1, + 0x6E, 0x0A, 0x6D, 0x9C, 0x4E, 0x46, 0x5D, 0xDF, 0xB7, 0x6D, 0xFB, 0x83, + 0xEF, 0xBF, 0xFF, 0xE4, 0xD1, 0xFD, 0x67, 0x2F, 0x8F, 0x2F, 0x2E, 0x67, + 0x8F, 0xDF, 0xBF, 0xFF, 0x67, 0x7F, 0xF2, 0xE3, 0x2F, 0x9F, 0xBD, 0xFE, + 0xE5, 0xE7, 0xDF, 0x64, 0x79, 0xE6, 0xC3, 0x56, 0xBA, 0x8B, 0x51, 0x70, + 0xA9, 0xF1, 0x47, 0x08, 0x22, 0xA7, 0x0C, 0x6D, 0x7D, 0xA2, 0xC4, 0x86, + 0x5D, 0x68, 0x23, 0x80, 0xF5, 0x01, 0x63, 0xB2, 0xB7, 0x33, 0x7E, 0x7B, + 0x79, 0xA3, 0xB4, 0x36, 0xDA, 0x6A, 0xE7, 0x92, 0xD9, 0x01, 0xC2, 0xC8, + 0x9B, 0x80, 0x10, 0x0A, 0xC8, 0x13, 0x42, 0x92, 0xE2, 0xBA, 0xEB, 0xFA, + 0x08, 0x90, 0x65, 0x92, 0x12, 0x1C, 0x7C, 0xD0, 0xDA, 0x36, 0x4D, 0xC7, + 0x18, 0x8D, 0x80, 0xD2, 0x84, 0xC5, 0x28, 0x8D, 0x14, 0xBC, 0x27, 0x9D, + 0x52, 0x07, 0x7B, 0xBB, 0xC6, 0xD9, 0xD1, 0xA0, 0xDA, 0x9D, 0x8E, 0xBF, + 0x79, 0xFA, 0xAA, 0xED, 0x54, 0xAF, 0x15, 0x02, 0xD4, 0x84, 0xAE, 0x69, + 0xBB, 0xB4, 0x4B, 0x2D, 0xF3, 0x3C, 0xF9, 0xF1, 0xC5, 0xE0, 0x7F, 0xF2, + 0xC3, 0x0F, 0x5F, 0xBC, 0x3A, 0xFE, 0xE3, 0x9F, 0xFE, 0x78, 0xB1, 0x5C, + 0x21, 0x84, 0x8C, 0xB1, 0x5D, 0xD7, 0x69, 0xAD, 0xD7, 0xAB, 0xFA, 0xF5, + 0x9B, 0xB3, 0x9F, 0xFC, 0xE1, 0xC7, 0x0F, 0x1F, 0xEC, 0x1B, 0x6B, 0xB3, + 0x5C, 0xC6, 0x18, 0x18, 0x25, 0x9C, 0x13, 0x42, 0x88, 0x36, 0xD6, 0x07, + 0x4F, 0x30, 0x65, 0x8C, 0x87, 0x18, 0xCA, 0x22, 0x9F, 0xCF, 0x17, 0x5D, + 0xA7, 0x76, 0x77, 0xC9, 0xFE, 0xDE, 0xD4, 0x7B, 0x1F, 0x43, 0x14, 0x9C, + 0x1D, 0x1E, 0x4C, 0x87, 0xC3, 0x2A, 0xE3, 0x8C, 0x60, 0x8C, 0x31, 0x2A, + 0x8B, 0x4C, 0x0A, 0x46, 0x08, 0x11, 0x82, 0x23, 0x04, 0x3E, 0x85, 0xB9, + 0xC5, 0xCD, 0x9D, 0xEB, 0xBD, 0x8F, 0x10, 0x19, 0x23, 0xA3, 0x61, 0x55, + 0x95, 0x39, 0xA3, 0x84, 0x18, 0x6B, 0x7D, 0x30, 0xD6, 0x25, 0x1E, 0x38, + 0xC2, 0x38, 0x39, 0xDA, 0x3B, 0xEF, 0x41, 0x6E, 0xE6, 0xAD, 0xE4, 0xBE, + 0x8D, 0x31, 0x26, 0xFF, 0xC3, 0xBF, 0xF8, 0xEF, 0xD2, 0x8D, 0x47, 0x29, + 0xC5, 0x08, 0xC5, 0x10, 0x52, 0x5B, 0x94, 0xA0, 0xFE, 0x54, 0xC5, 0x6E, + 0x81, 0x7C, 0x88, 0x21, 0x86, 0xD8, 0xF7, 0x7D, 0xDB, 0xAA, 0xC5, 0xAA, + 0x5E, 0xD5, 0x6D, 0xD7, 0xAA, 0xAE, 0xD7, 0x5D, 0xA7, 0x00, 0x01, 0xC1, + 0xA8, 0x57, 0xA6, 0xEB, 0x75, 0xDB, 0xE9, 0xB6, 0x57, 0xCE, 0x85, 0x44, + 0x16, 0xF7, 0xCE, 0xFB, 0x10, 0x30, 0x20, 0xC6, 0x49, 0x26, 0x79, 0x9E, + 0x49, 0x2E, 0x64, 0x2A, 0x62, 0x68, 0xFB, 0xAB, 0x6C, 0x90, 0xAE, 0x0D, + 0xA5, 0xFE, 0x4E, 0x66, 0xCD, 0xDD, 0x82, 0xF6, 0x6D, 0xCA, 0xFB, 0xBB, + 0x35, 0x42, 0xC2, 0xDE, 0xB7, 0x2B, 0xC9, 0x34, 0x26, 0xFE, 0x1E, 0x8A, + 0xDA, 0xE6, 0xBB, 0xF0, 0x2D, 0x09, 0x0E, 0xB6, 0xE3, 0x74, 0x8C, 0xD1, + 0x3B, 0x47, 0x30, 0x9A, 0x5D, 0x5F, 0x5D, 0x5C, 0xCC, 0x30, 0x26, 0x31, + 0x42, 0x44, 0xD8, 0xBA, 0x80, 0x31, 0x61, 0x2C, 0x4D, 0xB8, 0xA9, 0xA6, + 0xC3, 0x36, 0xB7, 0x35, 0xC6, 0x08, 0x18, 0x43, 0x80, 0xB8, 0x89, 0x23, + 0x40, 0x9B, 0xDF, 0x26, 0xDE, 0x91, 0x97, 0x46, 0x80, 0x94, 0x4F, 0x67, + 0x9C, 0x73, 0x36, 0x60, 0x8C, 0x28, 0x21, 0xAF, 0x4F, 0xDE, 0x3E, 0x7B, + 0x79, 0xF6, 0xEA, 0xE4, 0xEA, 0x66, 0x51, 0x8B, 0x4C, 0x46, 0x88, 0x5F, + 0x3F, 0x7D, 0xCE, 0x18, 0x97, 0x52, 0x1E, 0x9F, 0x5E, 0x3C, 0x7C, 0xF8, + 0xA0, 0x28, 0xF2, 0x5F, 0xFF, 0xF6, 0x1B, 0xE7, 0x83, 0x77, 0xCE, 0x19, + 0x23, 0x84, 0xD8, 0x9D, 0x4E, 0x52, 0x2C, 0xE6, 0xC7, 0x1F, 0x7F, 0x2F, + 0xF8, 0xD8, 0xB6, 0x3D, 0xC6, 0xD8, 0x58, 0x93, 0x16, 0xC6, 0x5A, 0xE9, + 0xAE, 0x57, 0x21, 0x44, 0x82, 0xF1, 0x7A, 0x5D, 0x63, 0x04, 0x04, 0x61, + 0xE3, 0x5C, 0xD7, 0x2B, 0x63, 0x5D, 0x84, 0xF8, 0xF0, 0x70, 0xB7, 0xC8, + 0xC4, 0xF5, 0x7C, 0xB5, 0x89, 0xAE, 0xE9, 0xD4, 0x7C, 0xD5, 0x2C, 0xD7, + 0xED, 0xD5, 0x7C, 0xD9, 0x74, 0xEA, 0x66, 0xB9, 0x6E, 0x3B, 0xA5, 0xB4, + 0xAE, 0xDB, 0xAE, 0xED, 0xD4, 0xE3, 0xC7, 0xEF, 0x1D, 0xEC, 0xEF, 0x36, + 0x4D, 0xD7, 0xF7, 0xFD, 0xD5, 0xD5, 0xAC, 0xAE, 0x6B, 0x04, 0x71, 0x38, + 0xAC, 0x28, 0xA5, 0xD6, 0xFB, 0xB6, 0xED, 0x24, 0x63, 0x4A, 0xA9, 0x10, + 0xA2, 0x36, 0x96, 0x52, 0xC2, 0x28, 0x03, 0x04, 0xCE, 0x39, 0x42, 0x10, + 0x25, 0x14, 0x10, 0x5C, 0xCE, 0x16, 0xAF, 0x8E, 0xDF, 0x16, 0x45, 0xCE, + 0x29, 0x4D, 0xB7, 0x07, 0x26, 0xA4, 0xC8, 0x33, 0xC6, 0x28, 0xE7, 0x34, + 0x04, 0xB0, 0xC6, 0x22, 0x84, 0x06, 0x83, 0x32, 0xCB, 0xB3, 0xBD, 0xFD, + 0xE9, 0x74, 0xBA, 0x53, 0x55, 0xFF, 0x0F, 0x5D, 0x6F, 0xD6, 0x64, 0x59, + 0x76, 0x9D, 0x87, 0xAD, 0x3D, 0x9F, 0xF1, 0x0E, 0x79, 0x73, 0xA8, 0xA9, + 0xBB, 0x7A, 0x02, 0x1A, 0x53, 0x83, 0x20, 0x01, 0x89, 0x83, 0x28, 0x4B, + 0x96, 0x6C, 0x87, 0x1F, 0xF4, 0xA0, 0xF0, 0x83, 0x5F, 0x1D, 0x0C, 0xE9, + 0xD9, 0xA4, 0xC9, 0xF0, 0xDF, 0x72, 0x84, 0xC2, 0xA1, 0x10, 0x4D, 0xD9, + 0x0E, 0x93, 0x04, 0x69, 0x8A, 0x20, 0x48, 0x0C, 0x0D, 0x34, 0xD0, 0x8D, + 0x9E, 0xAA, 0x2A, 0x2B, 0x2B, 0xA7, 0x3B, 0x9E, 0x69, 0x4F, 0x6B, 0xFB, + 0x61, 0x9D, 0x7B, 0x33, 0xBB, 0x41, 0xDF, 0x87, 0xEC, 0xAC, 0xEC, 0x3B, + 0x9C, 0x73, 0xEE, 0xD9, 0x6B, 0xAF, 0xF5, 0xAD, 0x6F, 0x7D, 0x5F, 0x59, + 0xE4, 0x59, 0xD3, 0xB4, 0xD3, 0xC9, 0x84, 0x03, 0xBE, 0x7C, 0x79, 0xA9, + 0x94, 0x7E, 0xF9, 0xEA, 0x72, 0xB7, 0xDB, 0x1D, 0x1D, 0xCD, 0x9D, 0xF7, + 0x0C, 0x40, 0x2B, 0x65, 0xB4, 0x8A, 0x98, 0x7C, 0xF0, 0x4A, 0xC9, 0xE3, + 0xC5, 0x11, 0x46, 0x4C, 0x88, 0x45, 0x9E, 0xFD, 0xE6, 0x6F, 0x7C, 0xFD, + 0xED, 0x37, 0x9E, 0x7C, 0xFF, 0x6F, 0xFE, 0x7E, 0xB5, 0xDE, 0xBD, 0xFE, + 0xDA, 0x23, 0xA5, 0xE4, 0x7A, 0xD3, 0x40, 0x62, 0x65, 0x99, 0x03, 0x80, + 0xF3, 0xBE, 0x6D, 0x1A, 0x63, 0x8C, 0x54, 0x4A, 0x4A, 0x71, 0xBC, 0x98, + 0x23, 0xE2, 0x7A, 0xB3, 0x2B, 0x8A, 0x8C, 0x33, 0xBE, 0xDB, 0xB5, 0x93, + 0x49, 0x55, 0x64, 0x59, 0xD3, 0x76, 0xCE, 0x7B, 0xC6, 0xA0, 0x2A, 0x8B, + 0xB6, 0xED, 0x9C, 0x73, 0x29, 0x61, 0x5D, 0x95, 0x9C, 0xF3, 0xE9, 0xA4, + 0x3C, 0x3D, 0x3E, 0x3A, 0x5E, 0xCC, 0x1E, 0x9D, 0x9D, 0x2C, 0x8E, 0xA6, + 0x37, 0xAB, 0xCD, 0x3F, 0xFC, 0xE4, 0x43, 0xAD, 0xF5, 0x30, 0x58, 0xA3, + 0x14, 0x00, 0xC6, 0x10, 0x8E, 0x17, 0xF3, 0x88, 0xA9, 0xEF, 0x7B, 0x21, + 0x45, 0x6E, 0x4C, 0x5D, 0x65, 0x74, 0x83, 0x95, 0x79, 0x16, 0x23, 0xB6, + 0xFD, 0x80, 0x23, 0x5C, 0xC3, 0x30, 0xA5, 0x22, 0x37, 0x5D, 0x37, 0x14, + 0x45, 0x7E, 0xBC, 0x98, 0x35, 0x6D, 0xEF, 0x9C, 0x57, 0x4A, 0x32, 0x60, + 0x83, 0xB5, 0x5C, 0x70, 0x25, 0xA4, 0xD6, 0x3A, 0xCB, 0x74, 0x08, 0x91, + 0x24, 0x8C, 0x48, 0xE2, 0x58, 0x29, 0xE1, 0x7D, 0x58, 0xAD, 0x1B, 0xC4, + 0x94, 0x65, 0xDA, 0x39, 0x2F, 0x38, 0xB7, 0xD6, 0xB6, 0x7D, 0x9F, 0x67, + 0x59, 0x4A, 0x69, 0x36, 0xAB, 0x7E, 0xE7, 0xBB, 0xDF, 0xCE, 0x32, 0xF3, + 0xC9, 0x67, 0xCF, 0x09, 0x9D, 0x20, 0x8F, 0x15, 0xCE, 0x58, 0x02, 0xD2, + 0xAF, 0x49, 0x5A, 0xC9, 0x2C, 0xD3, 0x82, 0xB3, 0x7F, 0xFD, 0x2F, 0x7E, + 0xFB, 0x64, 0x31, 0x7B, 0x71, 0xFE, 0xAA, 0x69, 0xFB, 0x8F, 0x3E, 0xFA, + 0xDC, 0x85, 0xC0, 0x39, 0x0F, 0x31, 0x66, 0xC6, 0x58, 0xE7, 0xDA, 0xAE, + 0xBB, 0xBC, 0x5E, 0x2E, 0x57, 0x9B, 0x93, 0xC5, 0xFC, 0xE6, 0x76, 0x75, + 0x73, 0xBB, 0xCC, 0xB2, 0x2C, 0x25, 0x20, 0x6E, 0x36, 0x21, 0x2D, 0x31, + 0xA2, 0x54, 0x02, 0x23, 0x9E, 0x9D, 0x1E, 0x6F, 0x76, 0xDB, 0xAF, 0x7E, + 0xE5, 0xED, 0xE0, 0xF1, 0x83, 0x0F, 0x3E, 0x5C, 0xAF, 0xD6, 0x83, 0xB5, + 0xC7, 0xF3, 0x29, 0x83, 0x64, 0x94, 0x72, 0xCE, 0x97, 0x65, 0x56, 0x15, + 0x99, 0x31, 0x9A, 0x74, 0x25, 0xC5, 0x81, 0xC9, 0xB2, 0x5F, 0xE4, 0x31, + 0x46, 0x06, 0xAC, 0xCC, 0xB3, 0x49, 0x55, 0x1A, 0x23, 0x85, 0x90, 0x4A, + 0x29, 0x4E, 0xD4, 0xB3, 0x04, 0x79, 0xA6, 0xB5, 0x24, 0xB9, 0x2C, 0x26, + 0x84, 0x50, 0x52, 0x2A, 0x29, 0x8C, 0x56, 0x46, 0x6B, 0x2E, 0x58, 0x66, + 0xB4, 0xF8, 0x93, 0xFF, 0xE5, 0x0F, 0x69, 0x67, 0xE3, 0x9C, 0x8F, 0x33, + 0x5B, 0x98, 0x18, 0x2D, 0x4B, 0x6A, 0xA7, 0xF1, 0x51, 0xA4, 0x3F, 0x21, + 0xDA, 0x61, 0x08, 0xDE, 0x5D, 0x5E, 0xAF, 0x6F, 0x56, 0xBB, 0xAE, 0x1F, + 0xBA, 0xC1, 0x3A, 0x17, 0x30, 0xE2, 0x83, 0xB3, 0xA3, 0xB7, 0xDE, 0x78, + 0xB2, 0x38, 0x9A, 0xE6, 0x99, 0x64, 0x0C, 0x9C, 0xF5, 0x3E, 0x04, 0xB2, + 0x29, 0x2E, 0x72, 0xAD, 0x95, 0x28, 0x8B, 0x8C, 0x73, 0xA8, 0x8A, 0xAC, + 0x2C, 0x8C, 0x10, 0x5C, 0x67, 0xD9, 0x58, 0xC8, 0x31, 0x96, 0x12, 0xDE, + 0x49, 0xA2, 0xEF, 0x39, 0x5F, 0x00, 0x09, 0x48, 0x3B, 0x6C, 0xC4, 0xBE, + 0xD2, 0x81, 0x60, 0x06, 0xF7, 0x12, 0x39, 0xBE, 0xE7, 0xC7, 0x32, 0xCE, + 0xF7, 0x39, 0xD8, 0x1D, 0xD1, 0x07, 0x60, 0x0F, 0xEB, 0xEF, 0x03, 0x1F, + 0x23, 0xE1, 0xB3, 0xF1, 0x39, 0x44, 0x16, 0xA3, 0x22, 0x14, 0x39, 0x67, + 0xCF, 0x9E, 0xBF, 0x78, 0xF1, 0xEC, 0x42, 0x29, 0x1D, 0x11, 0x23, 0x26, + 0x4C, 0x80, 0x23, 0xA7, 0x9F, 0x8D, 0x69, 0x62, 0xBA, 0x4B, 0xFA, 0x52, + 0x4A, 0x90, 0x18, 0xE3, 0x6C, 0x9C, 0x95, 0xE2, 0x74, 0x8C, 0x5F, 0x18, + 0x2D, 0x4A, 0xFB, 0xE3, 0x8F, 0x71, 0xE4, 0x61, 0xAC, 0x36, 0xBB, 0x8F, + 0x3E, 0x7E, 0xF1, 0xD3, 0x5F, 0x7C, 0x6A, 0xB2, 0xE2, 0xC5, 0xF9, 0xCB, + 0xEB, 0xDB, 0xDB, 0xC9, 0xB4, 0x9E, 0x4E, 0x27, 0x6F, 0xBC, 0xFE, 0xE4, + 0xAD, 0x37, 0x5E, 0x07, 0x06, 0xC7, 0xC7, 0x47, 0xDF, 0x78, 0xF7, 0xAD, + 0xDB, 0xD5, 0xC6, 0x98, 0xEC, 0xEB, 0xEF, 0xBE, 0xB5, 0x5E, 0x6D, 0xEC, + 0x30, 0xF8, 0x10, 0x43, 0xC4, 0x7A, 0x52, 0x21, 0xA6, 0xBA, 0xAE, 0x6F, + 0x96, 0xAB, 0x17, 0x2F, 0x2E, 0x52, 0x4A, 0x98, 0x90, 0x68, 0x1F, 0xDE, + 0x87, 0x69, 0x5D, 0x55, 0x45, 0x16, 0x7C, 0xB0, 0xCE, 0x65, 0xC6, 0x58, + 0xEB, 0x6F, 0xD6, 0xDB, 0xC5, 0x7C, 0x3A, 0xA9, 0x8B, 0xF5, 0xAE, 0x35, + 0x4A, 0xD6, 0x65, 0x7E, 0xBD, 0xDC, 0x70, 0xCE, 0x8C, 0xD6, 0x9D, 0xB5, + 0xCB, 0xF5, 0xAE, 0xED, 0xAD, 0x75, 0x81, 0x9C, 0x13, 0x18, 0x8C, 0x8C, + 0x53, 0x25, 0x65, 0x02, 0xF6, 0xEA, 0xD5, 0xD5, 0xED, 0x72, 0xD9, 0x76, + 0x2D, 0x22, 0xD6, 0x75, 0x39, 0x9D, 0xD6, 0x3E, 0x84, 0x6D, 0xD3, 0x5D, + 0x5F, 0x2F, 0x8B, 0xBD, 0xC1, 0x75, 0x62, 0x6C, 0x18, 0xAC, 0xD6, 0x9A, + 0x6A, 0x8D, 0xCC, 0x98, 0x3C, 0x33, 0x9C, 0x31, 0xEB, 0x42, 0xC4, 0xB8, + 0xDA, 0xEC, 0x7E, 0xFC, 0xFE, 0x87, 0xE4, 0x14, 0x47, 0xCA, 0x3F, 0x5C, + 0x8C, 0x23, 0xB1, 0x6D, 0xDB, 0x93, 0x38, 0x5A, 0x08, 0x21, 0x22, 0x52, + 0x13, 0x7D, 0xBD, 0xDD, 0xCD, 0x66, 0x93, 0x87, 0x67, 0x27, 0xEB, 0xED, + 0xEE, 0xF9, 0xF3, 0xF3, 0xAE, 0xEB, 0xBF, 0xF6, 0xB5, 0xAF, 0x00, 0x40, + 0x9E, 0x19, 0xC6, 0x58, 0x3F, 0xB8, 0x6D, 0xD3, 0x4C, 0xCA, 0x82, 0x71, + 0x26, 0xA4, 0xB0, 0xCE, 0xD1, 0x24, 0x06, 0x11, 0x0E, 0xA4, 0x94, 0x4F, + 0x1E, 0x9D, 0x85, 0x10, 0x3F, 0xF8, 0xF0, 0xD3, 0xA6, 0x69, 0x33, 0xA3, + 0x5F, 0x7B, 0x7C, 0x46, 0x7A, 0x0F, 0xC1, 0xC7, 0x3C, 0xCF, 0xA5, 0x94, + 0xCE, 0x5A, 0x22, 0xF4, 0x75, 0xFD, 0xD0, 0x34, 0xDD, 0xB4, 0xAE, 0xBE, + 0xF3, 0xED, 0xAF, 0xA5, 0x94, 0xB6, 0x9B, 0xAD, 0xD2, 0xAA, 0x2E, 0x0B, + 0x82, 0xA8, 0xDA, 0xB6, 0xA3, 0xE6, 0x83, 0x0F, 0x51, 0x0A, 0xDE, 0xB6, + 0xED, 0x6C, 0x36, 0x91, 0x42, 0x90, 0xA9, 0xC2, 0xD9, 0xE9, 0x51, 0x59, + 0xE4, 0x8C, 0xC1, 0x8F, 0x7E, 0xFA, 0xCB, 0xE5, 0x7A, 0x97, 0x65, 0xBA, + 0xE9, 0xBA, 0xB2, 0xC8, 0x18, 0x40, 0xD7, 0x5B, 0xEB, 0x7C, 0x4A, 0x00, + 0x2C, 0x69, 0x4D, 0xAD, 0x31, 0xAE, 0x94, 0xCA, 0xB5, 0x0E, 0x31, 0x36, + 0xFD, 0x40, 0xCD, 0x59, 0x29, 0x25, 0xB9, 0xCA, 0x23, 0x62, 0x8C, 0x49, + 0x4A, 0xF1, 0xF8, 0xD1, 0x03, 0xEA, 0x26, 0x1B, 0xA3, 0x23, 0x06, 0xE7, + 0xBC, 0x96, 0x52, 0x4A, 0x81, 0x98, 0x38, 0xE7, 0x88, 0x51, 0x6B, 0xAD, + 0xB5, 0xF2, 0x3E, 0x8C, 0x74, 0x8A, 0x98, 0xAC, 0xF3, 0x8C, 0x81, 0x10, + 0xBC, 0xED, 0xFB, 0x18, 0x51, 0x48, 0xA9, 0x95, 0x0E, 0x21, 0xE4, 0x99, + 0x59, 0xAD, 0x36, 0x2F, 0x2E, 0x2E, 0xB5, 0x52, 0xBF, 0xF3, 0xDD, 0xF7, + 0x9E, 0x3C, 0x3E, 0x7B, 0xF9, 0xEA, 0xA6, 0xEB, 0x87, 0xC1, 0x0E, 0x42, + 0x08, 0x06, 0x6C, 0x36, 0xAD, 0x8F, 0xE6, 0xB3, 0xD5, 0x76, 0x97, 0xE7, + 0xE6, 0xBF, 0xFB, 0x57, 0xBF, 0xFB, 0xDA, 0xE3, 0xB3, 0xF7, 0x7F, 0xFE, + 0xD1, 0x6C, 0x32, 0x79, 0xFF, 0xE7, 0x1F, 0xF5, 0x7D, 0xEF, 0x7C, 0xE0, + 0x9C, 0x4F, 0xEA, 0x7A, 0x3E, 0x9B, 0xFA, 0xE0, 0x23, 0x62, 0xDB, 0x76, + 0xA7, 0xC7, 0x47, 0xFF, 0xEC, 0xB7, 0x7F, 0xE3, 0xE2, 0xE2, 0xEA, 0xF9, + 0xF9, 0xA5, 0xB5, 0x4E, 0x6B, 0xAD, 0x94, 0xB6, 0xDE, 0x13, 0x0A, 0x0C, + 0x8C, 0x0D, 0x76, 0x08, 0x3E, 0x6E, 0x36, 0x5B, 0x6B, 0xDD, 0x62, 0xB1, + 0xD8, 0x6E, 0xB7, 0xDE, 0x07, 0xA3, 0xD5, 0xED, 0xED, 0xEA, 0x78, 0x31, + 0x3B, 0x3E, 0x9A, 0x17, 0xB9, 0x49, 0x09, 0x05, 0xE7, 0x59, 0xA6, 0x29, + 0xEE, 0x8C, 0x94, 0x88, 0x3D, 0xB2, 0x4D, 0x0B, 0x86, 0xCC, 0xE8, 0xB2, + 0x4C, 0x2B, 0x29, 0xF8, 0x98, 0x42, 0xC1, 0x1E, 0xB1, 0xA1, 0x11, 0x31, + 0xC2, 0xFE, 0xE5, 0xE8, 0x57, 0xC6, 0x85, 0x52, 0x72, 0xB4, 0xB0, 0x93, + 0x42, 0xFC, 0xF1, 0x1F, 0xFD, 0xCF, 0xF4, 0x54, 0x12, 0xE7, 0x0B, 0x21, + 0x50, 0x42, 0xC1, 0xC6, 0x7A, 0x53, 0xC5, 0x10, 0xBA, 0xA6, 0x05, 0x8C, + 0x09, 0xC3, 0xAB, 0xCB, 0xDB, 0xEB, 0x9B, 0xF5, 0xAE, 0xE9, 0xAD, 0x73, + 0x21, 0xC6, 0x4C, 0xEB, 0x93, 0xA3, 0xC9, 0xD9, 0xC9, 0xFC, 0xC1, 0xD9, + 0xC2, 0x59, 0xDB, 0xF7, 0x43, 0xDB, 0x0E, 0xDB, 0xA6, 0x1F, 0x9C, 0x27, + 0x2C, 0xF0, 0xF4, 0x78, 0xFA, 0xF0, 0x74, 0x5E, 0x57, 0x45, 0x66, 0xB4, + 0x14, 0x2C, 0x33, 0xAA, 0xAE, 0x6B, 0xD2, 0x3F, 0x65, 0xC4, 0x41, 0xDD, + 0x8F, 0x1C, 0xD1, 0x40, 0x21, 0x91, 0xAD, 0x53, 0xC2, 0x84, 0x31, 0x91, + 0xE2, 0x1F, 0x00, 0x63, 0xE4, 0x74, 0x40, 0x79, 0xDB, 0x08, 0x44, 0xF1, + 0xFD, 0x0C, 0xEF, 0x3E, 0x48, 0x01, 0xC0, 0x5D, 0xEB, 0x10, 0x88, 0x0D, + 0x01, 0x2C, 0xB1, 0x3B, 0xB8, 0x8A, 0x01, 0xE3, 0x5C, 0xDE, 0x1B, 0x9F, + 0xDA, 0xA3, 0x81, 0xC0, 0xB8, 0xE0, 0x97, 0x17, 0xAF, 0x2E, 0x5E, 0x5E, + 0x6A, 0x63, 0x00, 0x18, 0x22, 0x20, 0x42, 0x44, 0xE4, 0xFB, 0x31, 0x75, + 0xC6, 0x58, 0xC2, 0xF4, 0x25, 0x4A, 0x07, 0x1F, 0xCD, 0x99, 0xEE, 0xA7, + 0x7B, 0x77, 0xE2, 0xA1, 0x88, 0x29, 0x26, 0x8C, 0x01, 0x23, 0xA2, 0xF5, + 0x61, 0xB3, 0x6D, 0xFF, 0xE1, 0xA7, 0xBF, 0x7C, 0x75, 0xBD, 0xB9, 0xBE, + 0x5D, 0xCF, 0xA6, 0xD3, 0x8B, 0x57, 0x97, 0xC0, 0xD8, 0x93, 0xC7, 0x8F, + 0x16, 0x8B, 0x39, 0xC6, 0x38, 0xA9, 0xEB, 0x3C, 0xCF, 0xE7, 0xB3, 0xC9, + 0xF1, 0x62, 0xF6, 0xFE, 0x2F, 0x3E, 0xCE, 0xF3, 0x6C, 0x52, 0x15, 0x7F, + 0xF6, 0x7F, 0x7E, 0xFF, 0xF3, 0x67, 0x2F, 0x63, 0x44, 0xE7, 0xDD, 0x30, + 0xF8, 0x17, 0x2F, 0xAF, 0x5E, 0x5E, 0x5C, 0x7F, 0xF6, 0xEC, 0xFC, 0xFC, + 0xFC, 0x55, 0xF0, 0x21, 0x25, 0x9C, 0xD5, 0xB5, 0x56, 0x72, 0xD7, 0xB6, + 0xB9, 0xC9, 0x68, 0x18, 0x30, 0x62, 0x8C, 0x98, 0x38, 0xF0, 0xDE, 0xB9, + 0xDE, 0xB9, 0x10, 0xE3, 0xB4, 0x2A, 0xAE, 0x97, 0x9B, 0xB3, 0x93, 0xB9, + 0x0F, 0xA1, 0xC8, 0xB3, 0xA2, 0xC8, 0x56, 0xBB, 0x96, 0x1C, 0x6B, 0xC8, + 0xB7, 0x34, 0x8D, 0x32, 0x32, 0x3C, 0x61, 0x22, 0x4E, 0x65, 0x3F, 0x0C, + 0xCE, 0xB9, 0x18, 0xB1, 0x2C, 0xF2, 0x27, 0x4F, 0x1E, 0x52, 0x2B, 0xAD, + 0x6D, 0xBA, 0x6E, 0x18, 0xAC, 0x75, 0xB9, 0x51, 0x82, 0x13, 0x71, 0x9C, + 0x33, 0xC6, 0x9A, 0xB6, 0xC3, 0x84, 0x5A, 0x09, 0x06, 0x0C, 0x31, 0x96, + 0x45, 0x9E, 0x20, 0xB9, 0x10, 0xB5, 0x94, 0x4A, 0xCA, 0xA6, 0xE9, 0x3E, + 0xFC, 0xD5, 0xB3, 0x37, 0x9E, 0x3E, 0x3A, 0x9A, 0x4D, 0xBC, 0xF3, 0x42, + 0x8A, 0xBE, 0xEB, 0xAD, 0x73, 0x59, 0x66, 0x48, 0x1B, 0x93, 0x04, 0xFF, + 0x9A, 0xB6, 0xA7, 0x7C, 0xCD, 0xF9, 0xF0, 0x93, 0x9F, 0x7E, 0x20, 0x04, + 0xAF, 0xEB, 0xF2, 0xEA, 0xFA, 0xB6, 0x1B, 0xDC, 0x64, 0x52, 0xD7, 0x55, + 0x99, 0xE7, 0xC4, 0xC5, 0x4F, 0x99, 0xD1, 0x29, 0x25, 0x06, 0x2C, 0xC4, + 0xE8, 0xBD, 0x8F, 0x18, 0x8F, 0x66, 0xD3, 0x22, 0x37, 0xF3, 0xD9, 0xC4, + 0x7B, 0xFF, 0xEC, 0xF9, 0x45, 0x9E, 0x67, 0xCE, 0x07, 0x21, 0xC5, 0x6C, + 0x52, 0xF7, 0xBD, 0x5D, 0xEF, 0x9A, 0x94, 0x12, 0x19, 0x5E, 0x48, 0x21, + 0xBA, 0xC1, 0x4E, 0xAA, 0x0A, 0x20, 0x09, 0x21, 0x26, 0x55, 0x75, 0x75, + 0x75, 0x53, 0xE4, 0x39, 0xE7, 0xFC, 0x78, 0x31, 0xBF, 0xBC, 0xBA, 0xC5, + 0x84, 0x54, 0xEF, 0xF4, 0xC3, 0xA0, 0xA4, 0x20, 0x07, 0xDC, 0xF5, 0x7A, + 0xEB, 0x83, 0x97, 0x52, 0x92, 0x63, 0x5B, 0x55, 0xE6, 0x3F, 0xFE, 0xD9, + 0x47, 0xCE, 0x79, 0xEB, 0x3C, 0x79, 0x1D, 0x91, 0xD9, 0x20, 0x19, 0x35, + 0xA5, 0x94, 0x8C, 0x56, 0x7C, 0x6C, 0x1C, 0x31, 0x21, 0xA5, 0x14, 0xDC, + 0x07, 0x44, 0x4C, 0xE4, 0xCD, 0x2C, 0x85, 0x28, 0x8B, 0xCC, 0x87, 0x30, + 0x58, 0xCF, 0x19, 0x5F, 0x6F, 0x36, 0xCB, 0xD5, 0xC6, 0x3A, 0xDF, 0xF5, + 0xBD, 0x52, 0xCA, 0xFB, 0x20, 0x38, 0xAF, 0x8A, 0xC2, 0xF9, 0xC0, 0x38, + 0x97, 0x52, 0x42, 0x4A, 0x42, 0x08, 0xEB, 0x1C, 0x22, 0x8E, 0xD6, 0x90, + 0x88, 0xD7, 0x37, 0xCB, 0xA2, 0x28, 0x08, 0x24, 0x62, 0x9C, 0xE5, 0x59, + 0x86, 0x09, 0x6F, 0x97, 0x2B, 0x25, 0x04, 0x02, 0x5C, 0x5E, 0xDF, 0xD0, + 0x94, 0xD5, 0xFB, 0x1F, 0xFC, 0xEA, 0xFA, 0x76, 0xE5, 0x7D, 0xC8, 0x8D, + 0x39, 0x3B, 0x39, 0xEA, 0xDA, 0x9E, 0x71, 0xEE, 0x9C, 0x3B, 0x3D, 0x9E, + 0xFD, 0xCB, 0x7F, 0xF6, 0xDD, 0xB3, 0x93, 0x79, 0xDB, 0xF5, 0x1F, 0x7F, + 0xF2, 0xFC, 0x97, 0xBF, 0xFA, 0x3C, 0xCF, 0x33, 0xEF, 0x1C, 0xCD, 0x2A, + 0x1A, 0xA3, 0x49, 0xC1, 0xAB, 0xEF, 0x07, 0x21, 0x44, 0x3F, 0x0C, 0xCB, + 0xD5, 0x16, 0x11, 0x9F, 0x9F, 0x5F, 0x20, 0x22, 0x59, 0xC9, 0x35, 0x5D, + 0x4F, 0xE8, 0x15, 0xAD, 0x45, 0x02, 0x25, 0x63, 0x8C, 0xD3, 0x69, 0xDD, + 0xB5, 0xED, 0xD0, 0x0F, 0x5D, 0xDF, 0x49, 0x21, 0x1F, 0x3C, 0x38, 0x91, + 0x52, 0xCC, 0x67, 0x13, 0xC6, 0x98, 0x90, 0xBC, 0x2C, 0x32, 0xAD, 0xA5, + 0x14, 0x7C, 0xCF, 0x2A, 0x20, 0xCE, 0x16, 0x13, 0xA3, 0xAA, 0x9A, 0x10, + 0x92, 0x13, 0x2F, 0xFD, 0x8E, 0xBF, 0x4E, 0xD0, 0x98, 0x92, 0x9C, 0x0B, + 0xF2, 0xA8, 0x3D, 0x4C, 0xFD, 0xB3, 0xBD, 0xB8, 0x04, 0xE7, 0x8C, 0x71, + 0x26, 0xFE, 0xF8, 0x8F, 0xFE, 0x90, 0x72, 0xB1, 0x18, 0x02, 0x26, 0x42, + 0xD7, 0x14, 0xF1, 0xF3, 0xB9, 0x90, 0x42, 0xCA, 0xD5, 0x72, 0xB5, 0x5C, + 0xAE, 0x04, 0x67, 0xAB, 0x4D, 0x7B, 0xBB, 0xDC, 0x59, 0xEB, 0x23, 0x46, + 0xCE, 0x59, 0x99, 0x67, 0x47, 0xB3, 0xB2, 0x2C, 0xB2, 0xC1, 0xFA, 0xDB, + 0xD5, 0xF6, 0x66, 0xB9, 0xB9, 0xB9, 0xD9, 0x5C, 0x5E, 0x6F, 0xBA, 0x7E, + 0x08, 0x21, 0x5A, 0x1B, 0xEA, 0x22, 0xFB, 0xCA, 0x3B, 0x4F, 0x75, 0x9E, + 0xF3, 0x51, 0x11, 0x9B, 0x31, 0xC6, 0xB4, 0x31, 0xCA, 0x64, 0xE3, 0xF7, + 0xCC, 0x58, 0x1A, 0xC7, 0x1E, 0x29, 0x2B, 0x42, 0x96, 0x30, 0x7A, 0x8F, + 0x21, 0x1C, 0x9A, 0x98, 0x04, 0x42, 0x01, 0xE7, 0xD4, 0x05, 0xA7, 0xB9, + 0x57, 0x8A, 0x47, 0x8C, 0x73, 0x48, 0x0C, 0x00, 0x19, 0x03, 0xC6, 0x04, + 0x90, 0x0B, 0xC9, 0x7E, 0x12, 0x33, 0x41, 0x62, 0x09, 0x28, 0xEC, 0x8F, + 0x3F, 0xC5, 0x3F, 0xAE, 0x04, 0xCB, 0x39, 0xEF, 0x9A, 0xDD, 0xF3, 0x67, + 0x2F, 0x04, 0x57, 0x09, 0x00, 0x23, 0x84, 0x88, 0x89, 0x68, 0x27, 0x34, + 0x30, 0x2C, 0xC6, 0xF4, 0x74, 0xAC, 0x0B, 0xEE, 0x61, 0x94, 0x87, 0x48, + 0x0A, 0x00, 0xC0, 0x12, 0x3F, 0x88, 0x6D, 0xA4, 0x84, 0x29, 0xC5, 0x90, + 0x42, 0xC4, 0xDD, 0xAE, 0x3B, 0x7F, 0x79, 0xFD, 0xE2, 0xD5, 0xED, 0xAB, + 0xAB, 0xDB, 0xAA, 0xAC, 0xBA, 0xBE, 0x97, 0x4A, 0x02, 0x63, 0xCE, 0xF9, + 0x2C, 0xCF, 0xA7, 0xD3, 0x7A, 0x36, 0x9D, 0x0C, 0xD6, 0x39, 0xEF, 0xD6, + 0x9B, 0xAD, 0x92, 0xF2, 0xEC, 0xF4, 0xA8, 0x2E, 0x8B, 0x3F, 0xFF, 0xFE, + 0xDF, 0x5E, 0x5D, 0x2F, 0x81, 0xB1, 0x61, 0xB0, 0xB4, 0x86, 0x53, 0x4A, + 0xBD, 0xB5, 0xAB, 0xCD, 0x46, 0x29, 0x05, 0x09, 0x26, 0x75, 0x79, 0x34, + 0x9D, 0x6E, 0xDB, 0x96, 0xD2, 0x9C, 0xCE, 0x5A, 0x29, 0xE4, 0x83, 0xE3, + 0xA3, 0xAA, 0xC8, 0xB7, 0x4D, 0x13, 0x10, 0xEB, 0xA2, 0x88, 0x18, 0x5F, + 0xDD, 0xAC, 0x10, 0xD3, 0x6C, 0x52, 0x7B, 0x1F, 0x63, 0x4A, 0x57, 0xCB, + 0xCD, 0x66, 0xD7, 0x7A, 0x92, 0x03, 0x02, 0x20, 0x69, 0x07, 0x9A, 0xAF, + 0xA6, 0xB6, 0x5D, 0x8C, 0x48, 0xF0, 0xE5, 0xF1, 0x62, 0x56, 0x16, 0x79, + 0x5D, 0x57, 0x5D, 0xD7, 0xF5, 0xFD, 0xD0, 0x0F, 0x6E, 0xB0, 0x4E, 0x1B, + 0x33, 0xA9, 0x6B, 0x44, 0x84, 0x94, 0xB4, 0xD6, 0x44, 0xA4, 0x84, 0x94, + 0x8C, 0x56, 0x18, 0x31, 0x2F, 0x32, 0x21, 0x39, 0x24, 0x20, 0x6D, 0xB8, + 0xBA, 0x2C, 0x10, 0x71, 0xB9, 0xDA, 0x70, 0xCE, 0xDE, 0xFB, 0xE6, 0x57, + 0x62, 0x0C, 0x52, 0x70, 0x44, 0xB4, 0xCE, 0xB7, 0x6D, 0xB7, 0x6B, 0x3B, + 0xCE, 0x59, 0x59, 0x96, 0xE4, 0xBD, 0xA0, 0x94, 0x68, 0xDB, 0x5E, 0x0A, + 0xF1, 0xF4, 0xB5, 0x47, 0x8F, 0x1F, 0x3F, 0x98, 0x4E, 0x27, 0xDB, 0xED, + 0xEE, 0xFA, 0x76, 0xBD, 0xDA, 0x6C, 0x87, 0xC1, 0x9E, 0x9D, 0x1E, 0x03, + 0xA2, 0x77, 0x8E, 0x84, 0xC9, 0x94, 0x92, 0xF4, 0x25, 0xD0, 0xDE, 0x5D, + 0x55, 0xE5, 0xC3, 0xB3, 0x93, 0x94, 0xD2, 0xF5, 0xCD, 0x92, 0xCA, 0xF1, + 0xCC, 0x64, 0x34, 0x56, 0x29, 0xA5, 0x5C, 0x2C, 0x66, 0x97, 0x97, 0x37, + 0x11, 0xD3, 0xD1, 0x6C, 0x32, 0x99, 0x54, 0x5A, 0xAB, 0xA6, 0xED, 0x48, + 0x4B, 0x64, 0xBB, 0x6B, 0xBF, 0xF2, 0xCE, 0xD3, 0xED, 0xAE, 0x7D, 0xFE, + 0xE2, 0xC2, 0x18, 0x95, 0x19, 0x3D, 0x9B, 0xD6, 0xBB, 0xA6, 0x9B, 0x4D, + 0xAB, 0x69, 0x5D, 0x31, 0x00, 0x29, 0x84, 0x92, 0x82, 0x26, 0x9F, 0x20, + 0x81, 0x0B, 0x21, 0xCB, 0xCC, 0x66, 0xB3, 0x7B, 0xF6, 0xE2, 0xA2, 0xAE, + 0xCA, 0xD5, 0x7A, 0xCB, 0x19, 0x53, 0x4A, 0x79, 0xEF, 0xAD, 0xF3, 0x90, + 0x80, 0x0B, 0x26, 0x38, 0x23, 0xC2, 0xF6, 0x60, 0x1D, 0xE7, 0x3C, 0x37, + 0x6A, 0x70, 0x9E, 0x16, 0x9E, 0x16, 0x5C, 0x4A, 0xA1, 0xA5, 0xEC, 0xAD, + 0xDB, 0x35, 0x5D, 0x8C, 0x11, 0x23, 0xF6, 0xFD, 0x50, 0x96, 0xE5, 0x76, + 0xBB, 0xDB, 0x93, 0xD4, 0xC0, 0x5A, 0x9F, 0x20, 0x29, 0x29, 0x9D, 0x73, + 0x8C, 0x71, 0x6B, 0x1D, 0x63, 0xEC, 0xEC, 0x74, 0x51, 0x16, 0x26, 0xCF, + 0xCC, 0xB3, 0xF3, 0x57, 0xCE, 0x79, 0x12, 0xC9, 0xA1, 0xB6, 0x78, 0xD3, + 0xB6, 0x79, 0x66, 0x4E, 0x8F, 0x17, 0x5D, 0xDF, 0x0F, 0xD6, 0x9E, 0x2C, + 0x16, 0x18, 0x71, 0xBD, 0xDD, 0x19, 0xAD, 0x8F, 0x17, 0x47, 0xD6, 0xDA, + 0xC1, 0xDA, 0xE9, 0xA4, 0x24, 0x9F, 0xBD, 0x6F, 0x7E, 0xED, 0xCD, 0xFF, + 0xFA, 0xF7, 0xBF, 0x57, 0x64, 0xC6, 0xFB, 0xF0, 0xD3, 0x9F, 0x7D, 0xB4, + 0x5C, 0x6D, 0x7F, 0xE7, 0x7B, 0xDF, 0x36, 0x46, 0x7D, 0xF4, 0xF1, 0xE7, + 0x75, 0x59, 0x38, 0xE7, 0xFB, 0xC1, 0x4A, 0x29, 0xBB, 0x6E, 0xF0, 0x21, + 0xBC, 0xF6, 0xE8, 0x8C, 0x31, 0x76, 0x73, 0x73, 0x3B, 0x9B, 0x54, 0x5A, + 0xC9, 0xB2, 0x2A, 0x1F, 0x3D, 0x38, 0x15, 0x9C, 0xC5, 0x18, 0xA7, 0x75, + 0x59, 0x97, 0x45, 0x6E, 0x54, 0xAE, 0xE5, 0xB4, 0xCC, 0x43, 0x0C, 0x2E, + 0x44, 0x3B, 0xB8, 0xC1, 0x5A, 0xEF, 0x5D, 0x99, 0xE7, 0x55, 0x55, 0x2A, + 0x29, 0xE7, 0xB3, 0x2A, 0x33, 0x5A, 0x2B, 0x31, 0xA9, 0x0B, 0xAD, 0x88, + 0x34, 0x3E, 0x4E, 0x17, 0xD2, 0xFA, 0xE1, 0x87, 0xC7, 0x5E, 0xBC, 0xEB, + 0xC0, 0x97, 0x18, 0x53, 0x12, 0x4E, 0x89, 0x98, 0x20, 0x63, 0x8D, 0x2F, + 0x20, 0x48, 0xF7, 0xAA, 0x53, 0xCA, 0xD3, 0x46, 0xCC, 0x88, 0x9C, 0x78, + 0xA4, 0x52, 0xC0, 0x85, 0x10, 0x82, 0x52, 0x9E, 0xE3, 0x93, 0xE3, 0x3C, + 0xCB, 0xCE, 0x5F, 0x5E, 0xD2, 0x6C, 0x7D, 0xDA, 0x93, 0xD3, 0x10, 0xD3, + 0xCD, 0x6A, 0xD7, 0xBF, 0xBC, 0xA5, 0xE3, 0x0B, 0x21, 0x0E, 0xCE, 0x7B, + 0x1F, 0x89, 0xEC, 0x50, 0x64, 0xEA, 0xF5, 0xD7, 0x1F, 0x64, 0x65, 0x11, + 0x22, 0x2A, 0x00, 0xA5, 0x54, 0x42, 0x6C, 0x9A, 0x56, 0x6B, 0x27, 0xA4, + 0x44, 0x87, 0x42, 0x4A, 0x3E, 0xB6, 0xAB, 0x01, 0x80, 0x01, 0x46, 0xC0, + 0x48, 0x51, 0x2B, 0x21, 0x8E, 0x93, 0x6C, 0x63, 0xCC, 0x48, 0xFB, 0xAE, + 0x62, 0x22, 0xB5, 0x58, 0xC6, 0x18, 0xE3, 0xF7, 0xA5, 0xBB, 0xD8, 0xC8, + 0x0B, 0x3B, 0x54, 0xA8, 0xD4, 0x49, 0xD8, 0x67, 0xA6, 0x90, 0x04, 0xB0, + 0x2F, 0x36, 0x10, 0xC6, 0xD7, 0x92, 0xA5, 0xB9, 0x7D, 0xF1, 0xFC, 0x1C, + 0x11, 0x18, 0x67, 0x64, 0xB1, 0x37, 0xAA, 0x3A, 0x26, 0x48, 0x7B, 0xD5, + 0xE9, 0xC3, 0x85, 0x0D, 0x98, 0x18, 0xD1, 0xD8, 0x12, 0x2A, 0x10, 0x42, + 0x8C, 0xD7, 0x9D, 0xB8, 0x62, 0xA4, 0xB4, 0xB3, 0x4F, 0x32, 0x59, 0x8C, + 0xB8, 0x6B, 0xFB, 0xF3, 0x8B, 0xAB, 0x8B, 0x8B, 0x2B, 0xC6, 0xC5, 0xD9, + 0xC9, 0x71, 0x08, 0xE1, 0xD1, 0xA3, 0xB3, 0xA3, 0xA3, 0xF9, 0x76, 0xDB, + 0x74, 0xDD, 0xF0, 0xE0, 0xEC, 0x98, 0x2C, 0xC8, 0x6E, 0x97, 0x6B, 0x6B, + 0x2D, 0xA4, 0xF4, 0xE0, 0xF4, 0xA4, 0xEB, 0x86, 0xFF, 0xE3, 0xCF, 0xFE, + 0xE2, 0xD5, 0xE5, 0xB2, 0xB7, 0x03, 0x8D, 0x43, 0x73, 0x00, 0xEB, 0x5C, + 0xC4, 0x14, 0x13, 0x4E, 0xAA, 0xBA, 0x2C, 0xF2, 0xCD, 0x76, 0xCB, 0x38, + 0xBF, 0xDD, 0x6C, 0xBA, 0x6E, 0x40, 0x44, 0xD0, 0x0C, 0x13, 0xB4, 0x83, + 0xBD, 0xBA, 0x5D, 0x53, 0x2F, 0xDF, 0x79, 0x2F, 0x84, 0x50, 0x42, 0x4A, + 0x81, 0x8C, 0xB1, 0x57, 0xD7, 0xEB, 0x98, 0x90, 0x01, 0x74, 0xDD, 0x40, + 0x26, 0xC1, 0x04, 0x5F, 0x22, 0x26, 0xEB, 0x03, 0xA2, 0x27, 0x00, 0x02, + 0x12, 0x70, 0xCE, 0x42, 0x88, 0xA7, 0x27, 0xF3, 0x49, 0x5D, 0xED, 0x76, + 0x4D, 0xB3, 0xDB, 0xD9, 0xC1, 0x6E, 0x9B, 0xB6, 0x1F, 0x6C, 0x55, 0x95, + 0xA7, 0xC7, 0x0B, 0x06, 0x69, 0xB7, 0xDD, 0x1D, 0x7A, 0xB8, 0x42, 0x08, + 0x92, 0x09, 0xA8, 0xCB, 0x8C, 0x01, 0x5B, 0xAF, 0x76, 0x64, 0x33, 0xBA, + 0x6D, 0xDA, 0xF9, 0xA4, 0x2E, 0x0B, 0x33, 0xA9, 0x8A, 0xA3, 0xD9, 0xC4, + 0x39, 0x17, 0x63, 0x0C, 0xCE, 0x93, 0x34, 0xD8, 0x7C, 0x3E, 0xDD, 0xEC, + 0x9A, 0x04, 0x20, 0x84, 0x08, 0xC1, 0xD7, 0x65, 0x41, 0xF3, 0x77, 0x9B, + 0x6D, 0x43, 0x86, 0x98, 0xC6, 0xE8, 0xDF, 0xFC, 0xCE, 0x37, 0xB3, 0xCC, + 0x5C, 0x5E, 0xAF, 0xBC, 0x8F, 0x31, 0x46, 0x21, 0x44, 0x88, 0xD4, 0xED, + 0x65, 0x4A, 0xC9, 0x10, 0x31, 0x84, 0xE8, 0x06, 0xDB, 0x42, 0x32, 0x8D, + 0xBE, 0xBE, 0x59, 0x5D, 0xDF, 0xDC, 0x4A, 0x25, 0x38, 0xD7, 0x37, 0x37, + 0xCB, 0xAB, 0xEB, 0x9B, 0x53, 0xB6, 0xF8, 0xFA, 0xBB, 0x6F, 0x26, 0x32, + 0x34, 0xB1, 0x7E, 0xB3, 0xDD, 0x59, 0xE7, 0x95, 0xE0, 0x9B, 0x5D, 0xFB, + 0xE6, 0xD3, 0xC7, 0x55, 0x91, 0x3F, 0x7B, 0x71, 0x71, 0x34, 0x9F, 0x3E, + 0x3F, 0xBF, 0x50, 0x52, 0x4C, 0x27, 0x55, 0x59, 0xE4, 0x09, 0x93, 0x10, + 0xFC, 0xEC, 0x78, 0xC6, 0x69, 0x7E, 0xA8, 0x2A, 0x94, 0x12, 0x29, 0x41, + 0x66, 0xF4, 0x7A, 0xDB, 0x4C, 0xA7, 0xF5, 0xEB, 0x4F, 0xCE, 0x72, 0xA3, + 0xBD, 0xF7, 0x5F, 0xFB, 0xCA, 0x1B, 0x09, 0x52, 0x3B, 0x0C, 0xC1, 0x07, + 0x92, 0x84, 0x15, 0x9C, 0x31, 0x21, 0x85, 0x00, 0xE2, 0x73, 0x38, 0xEF, + 0x39, 0x17, 0x00, 0x29, 0x44, 0xA4, 0xD2, 0xDD, 0xF5, 0xCE, 0x5A, 0x5B, + 0x95, 0xA5, 0x94, 0x4A, 0x08, 0xF1, 0xF0, 0xC1, 0xC9, 0xAB, 0xCB, 0xEB, + 0xD5, 0x66, 0xCB, 0xB8, 0x28, 0xAB, 0x54, 0x55, 0x65, 0xD7, 0xF5, 0x4A, + 0xA9, 0x61, 0xB0, 0x4A, 0xC9, 0x22, 0xCF, 0xB9, 0x10, 0xD6, 0x5A, 0xF2, + 0x58, 0x2B, 0x4B, 0x35, 0x0C, 0x16, 0x18, 0x10, 0x5B, 0x93, 0x01, 0x84, + 0xE0, 0x19, 0xE3, 0x09, 0x13, 0x40, 0xCA, 0x8C, 0xC9, 0xB3, 0xCC, 0x79, + 0x7F, 0x7C, 0x7C, 0x44, 0x64, 0x14, 0xAD, 0x44, 0x3F, 0x0C, 0xC6, 0xE8, + 0xAA, 0xCA, 0x5F, 0x5E, 0x8C, 0x02, 0xB3, 0xDF, 0xF9, 0xD6, 0x57, 0x9F, + 0x3C, 0x3A, 0x79, 0xFC, 0xF0, 0x94, 0x50, 0xFF, 0x9F, 0xFE, 0xEC, 0xA3, + 0x4F, 0x9F, 0x9D, 0x1F, 0xCD, 0xEA, 0xAE, 0xEF, 0x7F, 0xF0, 0xC3, 0x9F, + 0x90, 0x16, 0xD3, 0xA9, 0x56, 0xAF, 0x2E, 0xAF, 0xBD, 0xB3, 0x00, 0x38, + 0xAD, 0x0A, 0xCE, 0x40, 0x70, 0xA8, 0xAB, 0x22, 0x37, 0xB2, 0x7A, 0x78, + 0x32, 0x2A, 0xD3, 0x42, 0x29, 0x18, 0x54, 0x55, 0x89, 0x11, 0xDB, 0xBE, + 0x57, 0x4A, 0x69, 0xA5, 0xA4, 0x52, 0x42, 0xEE, 0x52, 0x82, 0x93, 0xC5, + 0x11, 0xE3, 0x00, 0x29, 0x09, 0x00, 0x2D, 0xF8, 0xD1, 0x6C, 0xCA, 0x19, + 0xD3, 0x5A, 0x2A, 0x29, 0x49, 0x01, 0x8C, 0x74, 0x76, 0x38, 0x67, 0xA3, + 0xE6, 0xE4, 0x3E, 0x30, 0x7D, 0x31, 0x7E, 0xDD, 0x25, 0x0A, 0xEC, 0x8B, + 0x1A, 0x14, 0x69, 0x24, 0xAE, 0xB2, 0x7B, 0x7D, 0x3E, 0x20, 0xA6, 0x34, + 0x81, 0x76, 0x11, 0x00, 0x48, 0x71, 0x90, 0xED, 0x29, 0x73, 0x30, 0xEA, + 0x4D, 0x0B, 0xCE, 0x89, 0x12, 0x0C, 0x94, 0x43, 0x06, 0x8E, 0x55, 0x25, + 0xBB, 0xDE, 0x21, 0x26, 0x63, 0xA4, 0x96, 0x32, 0x22, 0x7A, 0x1F, 0xAC, + 0x0D, 0x88, 0x58, 0x15, 0x46, 0x08, 0xFE, 0xD5, 0xB7, 0x1F, 0x9F, 0x9C, + 0x2C, 0x10, 0x81, 0x01, 0x24, 0xC6, 0x6C, 0xD7, 0x2E, 0x97, 0xEB, 0xB6, + 0xEB, 0x19, 0x03, 0xAD, 0x95, 0x73, 0xDE, 0xF0, 0x9C, 0x01, 0x19, 0x67, + 0x40, 0x42, 0xDC, 0x77, 0x24, 0xC7, 0x7C, 0x8A, 0x01, 0xE0, 0xDE, 0x6E, + 0x52, 0x48, 0xC9, 0x01, 0x80, 0x8B, 0x04, 0x00, 0x88, 0xD1, 0xFB, 0xFD, + 0xA8, 0x1B, 0xE7, 0x42, 0x8E, 0x80, 0x17, 0xDB, 0xE7, 0x6E, 0x5F, 0xCA, + 0x92, 0x20, 0x41, 0x62, 0x69, 0x6F, 0xF5, 0x78, 0xEF, 0x72, 0x8C, 0xA4, + 0x4A, 0x8C, 0xFE, 0x57, 0x1F, 0x7D, 0xDC, 0xB6, 0x83, 0x94, 0x32, 0xC6, + 0x14, 0x31, 0x61, 0x4A, 0xA3, 0x82, 0xDE, 0x3E, 0xEC, 0x8F, 0x12, 0x47, + 0x08, 0x94, 0x67, 0x51, 0xBA, 0x45, 0x8D, 0x98, 0x7D, 0x14, 0x63, 0xD4, + 0x9F, 0xC0, 0x71, 0x06, 0x6E, 0x04, 0x2F, 0x77, 0x4D, 0x77, 0x7E, 0x71, + 0x75, 0x79, 0xBD, 0xEC, 0xFA, 0x61, 0x32, 0x9D, 0x64, 0x59, 0x56, 0x95, + 0x85, 0xC9, 0xCD, 0xE5, 0xD5, 0xED, 0x6C, 0x5A, 0x57, 0x55, 0xA9, 0x8D, + 0xBE, 0xBC, 0xBA, 0xBD, 0xBA, 0x5D, 0xDD, 0xDC, 0xAE, 0x16, 0xF3, 0xD9, + 0x37, 0xBF, 0xF6, 0xD6, 0xB3, 0xE7, 0x2F, 0x3F, 0xFC, 0xF0, 0xD3, 0xE5, + 0x72, 0x3B, 0x99, 0x54, 0xD0, 0x30, 0xE7, 0x3C, 0xA9, 0x17, 0x24, 0x00, + 0xA3, 0x75, 0x82, 0x11, 0xCE, 0xF7, 0x21, 0x6C, 0x77, 0x8D, 0x94, 0x52, + 0x4A, 0xC1, 0xB9, 0x4A, 0x90, 0xFA, 0xC1, 0xB5, 0x5D, 0xDF, 0xF5, 0xBD, + 0x96, 0x8A, 0x08, 0x3E, 0xD6, 0x3A, 0x94, 0xD2, 0xF9, 0x40, 0x96, 0x42, + 0x98, 0x30, 0x21, 0x2A, 0x21, 0x07, 0x6F, 0x49, 0x0E, 0x84, 0xB8, 0x6E, + 0x31, 0xA2, 0x1C, 0xE5, 0x27, 0x29, 0xF0, 0x83, 0x10, 0x3C, 0xD3, 0x7A, + 0xE8, 0x07, 0x96, 0x20, 0x21, 0xB6, 0xDD, 0x80, 0x88, 0xB3, 0xAA, 0x5C, + 0x2C, 0xE6, 0xF3, 0xA3, 0xE9, 0x66, 0xBD, 0xC5, 0x18, 0xA9, 0x7D, 0x2E, + 0xA4, 0x64, 0x31, 0x7A, 0x1F, 0x74, 0x5D, 0x14, 0x45, 0xD6, 0x36, 0x7D, + 0x88, 0x31, 0xC6, 0xE4, 0xBC, 0x53, 0x4A, 0x09, 0xC1, 0x04, 0x63, 0x47, + 0xB3, 0x9A, 0xA5, 0x34, 0x8A, 0xE8, 0x8B, 0xA4, 0x94, 0x9A, 0x1B, 0xC3, + 0x85, 0x78, 0xF2, 0xE8, 0x6C, 0xB5, 0xDE, 0x6E, 0x77, 0x3B, 0xA3, 0x95, + 0xB5, 0x3E, 0xCF, 0x4D, 0x9E, 0x19, 0x6B, 0xF4, 0xAE, 0x69, 0x31, 0xE2, + 0x8B, 0x97, 0x17, 0x75, 0x55, 0xCE, 0xA6, 0x93, 0x3C, 0xCF, 0xCF, 0x2F, + 0xAE, 0x57, 0xEB, 0x2D, 0x91, 0xBF, 0xBB, 0xAE, 0xAF, 0xEB, 0x32, 0xA5, + 0x24, 0x38, 0x07, 0x01, 0x82, 0xF3, 0xD3, 0xD3, 0x93, 0x2C, 0x33, 0xAB, + 0xF5, 0xD6, 0xF9, 0xF0, 0xC6, 0xEB, 0x8F, 0x27, 0x93, 0xEA, 0x79, 0x99, + 0xDF, 0xDC, 0xAE, 0x2F, 0x2F, 0x6F, 0x94, 0x10, 0xDF, 0xFE, 0xD6, 0x57, + 0xDF, 0xFF, 0xF9, 0xAF, 0x9A, 0xB6, 0xAD, 0xEA, 0x92, 0x33, 0x1E, 0xBC, + 0x23, 0xA4, 0xD9, 0x79, 0xFF, 0xE6, 0xD3, 0xC7, 0xB7, 0xCB, 0x35, 0x46, + 0x94, 0x42, 0x4C, 0xEB, 0xAA, 0xAE, 0xCB, 0xDC, 0xE8, 0x14, 0x71, 0x36, + 0xA9, 0xC8, 0x3B, 0xA3, 0x2C, 0xF2, 0x3C, 0x37, 0x55, 0x59, 0x9E, 0x1C, + 0xCF, 0x77, 0x6D, 0xF7, 0xDE, 0xD7, 0xDF, 0x21, 0x41, 0xB1, 0xDF, 0xFE, + 0xEE, 0x37, 0x67, 0x93, 0xF2, 0x7F, 0xFB, 0x8F, 0x7F, 0x4E, 0x1B, 0x67, + 0x8C, 0xD1, 0x39, 0x87, 0x48, 0x77, 0x07, 0x57, 0x52, 0x02, 0x00, 0x67, + 0x2C, 0xCF, 0x34, 0x62, 0xB2, 0xDE, 0x73, 0xC1, 0x87, 0xC1, 0xB6, 0x6D, + 0xDF, 0xB6, 0x7D, 0x88, 0x89, 0x0B, 0xBE, 0x5C, 0x6D, 0x7E, 0xEB, 0x37, + 0xBE, 0xE5, 0xAC, 0xBF, 0xBC, 0xBA, 0x15, 0x12, 0xAE, 0xAE, 0x6F, 0x01, + 0xA0, 0xAE, 0x4B, 0x8A, 0x56, 0x42, 0x70, 0x1F, 0xC2, 0xD3, 0x47, 0xA7, + 0xB7, 0x4A, 0xDC, 0xDC, 0xAC, 0x84, 0xE0, 0x7D, 0xDF, 0x93, 0xB6, 0xC3, + 0x6A, 0x9D, 0xD4, 0xF8, 0xA5, 0xF3, 0x94, 0x12, 0xD5, 0x0A, 0x93, 0xAA, + 0x3C, 0xBF, 0x78, 0xF5, 0xDA, 0xE3, 0x07, 0xEF, 0xBC, 0xF9, 0x78, 0xBB, + 0x6D, 0xCA, 0xB2, 0x1C, 0x86, 0xE1, 0xF2, 0xEA, 0xF6, 0xAD, 0xA7, 0x8F, + 0x1F, 0x3E, 0x58, 0x9C, 0x9F, 0xBF, 0x3A, 0x2D, 0x8F, 0x9E, 0x3E, 0x39, + 0xFB, 0xBD, 0x7F, 0xFA, 0x1E, 0x22, 0x6E, 0xB6, 0x0D, 0x00, 0x34, 0x6D, + 0xF7, 0xB3, 0x0F, 0x3E, 0x7A, 0xF2, 0xE4, 0x61, 0xDB, 0xF4, 0xFF, 0xE9, + 0x3F, 0x7F, 0x1F, 0x83, 0x9F, 0xD4, 0x15, 0x17, 0xD2, 0xF7, 0x7D, 0x5D, + 0x16, 0xF3, 0xF9, 0x9C, 0xEC, 0xB8, 0x8A, 0x3C, 0xCB, 0xB3, 0x45, 0x55, + 0x64, 0x79, 0x6E, 0x48, 0xDC, 0x78, 0xB0, 0xB6, 0xEB, 0x87, 0xC9, 0x64, + 0xF2, 0xF4, 0xB5, 0x07, 0x0C, 0xA0, 0x1F, 0x2C, 0x62, 0x6A, 0xBA, 0xCE, + 0x18, 0x7D, 0x74, 0x34, 0xE3, 0x5C, 0xD4, 0x55, 0xD1, 0xB6, 0x9D, 0xF7, + 0x9E, 0x33, 0xA8, 0xCA, 0xCC, 0x3B, 0x37, 0x5D, 0x4C, 0xB5, 0x92, 0x52, + 0x72, 0x21, 0xF6, 0x6E, 0x06, 0x30, 0xC2, 0xE0, 0x8C, 0xDF, 0x51, 0x0E, + 0xEE, 0xB7, 0xF2, 0x18, 0x00, 0xC2, 0x1E, 0x76, 0x1A, 0x75, 0x79, 0x69, + 0xF8, 0x1B, 0xF7, 0x21, 0x8F, 0x56, 0xF1, 0x1D, 0x24, 0x2D, 0x71, 0xD4, + 0x11, 0x97, 0xCA, 0x18, 0xA9, 0x34, 0x83, 0x3B, 0x85, 0x89, 0x94, 0x12, + 0x4B, 0x80, 0xD1, 0x3B, 0x6B, 0xF9, 0xDE, 0xE7, 0x02, 0x20, 0x71, 0xC6, + 0x10, 0x71, 0x36, 0xC9, 0x9D, 0x8F, 0x5D, 0x6F, 0x31, 0xE2, 0x76, 0xD7, + 0x5B, 0x17, 0x8C, 0x96, 0x52, 0xA8, 0xAA, 0xCA, 0x8D, 0x14, 0xB3, 0xF9, + 0x8C, 0x49, 0x45, 0x4D, 0xA5, 0x14, 0xB1, 0x69, 0x5A, 0xA5, 0xC4, 0xC3, + 0x87, 0x67, 0x7B, 0xD3, 0x84, 0x71, 0x54, 0x2D, 0x21, 0x1D, 0x0B, 0x42, + 0x02, 0xCE, 0x05, 0xF9, 0xE5, 0x1C, 0xE2, 0x2E, 0x4B, 0x80, 0x18, 0x63, + 0x00, 0x46, 0xC3, 0x93, 0x29, 0xB1, 0x84, 0xDE, 0x3B, 0x44, 0xA4, 0xB8, + 0x95, 0xE5, 0x39, 0x62, 0x12, 0x42, 0x70, 0x21, 0x81, 0x8B, 0x3D, 0xDC, + 0x76, 0x47, 0xAA, 0x18, 0x8B, 0xE9, 0x2F, 0xA7, 0x62, 0x89, 0x38, 0xE5, + 0xB6, 0x6F, 0x3F, 0xFA, 0xF0, 0x63, 0x12, 0x03, 0x88, 0x81, 0xF4, 0x35, + 0x00, 0x71, 0xC4, 0x19, 0x19, 0x63, 0x87, 0x37, 0x24, 0xD6, 0x28, 0x7D, + 0xEA, 0x28, 0xD0, 0xAA, 0x7F, 0x6D, 0x9E, 0x74, 0x9C, 0x4F, 0x62, 0x0C, + 0x20, 0xC6, 0x78, 0x73, 0xBB, 0x59, 0xAD, 0xB7, 0xAB, 0xD5, 0xB6, 0x2A, + 0x8A, 0xB7, 0xDE, 0x7C, 0x1D, 0x81, 0x69, 0xA3, 0x13, 0xA6, 0xD5, 0x6A, + 0x3B, 0x9B, 0xD6, 0x5A, 0xEB, 0x67, 0xCF, 0x5F, 0x5A, 0xE7, 0xCF, 0x2F, + 0x2E, 0x3F, 0xF9, 0xE4, 0xF9, 0x72, 0xB5, 0xF9, 0xEF, 0xFF, 0xDB, 0x7F, + 0xDE, 0x34, 0xDD, 0x7F, 0xFA, 0xD3, 0x3F, 0xE7, 0x8C, 0x4F, 0xA6, 0x35, + 0x97, 0x12, 0x31, 0x31, 0xCE, 0xD0, 0xD3, 0x62, 0x10, 0x5A, 0xAB, 0x4D, + 0xD3, 0xE0, 0xE8, 0x5D, 0xC6, 0xB4, 0xD6, 0x52, 0x0A, 0x2A, 0x4F, 0x9A, + 0xBE, 0x0F, 0x31, 0xD1, 0x0C, 0x53, 0x0C, 0x41, 0x70, 0x1E, 0x3D, 0x1A, + 0xAD, 0x87, 0xC1, 0xC6, 0x18, 0x75, 0x91, 0x63, 0xC4, 0x10, 0x82, 0x0B, + 0x5E, 0x70, 0xC1, 0x18, 0x17, 0x02, 0x68, 0xEB, 0x62, 0x0C, 0xB4, 0x96, + 0x18, 0x91, 0x31, 0x36, 0x1A, 0xA3, 0x71, 0xCE, 0x38, 0x1B, 0xAC, 0x55, + 0x42, 0x84, 0x88, 0xDB, 0xA6, 0xED, 0x06, 0x5B, 0xE5, 0xC6, 0x48, 0x15, + 0x43, 0xE0, 0x0C, 0xB4, 0x96, 0x34, 0xF4, 0x4B, 0x83, 0xAC, 0x09, 0x51, + 0x70, 0xF0, 0x3E, 0xAC, 0x57, 0x3B, 0x22, 0xAA, 0xB7, 0xC3, 0xE0, 0xBD, + 0x3F, 0x3B, 0x5E, 0x30, 0x80, 0xED, 0x6E, 0x17, 0xD6, 0x71, 0xD7, 0xB4, + 0x67, 0x67, 0x8B, 0xD3, 0x93, 0xA3, 0x18, 0x35, 0x1D, 0x36, 0x8F, 0x91, + 0xB0, 0x8E, 0x61, 0xB0, 0x74, 0x8D, 0xFB, 0x01, 0x68, 0xE5, 0xDC, 0x2E, + 0xD7, 0x3E, 0x84, 0xE3, 0xC5, 0xC2, 0x3A, 0x1F, 0xA3, 0x37, 0x59, 0xF6, + 0xFA, 0x93, 0x87, 0x93, 0xAA, 0xBC, 0xB8, 0xBC, 0x79, 0xF8, 0xE0, 0x94, + 0xE8, 0xA3, 0x6D, 0xD7, 0xED, 0x0D, 0xB7, 0xA0, 0xAA, 0xCA, 0xDB, 0xD5, + 0x26, 0xC6, 0xAD, 0xD6, 0xEA, 0xB3, 0x67, 0x2F, 0xF3, 0x4C, 0x3F, 0x7E, + 0x74, 0xB6, 0x58, 0xCC, 0x3E, 0xF9, 0xF4, 0x85, 0x52, 0x22, 0x33, 0xEA, + 0xEB, 0xEF, 0xBE, 0xD9, 0x5B, 0xF7, 0xFC, 0xC5, 0xAB, 0xA6, 0xEB, 0x8E, + 0x66, 0x93, 0xBA, 0xAE, 0x2E, 0xAF, 0x6E, 0xEA, 0xA2, 0x10, 0x9C, 0xCF, + 0x67, 0x93, 0xD5, 0x7A, 0x1B, 0x63, 0x9C, 0x4F, 0xAB, 0x3C, 0x33, 0x31, + 0x46, 0x1F, 0xA3, 0x60, 0xAC, 0xAA, 0x72, 0xA5, 0x84, 0x56, 0xCA, 0x68, + 0xCD, 0x12, 0xBE, 0xFE, 0xE8, 0x74, 0x32, 0x29, 0x13, 0xB0, 0x18, 0x22, + 0x67, 0xEC, 0x74, 0x31, 0xBD, 0xBE, 0x5D, 0x5F, 0xDD, 0x2C, 0xA5, 0xD4, + 0x84, 0x8E, 0x01, 0xB0, 0xCC, 0x28, 0xEB, 0x02, 0xE5, 0x9B, 0x04, 0xD5, + 0x2B, 0x25, 0xFB, 0xAE, 0xD7, 0xAA, 0x54, 0x4A, 0x3A, 0xE7, 0xE9, 0x68, + 0x63, 0x8C, 0x0F, 0xCE, 0x4E, 0x18, 0x17, 0x2F, 0x2E, 0x2E, 0x97, 0xAB, + 0x4D, 0x02, 0xF0, 0xDE, 0xD3, 0x58, 0x42, 0xDF, 0x5B, 0x82, 0x85, 0x42, + 0x88, 0x88, 0xFE, 0x67, 0x1F, 0x7C, 0x38, 0x9F, 0xCD, 0x4D, 0x66, 0x82, + 0xF7, 0x52, 0x4A, 0xAD, 0x64, 0xDB, 0xF5, 0xCE, 0x7B, 0xD0, 0x63, 0x25, + 0x11, 0x63, 0x34, 0xC6, 0x70, 0xCE, 0xAF, 0xAE, 0x6F, 0xDF, 0x7E, 0xF3, + 0xB5, 0xEF, 0x7E, 0xE7, 0xEB, 0x00, 0xE9, 0xC9, 0xC3, 0x13, 0x6D, 0x74, + 0x6E, 0x8C, 0xD1, 0x8A, 0x9A, 0x03, 0xFF, 0xE3, 0xBF, 0xFD, 0x6F, 0xB4, + 0x92, 0x4A, 0xAB, 0xBE, 0x1F, 0xDA, 0xB6, 0x07, 0x80, 0x3C, 0xCF, 0x2E, + 0x5E, 0x5D, 0xC5, 0x88, 0x57, 0xD7, 0xCB, 0x97, 0x2F, 0xAF, 0x62, 0x0C, + 0xB9, 0x56, 0xD3, 0x69, 0xDD, 0xF6, 0x76, 0xB7, 0xDB, 0x29, 0xA9, 0x62, + 0x0C, 0xCE, 0xF9, 0xAA, 0x2C, 0x1E, 0x9E, 0x2E, 0x94, 0x92, 0x93, 0xBA, + 0xD4, 0x5A, 0xDF, 0xDC, 0xAE, 0xBA, 0x6E, 0x60, 0x00, 0xC7, 0xF3, 0x49, + 0x96, 0x99, 0x3C, 0xCB, 0xAA, 0x32, 0x57, 0x4A, 0x22, 0xE2, 0xED, 0x72, + 0xBD, 0x5A, 0xEF, 0x4C, 0x66, 0xC8, 0x37, 0x1A, 0x8F, 0xA6, 0x9B, 0xED, + 0x4E, 0x4A, 0x71, 0x34, 0x9B, 0x4C, 0xEA, 0xA2, 0xCC, 0xB3, 0x2C, 0x53, + 0xEA, 0x9E, 0xDD, 0x17, 0xE3, 0x8C, 0x33, 0xBE, 0x47, 0xF9, 0xBF, 0x34, + 0x6A, 0x7D, 0x87, 0x31, 0xEF, 0xC9, 0xF1, 0x90, 0x52, 0x82, 0x3B, 0x91, + 0xAB, 0xBB, 0x97, 0xDC, 0x4F, 0xE2, 0xC4, 0xFF, 0xFA, 0x27, 0x7F, 0x4C, + 0x52, 0x93, 0xDA, 0x64, 0x00, 0x00, 0x38, 0xCA, 0x4E, 0x8C, 0x1C, 0x8F, + 0x18, 0x86, 0xBE, 0x5B, 0x6F, 0x76, 0x5D, 0xEF, 0x62, 0x8C, 0x81, 0xC0, + 0xE4, 0xBB, 0x88, 0x98, 0x88, 0xD8, 0xE2, 0x7C, 0x80, 0x44, 0xF2, 0xBB, + 0xAC, 0xEB, 0x6D, 0x55, 0x66, 0x47, 0xF3, 0x49, 0x0C, 0x91, 0x01, 0x46, + 0x67, 0x09, 0xB6, 0xAC, 0x27, 0x93, 0xA2, 0x28, 0x12, 0xA2, 0x73, 0x96, + 0x4B, 0x21, 0xB8, 0xF0, 0x43, 0x8F, 0x31, 0x46, 0x0C, 0xC4, 0xC0, 0x20, + 0x80, 0x09, 0x63, 0xD8, 0x47, 0x22, 0x8A, 0xC6, 0x49, 0x2A, 0xC5, 0xF8, + 0xBE, 0x29, 0xC8, 0x98, 0xB3, 0x43, 0x08, 0xA3, 0x4D, 0x4C, 0xF0, 0xDE, + 0x39, 0xEB, 0x9D, 0x03, 0x40, 0xCE, 0xF6, 0x13, 0x4B, 0x69, 0xBC, 0x22, + 0x63, 0xA4, 0xBF, 0x23, 0x5B, 0xD0, 0xA9, 0x8F, 0x93, 0x31, 0xCB, 0xDB, + 0x9B, 0x8F, 0x7E, 0xF1, 0xE1, 0xAE, 0x19, 0xC8, 0x92, 0x1E, 0xC7, 0x9E, + 0x23, 0x60, 0x4A, 0x71, 0x0F, 0x83, 0x51, 0x94, 0xA7, 0xB3, 0x0E, 0x09, + 0x91, 0xC4, 0x84, 0x30, 0x71, 0xCE, 0x8C, 0x91, 0x52, 0x8E, 0x23, 0xC4, + 0x89, 0xC4, 0x94, 0xC7, 0x89, 0xF1, 0x84, 0x11, 0xDB, 0xDE, 0x6E, 0xB6, + 0xCD, 0xD5, 0xF5, 0x52, 0x48, 0xF9, 0xF4, 0xF5, 0x47, 0x8B, 0xC5, 0x9C, + 0xBC, 0xD7, 0x76, 0x4D, 0xB7, 0x5C, 0xAE, 0xAF, 0xAF, 0x6F, 0x7F, 0xF8, + 0xA3, 0x9F, 0x7D, 0xFC, 0xE9, 0xF3, 0x8B, 0x8B, 0xCB, 0xF3, 0xF3, 0xCB, + 0xB6, 0xED, 0xBE, 0xFD, 0xAD, 0x77, 0xEB, 0xAA, 0xFC, 0x7F, 0xFF, 0xCB, + 0x8F, 0x94, 0x90, 0x98, 0x52, 0xD3, 0x75, 0xD6, 0x39, 0xDA, 0xA6, 0x30, + 0x21, 0x03, 0xAE, 0xA4, 0x22, 0xDD, 0x2B, 0xC1, 0x45, 0x9E, 0x1B, 0x25, + 0xC9, 0x93, 0x80, 0xC7, 0x88, 0xDD, 0x30, 0x00, 0xE3, 0xB9, 0x31, 0xB9, + 0x56, 0x64, 0x40, 0x0B, 0x00, 0x4A, 0x08, 0xAD, 0xA5, 0x10, 0x42, 0x2B, + 0x05, 0x64, 0xC0, 0x0E, 0xE3, 0x45, 0x8E, 0x11, 0x19, 0x27, 0x8D, 0x36, + 0x48, 0xC0, 0x48, 0xDA, 0x3E, 0xC6, 0x98, 0x19, 0x4D, 0x0E, 0xDB, 0xE3, + 0x9B, 0x0B, 0xBE, 0x6D, 0xBB, 0xC1, 0x7A, 0x44, 0xD4, 0x52, 0xD0, 0xF0, + 0xB3, 0x54, 0x6A, 0xBD, 0xDA, 0x38, 0xE7, 0x00, 0x40, 0x70, 0x11, 0x31, + 0x86, 0x88, 0x9C, 0xF3, 0x3C, 0xCB, 0x72, 0x92, 0xCF, 0x1F, 0x2C, 0xC6, + 0x18, 0x53, 0xCA, 0xB4, 0x62, 0x29, 0xF9, 0x10, 0xB4, 0xD6, 0x44, 0xE6, + 0xCA, 0x0B, 0x03, 0x7B, 0xF8, 0x96, 0xB8, 0x02, 0x75, 0x55, 0x68, 0xA5, + 0xD6, 0x9B, 0x1D, 0x62, 0x2A, 0x8B, 0x7C, 0xBD, 0xDD, 0x11, 0x33, 0xA0, + 0xEF, 0xED, 0xED, 0x72, 0xB5, 0x5C, 0xAE, 0xBC, 0x0F, 0x7B, 0x50, 0x1F, + 0xB5, 0x94, 0xF5, 0xA4, 0xAC, 0xCA, 0x62, 0x18, 0xAC, 0x0F, 0xDE, 0x18, + 0x43, 0x24, 0xB2, 0x5D, 0xD3, 0x84, 0x10, 0x8F, 0x8E, 0x66, 0xBB, 0xA6, + 0x59, 0xAF, 0x37, 0x59, 0x96, 0x6D, 0xB7, 0xBB, 0x27, 0x8F, 0x4E, 0xAD, + 0x73, 0x44, 0x25, 0xD7, 0x52, 0x3E, 0x3C, 0x5B, 0x3C, 0x7A, 0x78, 0x42, + 0xAF, 0x7D, 0xED, 0xF1, 0x03, 0x96, 0x80, 0x0B, 0xCE, 0x19, 0x23, 0x79, + 0x52, 0x8C, 0xA9, 0x2C, 0x33, 0xE7, 0x3C, 0x8C, 0x32, 0x3B, 0x61, 0x36, + 0xAD, 0xCB, 0x22, 0xA7, 0x5B, 0x5A, 0x48, 0x7E, 0xBC, 0x98, 0xD3, 0x4C, + 0x1E, 0x69, 0x3D, 0x2A, 0x25, 0x7F, 0xFA, 0xC1, 0xC7, 0x9F, 0x3F, 0xBF, + 0x32, 0x46, 0xC7, 0x18, 0xCF, 0x4E, 0x8F, 0x7E, 0xEF, 0xB7, 0x7F, 0xB3, + 0x6D, 0xFB, 0xAB, 0xDB, 0xA5, 0xE0, 0x22, 0xCF, 0x8C, 0x0F, 0x81, 0xDC, + 0xC2, 0xA9, 0x5F, 0x14, 0x7C, 0xBC, 0xB8, 0xBA, 0xCD, 0x8D, 0x8A, 0x21, + 0x3E, 0x7D, 0xFD, 0xF1, 0xEF, 0xFE, 0x93, 0xEF, 0xA4, 0x94, 0x96, 0xCB, + 0xED, 0x72, 0xB5, 0xA6, 0xF2, 0x50, 0x69, 0x29, 0x38, 0xA7, 0x56, 0xAC, + 0x14, 0x64, 0x37, 0x19, 0xB5, 0x56, 0x21, 0xC4, 0x84, 0x18, 0x63, 0x30, + 0x46, 0x87, 0x88, 0x00, 0x40, 0x49, 0x0D, 0x35, 0xDF, 0xA9, 0x2F, 0x17, + 0x42, 0xFC, 0x8D, 0xF7, 0xDE, 0x7D, 0xEB, 0x8D, 0x27, 0x7F, 0xFE, 0xFD, + 0x1F, 0xFC, 0xF2, 0xA3, 0xCF, 0xDA, 0xAE, 0x9F, 0x4E, 0xAA, 0xD9, 0xB4, + 0x26, 0xD7, 0x67, 0x4C, 0x78, 0x7E, 0x71, 0xCD, 0x39, 0x83, 0x94, 0xAE, + 0x6E, 0xD6, 0x34, 0xA9, 0xEE, 0x9C, 0xFB, 0x8B, 0xBF, 0xFE, 0x61, 0x4A, + 0x69, 0x18, 0x06, 0x02, 0x46, 0xAB, 0x22, 0x1B, 0x06, 0x7B, 0x79, 0xB3, + 0x64, 0x8C, 0x67, 0x46, 0xE7, 0x79, 0xA1, 0xA4, 0x78, 0x74, 0x76, 0x9C, + 0x19, 0x65, 0xB4, 0x2E, 0x8B, 0x42, 0x4A, 0x61, 0xB4, 0x52, 0x5A, 0x55, + 0x65, 0x3E, 0x9F, 0x4E, 0xA4, 0xE4, 0x09, 0xD2, 0xA4, 0x2E, 0xAB, 0xDC, + 0x4C, 0xAA, 0x62, 0x52, 0x97, 0x65, 0x59, 0x2C, 0xE6, 0xD3, 0x49, 0x5D, + 0xE6, 0x99, 0x01, 0x60, 0x46, 0xAB, 0xA3, 0xF9, 0x74, 0x3A, 0xA9, 0x66, + 0x93, 0x2A, 0xCF, 0x0C, 0x69, 0x4C, 0x72, 0x31, 0x3E, 0xF6, 0x20, 0xD7, + 0x7D, 0x9A, 0xC1, 0xAF, 0xA5, 0x04, 0xE9, 0x7E, 0xB2, 0x76, 0x58, 0xBE, + 0xF7, 0x7F, 0xA6, 0xFB, 0x41, 0x50, 0x6A, 0xA5, 0x94, 0xD6, 0x9C, 0x73, + 0x8C, 0x01, 0x12, 0x22, 0x26, 0x86, 0x28, 0xA4, 0x60, 0xC0, 0x13, 0x62, + 0xF0, 0xBE, 0xEF, 0xFA, 0x94, 0x50, 0x29, 0xD1, 0x0F, 0x2E, 0xC4, 0x18, + 0x28, 0xCB, 0x42, 0xEC, 0x7A, 0xAB, 0x95, 0x90, 0x52, 0x90, 0x66, 0x08, + 0x00, 0x20, 0x26, 0xE7, 0x2C, 0x15, 0x82, 0xAF, 0x5E, 0x5D, 0x51, 0x33, + 0x1E, 0x18, 0x54, 0x75, 0x0D, 0x00, 0x18, 0x63, 0x67, 0xED, 0x30, 0xF4, + 0xDE, 0x07, 0x36, 0x58, 0xA5, 0x2C, 0x21, 0x58, 0x42, 0xCA, 0xCC, 0x64, + 0x77, 0xF9, 0x22, 0x63, 0x18, 0x43, 0x4A, 0xA8, 0xB4, 0x66, 0x5C, 0x28, + 0xB6, 0xD7, 0xA1, 0x05, 0x48, 0x88, 0x11, 0xA3, 0x90, 0x12, 0x00, 0xD6, + 0xEB, 0x2D, 0xCD, 0xD0, 0xFB, 0xE0, 0x13, 0x26, 0xE7, 0x5D, 0x96, 0x79, + 0x3D, 0x5A, 0xA2, 0x24, 0x0A, 0xE1, 0x52, 0x2A, 0x90, 0x8A, 0xED, 0xA5, + 0x25, 0x18, 0x63, 0x31, 0x84, 0x84, 0xA8, 0x94, 0x3C, 0x7F, 0xFE, 0xFC, + 0xD9, 0x67, 0xCF, 0x38, 0x57, 0x82, 0x31, 0x67, 0x9D, 0xD4, 0x19, 0x63, + 0x40, 0x9E, 0x97, 0x87, 0xC0, 0x9F, 0xC6, 0x3E, 0x25, 0x44, 0xC4, 0x80, + 0x98, 0x30, 0xF1, 0xD1, 0x93, 0x25, 0x31, 0xC6, 0xE5, 0x88, 0x21, 0xC2, + 0x88, 0x8B, 0x25, 0x42, 0xF6, 0x40, 0x0A, 0x91, 0x38, 0x20, 0x26, 0xA5, + 0xD5, 0xD1, 0xE2, 0x28, 0xCB, 0xB2, 0x80, 0xE9, 0xD9, 0xF9, 0x95, 0xF7, + 0x61, 0xB0, 0xEE, 0x93, 0x4F, 0x9F, 0x7F, 0xF8, 0xD1, 0xA7, 0xCE, 0xB9, + 0xBC, 0xC8, 0x5F, 0x7F, 0xF2, 0xD8, 0x5A, 0xB7, 0x5C, 0x6D, 0xDE, 0x7D, + 0xF7, 0xED, 0xC9, 0xA4, 0xFE, 0xE1, 0xDF, 0xFF, 0x4C, 0x08, 0x6E, 0x8A, + 0xBC, 0x77, 0xCE, 0x3A, 0x1F, 0xFA, 0x61, 0x3A, 0x99, 0x08, 0xCE, 0x15, + 0x68, 0x60, 0x9E, 0xF4, 0xAA, 0xCA, 0x22, 0xCF, 0x33, 0xC3, 0x00, 0xBA, + 0xBE, 0x27, 0xCB, 0x48, 0x25, 0xE5, 0xA4, 0xAA, 0x22, 0xC6, 0x94, 0xC0, + 0xFB, 0x30, 0x58, 0x2B, 0x84, 0x90, 0x52, 0x90, 0xB0, 0x92, 0x10, 0x40, + 0x53, 0xEB, 0x8C, 0x70, 0x55, 0x96, 0x22, 0x26, 0x60, 0x40, 0x01, 0x97, + 0xE4, 0xBD, 0xA4, 0xE4, 0x5A, 0xE9, 0x94, 0x52, 0x0C, 0x91, 0xB8, 0xCA, + 0x54, 0xC9, 0xAE, 0xB6, 0xBB, 0x88, 0x68, 0xB4, 0x11, 0x9C, 0x51, 0x8B, + 0x8D, 0x09, 0xBE, 0xDB, 0x36, 0x43, 0x6F, 0x09, 0xA6, 0x19, 0x35, 0x8B, + 0xC0, 0x4B, 0x29, 0xCB, 0x32, 0x77, 0xCE, 0x0F, 0xD6, 0x69, 0xA9, 0x22, + 0x46, 0x06, 0xB0, 0xDD, 0x36, 0xE5, 0xE9, 0xF1, 0xC9, 0xC9, 0xB1, 0x14, + 0xBC, 0xEB, 0x86, 0xF3, 0x8B, 0xCB, 0xC5, 0x62, 0x3A, 0xAD, 0x2B, 0xCE, + 0xD9, 0x30, 0x38, 0x6B, 0xDD, 0xD1, 0xD1, 0xCC, 0xFB, 0xE0, 0x9C, 0x27, + 0x54, 0x7B, 0xB7, 0x6B, 0x32, 0xA3, 0x9B, 0xA6, 0xCB, 0x32, 0x7D, 0x7A, + 0x72, 0x94, 0x67, 0xE6, 0x57, 0xBF, 0xFA, 0x4C, 0x70, 0x4E, 0x72, 0x48, + 0x92, 0xB3, 0xFA, 0x68, 0xBA, 0xD9, 0x35, 0x83, 0x73, 0xD3, 0xBA, 0xF4, + 0xDE, 0x87, 0xE0, 0xA7, 0x93, 0x89, 0xD1, 0xFA, 0xE5, 0xE5, 0xF5, 0xE2, + 0x68, 0xD6, 0xEC, 0x9A, 0xE0, 0xC3, 0x66, 0xDB, 0xBC, 0xF7, 0xCD, 0x77, + 0x9D, 0xB5, 0xCF, 0x9E, 0x5F, 0x94, 0x65, 0xD9, 0x76, 0xFD, 0x7A, 0xD3, + 0x00, 0x00, 0xE7, 0xEC, 0x68, 0x36, 0xA9, 0xCB, 0xE2, 0xDB, 0xDF, 0x78, + 0x87, 0x01, 0xBB, 0x5D, 0x6D, 0x7E, 0xF5, 0xC9, 0xB3, 0x94, 0x60, 0x3E, + 0x9F, 0xD0, 0x40, 0xE5, 0x66, 0xDB, 0x14, 0x53, 0xF2, 0x09, 0x00, 0x00, + 0x20, 0x00, 0x49, 0x44, 0x41, 0x54, 0x2A, 0x25, 0x73, 0x29, 0xCA, 0x32, + 0xEB, 0xBA, 0x84, 0x88, 0x52, 0x8A, 0xCC, 0x18, 0x2E, 0x98, 0x10, 0xE2, + 0x20, 0xBD, 0x4E, 0x85, 0x82, 0xB5, 0xFE, 0xF3, 0xE7, 0xAF, 0x10, 0xC3, + 0x76, 0xB7, 0x9B, 0xD4, 0xE5, 0x3F, 0xFD, 0xAD, 0x6F, 0x65, 0xC6, 0x38, + 0x1F, 0x48, 0x03, 0xDD, 0xEF, 0xFB, 0xFE, 0x24, 0x4B, 0xDE, 0xF7, 0x56, + 0x08, 0x9E, 0x67, 0x86, 0x84, 0x03, 0x4E, 0x8F, 0x17, 0x1F, 0x7D, 0xF2, + 0xEC, 0xC3, 0x8F, 0x3F, 0x9F, 0xD4, 0xE5, 0x7F, 0xF5, 0xBB, 0xDF, 0xFD, + 0x87, 0x9F, 0xFC, 0xFC, 0xE2, 0xD5, 0xB5, 0xE0, 0x1A, 0x31, 0x4A, 0xC1, + 0x09, 0xAB, 0xC1, 0x94, 0x42, 0x60, 0x21, 0xC4, 0x88, 0xBE, 0x2C, 0x72, + 0xCE, 0x4D, 0x0C, 0x18, 0x62, 0xA0, 0x79, 0x72, 0xE7, 0xBC, 0xC9, 0x4C, + 0x0C, 0x91, 0xD2, 0x9F, 0xEF, 0xFD, 0xD6, 0xB7, 0x16, 0x47, 0xB3, 0x1F, + 0xFD, 0xE4, 0x03, 0xE7, 0x9C, 0x31, 0x66, 0xBD, 0xDE, 0x7D, 0xF0, 0xC1, + 0xC7, 0x7D, 0x6F, 0x6F, 0x96, 0x9B, 0x07, 0xA7, 0x47, 0x0F, 0x4E, 0x8F, + 0xDB, 0xAE, 0x3F, 0x59, 0xCC, 0x6E, 0x57, 0x9B, 0xED, 0xAE, 0x39, 0x59, + 0xCC, 0x58, 0x4A, 0xEB, 0xCD, 0xAE, 0xEF, 0x06, 0xAD, 0x55, 0xDB, 0x05, + 0x21, 0x78, 0x95, 0x19, 0x06, 0x68, 0xAD, 0x07, 0x04, 0xA9, 0x39, 0x00, + 0x28, 0xC9, 0x8B, 0xBC, 0x64, 0x00, 0x75, 0x5D, 0xD6, 0x55, 0x49, 0x73, + 0xEF, 0x98, 0xD2, 0x22, 0x37, 0x5A, 0x8F, 0x16, 0x01, 0x21, 0xA2, 0xD1, + 0xD2, 0x64, 0x5A, 0x48, 0x51, 0x28, 0x91, 0xE7, 0x86, 0x00, 0x0D, 0x92, + 0x2D, 0x4A, 0x29, 0x19, 0x2D, 0x95, 0x14, 0x99, 0x31, 0x52, 0x0A, 0xC6, + 0x0E, 0x74, 0x83, 0x31, 0x72, 0x21, 0x7E, 0x81, 0xBE, 0xFE, 0x6B, 0xE8, + 0x18, 0xDB, 0x13, 0x2F, 0x12, 0x63, 0x77, 0x4F, 0x20, 0x8F, 0xD1, 0x2F, + 0xA1, 0x69, 0xF4, 0x4F, 0xA9, 0x0E, 0xB6, 0xB8, 0x00, 0x34, 0xE7, 0xC2, + 0x38, 0x4F, 0x09, 0x52, 0xF2, 0xDE, 0xB9, 0x10, 0x02, 0x75, 0x79, 0x89, + 0x58, 0x25, 0x18, 0x93, 0x5A, 0xD1, 0x8A, 0xA5, 0xB9, 0xE8, 0xB4, 0xB7, + 0x5C, 0x2C, 0x0B, 0x53, 0x15, 0xD9, 0xAE, 0xED, 0x95, 0x52, 0xCE, 0x85, + 0x61, 0x70, 0xD6, 0x7A, 0xEB, 0xBC, 0x92, 0xA2, 0x6B, 0x07, 0x12, 0xA4, + 0x26, 0x0F, 0x54, 0x9A, 0x3F, 0x27, 0xCE, 0x1A, 0x63, 0x4C, 0x4A, 0xC5, + 0x18, 0x4F, 0x88, 0x31, 0xA5, 0x18, 0x82, 0xF7, 0x0E, 0x23, 0x72, 0xC1, + 0x85, 0x94, 0x29, 0x10, 0xC0, 0x9D, 0x94, 0x52, 0x29, 0x81, 0xB7, 0x43, + 0x08, 0x51, 0x08, 0x61, 0xBD, 0xEB, 0xBB, 0x81, 0x73, 0x2E, 0x24, 0x27, + 0x32, 0x2A, 0x46, 0x0C, 0x01, 0x8B, 0x62, 0x2F, 0xD8, 0x1D, 0x23, 0x30, + 0xA6, 0x84, 0x54, 0x4A, 0x49, 0xAD, 0x52, 0x4A, 0x5C, 0x08, 0xA0, 0x41, + 0xA7, 0x94, 0x3E, 0xFE, 0xEC, 0xD9, 0xC5, 0xC5, 0x95, 0xD6, 0x8A, 0x31, + 0x31, 0x0A, 0x61, 0x24, 0x00, 0xBE, 0x57, 0x33, 0xDB, 0xC7, 0x7E, 0xAA, + 0xC0, 0xA9, 0x25, 0x4F, 0x81, 0x94, 0x1C, 0xA5, 0xA4, 0x92, 0x44, 0x75, + 0x19, 0xBB, 0xBD, 0x91, 0xE2, 0x1D, 0xA3, 0x1E, 0xFF, 0x72, 0xDD, 0x7C, + 0xF6, 0xE2, 0x42, 0x48, 0x95, 0x19, 0x93, 0x18, 0xFB, 0xFC, 0xC5, 0x4B, + 0x63, 0xCC, 0x6A, 0xB3, 0xB3, 0xCE, 0xDF, 0x2E, 0x57, 0x9B, 0x75, 0xA3, + 0xB5, 0x56, 0x4A, 0x9E, 0x9D, 0x9E, 0x04, 0xE7, 0x6E, 0x6F, 0x57, 0x5F, + 0x7B, 0xF7, 0x1D, 0xE7, 0xC3, 0x5F, 0xFD, 0xCD, 0x0F, 0x67, 0xD3, 0x3A, + 0xC5, 0xB4, 0x21, 0x55, 0x5F, 0xCE, 0xD1, 0xFB, 0xB6, 0xEF, 0x24, 0xE7, + 0x00, 0x64, 0xAA, 0x9A, 0xC8, 0x31, 0x8C, 0xF3, 0x11, 0x31, 0xB1, 0xCE, + 0x2A, 0xA9, 0xB8, 0x10, 0xC1, 0x39, 0xEF, 0xBD, 0x14, 0x02, 0x53, 0xD2, + 0x4A, 0x79, 0x52, 0xB0, 0xE2, 0x01, 0x5D, 0x4A, 0x90, 0xAC, 0xF7, 0xB0, + 0x6F, 0x73, 0x90, 0x9B, 0x16, 0xD5, 0x2F, 0x24, 0x85, 0x4E, 0x6C, 0x2C, + 0x3A, 0xCD, 0xB2, 0xC8, 0xA6, 0x93, 0x9A, 0x71, 0x71, 0xBB, 0x5A, 0x87, + 0x18, 0x7B, 0x6B, 0x21, 0x25, 0x0C, 0x28, 0x04, 0x47, 0xC4, 0x6E, 0xB0, + 0x8C, 0x81, 0x92, 0x3C, 0x37, 0xBA, 0xE9, 0xFB, 0x22, 0x33, 0x29, 0x41, + 0x8A, 0x90, 0x67, 0x46, 0x2B, 0xED, 0x7D, 0xD8, 0x35, 0x5D, 0x42, 0x1C, + 0xA5, 0x94, 0x19, 0x1C, 0x4D, 0x27, 0xC7, 0x8B, 0xB9, 0xD6, 0xBA, 0xEB, + 0xBA, 0xED, 0x6E, 0x07, 0x00, 0xCF, 0xCF, 0x2F, 0x2F, 0x2F, 0x6F, 0xBF, + 0xFE, 0xB5, 0x37, 0xDF, 0x7A, 0xF3, 0xB5, 0xCD, 0x66, 0x97, 0x65, 0xC6, + 0x68, 0x15, 0x11, 0xCB, 0x32, 0x37, 0x46, 0x0F, 0xD6, 0xC6, 0xC1, 0x31, + 0x06, 0x0C, 0xB4, 0xF7, 0x61, 0x32, 0xA9, 0xDE, 0x7B, 0xEF, 0xDD, 0xF5, + 0x6A, 0x73, 0xFE, 0xF2, 0x92, 0x01, 0x64, 0x5A, 0x75, 0x6D, 0xC7, 0x18, + 0xCB, 0x8C, 0xEE, 0xBA, 0x9E, 0x33, 0xE0, 0x9C, 0xAF, 0xD6, 0x1B, 0xC6, + 0xF9, 0xD1, 0x7C, 0xCA, 0x00, 0xDA, 0xB6, 0x9D, 0x4C, 0x26, 0xFD, 0x60, + 0x3F, 0xFD, 0xF4, 0xF9, 0xD7, 0xBF, 0xFA, 0x66, 0xD3, 0x76, 0xD6, 0xDA, + 0x37, 0x5E, 0x7F, 0xDC, 0x0F, 0xC3, 0xCD, 0xED, 0x66, 0x36, 0xA9, 0x27, + 0x75, 0x41, 0x7E, 0xE9, 0x0F, 0xCF, 0x8E, 0x1F, 0x3D, 0x58, 0x30, 0x48, + 0x1F, 0x7E, 0xFC, 0xAC, 0xEB, 0x86, 0xC7, 0x8F, 0x4E, 0xAD, 0x75, 0x9F, + 0x7E, 0x7E, 0x5E, 0x95, 0x05, 0x00, 0x94, 0x45, 0x5E, 0x96, 0x39, 0x07, + 0xA6, 0xB5, 0xAE, 0x4A, 0xE1, 0x1D, 0xE9, 0x8B, 0xA1, 0x52, 0x12, 0x88, + 0xF9, 0x0C, 0xEC, 0xE2, 0xFA, 0xB6, 0x1F, 0x06, 0xD2, 0x05, 0xFC, 0xFD, + 0xDF, 0xFE, 0xCD, 0xE9, 0xA4, 0xFA, 0xD9, 0x2F, 0x3E, 0x7D, 0xF1, 0xF2, + 0x92, 0x33, 0x06, 0x09, 0x7D, 0xF0, 0x52, 0x48, 0xC4, 0xD8, 0xF7, 0xB6, + 0x69, 0x7A, 0x21, 0xB9, 0xD6, 0xD9, 0xA4, 0x2A, 0xB7, 0xBB, 0xB6, 0x2C, + 0x8A, 0x8B, 0xCB, 0x6B, 0x4C, 0xF8, 0xD6, 0xD3, 0x27, 0x29, 0xA5, 0xCD, + 0x76, 0x47, 0xF2, 0x12, 0x88, 0x51, 0x4A, 0x59, 0xE7, 0xA6, 0xEB, 0x3D, + 0xAD, 0x4C, 0x06, 0xF0, 0xE8, 0xEC, 0x18, 0x53, 0x52, 0x52, 0x76, 0x83, + 0x45, 0x44, 0x00, 0xCD, 0x38, 0xAF, 0xAB, 0xA2, 0xEB, 0x06, 0xE7, 0x43, + 0x59, 0x18, 0x25, 0xE5, 0xEB, 0x4F, 0x1E, 0x7A, 0x6B, 0x7F, 0xFE, 0xC1, + 0x87, 0xCE, 0x5A, 0xEA, 0xA7, 0x85, 0x10, 0xA4, 0x52, 0xCE, 0xC7, 0x5F, + 0x7C, 0xF8, 0x89, 0xF7, 0x4E, 0x08, 0xDE, 0xB6, 0x1D, 0x40, 0x8A, 0x31, + 0xBE, 0xF5, 0xDA, 0xC3, 0x18, 0x42, 0x4A, 0xE9, 0x76, 0xB9, 0xA6, 0x91, + 0x75, 0x06, 0xCC, 0x28, 0xCD, 0x39, 0xC3, 0x18, 0x12, 0x24, 0x00, 0x64, + 0x20, 0x62, 0xC4, 0x5D, 0xD3, 0x56, 0x45, 0x5E, 0xE4, 0xD9, 0x64, 0x52, + 0xE7, 0x5A, 0x09, 0xC1, 0x49, 0x90, 0xAA, 0x2A, 0x8C, 0x54, 0x12, 0x23, + 0x86, 0x88, 0x52, 0x88, 0x3C, 0xD7, 0x52, 0x4A, 0xCE, 0x38, 0xDC, 0x85, + 0xA7, 0x04, 0x90, 0x8A, 0x94, 0x52, 0x4A, 0x82, 0x0B, 0x35, 0xB6, 0xFD, + 0x89, 0x2A, 0xC1, 0xD9, 0x28, 0x91, 0x35, 0xD6, 0x4C, 0xEC, 0x7E, 0xAE, + 0xF5, 0x6B, 0x19, 0x16, 0x85, 0xB0, 0x43, 0xF2, 0x75, 0x2F, 0x72, 0xDD, + 0xB3, 0xA9, 0x4C, 0x04, 0x9B, 0x23, 0x00, 0x48, 0x9A, 0x74, 0xDD, 0xAF, + 0xFF, 0x80, 0x98, 0x58, 0x82, 0xE0, 0x7D, 0x08, 0x81, 0xC6, 0xE5, 0x7C, + 0x88, 0x3E, 0x26, 0x1F, 0x22, 0xE7, 0x8C, 0xFC, 0xEC, 0x30, 0x25, 0xE2, + 0xA7, 0xE5, 0xB9, 0x76, 0xCE, 0x3B, 0xC6, 0x04, 0xE7, 0x55, 0x99, 0x0D, + 0xD6, 0x21, 0xA6, 0xE0, 0x03, 0x03, 0xD8, 0xEC, 0x7A, 0x32, 0x79, 0xEF, + 0xC1, 0x37, 0xDD, 0x60, 0x94, 0xA4, 0xC2, 0x38, 0x33, 0x4A, 0x8A, 0x14, + 0x88, 0x43, 0x1C, 0x02, 0xCD, 0x0B, 0x20, 0x86, 0x18, 0x62, 0x88, 0x81, + 0x2C, 0x03, 0xA2, 0x0F, 0xBE, 0x0F, 0x4D, 0xD3, 0x8E, 0x0E, 0x02, 0x98, + 0x8C, 0xD1, 0xB4, 0x93, 0x87, 0xBD, 0x0F, 0x18, 0x17, 0x1C, 0x12, 0xF1, + 0x04, 0x58, 0x0C, 0xA4, 0x15, 0xEF, 0x18, 0x4B, 0x9C, 0x8B, 0x18, 0xE3, + 0xA8, 0x6F, 0x27, 0x82, 0xF7, 0x5E, 0x78, 0xC9, 0x81, 0x71, 0x21, 0x8A, + 0x32, 0x6F, 0x9A, 0xEE, 0x17, 0x1F, 0x7E, 0x36, 0xF4, 0x76, 0x3A, 0xA9, + 0x22, 0xA6, 0x98, 0x80, 0x01, 0x87, 0x94, 0xD2, 0x58, 0xB9, 0x8E, 0x17, + 0x87, 0x94, 0xFC, 0x28, 0xD5, 0x8A, 0x89, 0x08, 0x6D, 0x29, 0xA5, 0x14, + 0x42, 0x90, 0x92, 0xD7, 0x45, 0x76, 0x58, 0xFF, 0x31, 0xC6, 0x18, 0xC9, + 0x81, 0x89, 0x7D, 0x7E, 0x7E, 0xB1, 0xDE, 0x75, 0x3F, 0xFA, 0xE9, 0x2F, + 0x8F, 0xE6, 0xF3, 0x69, 0x5D, 0xF8, 0xDC, 0x87, 0x88, 0xD6, 0x85, 0xEB, + 0xDB, 0xF5, 0xCD, 0x72, 0x8D, 0x98, 0x18, 0xB0, 0xE3, 0xE3, 0x79, 0xDF, + 0xDB, 0xB6, 0xED, 0x76, 0x9B, 0x1D, 0xE7, 0x7C, 0x70, 0xEE, 0xFC, 0xE2, + 0xD2, 0x0E, 0x6E, 0x36, 0x9D, 0xF8, 0x10, 0xAC, 0xEB, 0x05, 0x17, 0x45, + 0x9E, 0x31, 0x80, 0xCC, 0x68, 0xEB, 0x7D, 0x1C, 0xCD, 0x2E, 0x20, 0x26, + 0x04, 0x04, 0xAD, 0xD4, 0x7A, 0xBB, 0x8D, 0x11, 0x05, 0x67, 0x42, 0xC8, + 0xDE, 0x5A, 0x1F, 0x22, 0x8D, 0xC4, 0x63, 0x4A, 0x90, 0x20, 0x62, 0x1A, + 0xCB, 0x43, 0x21, 0x43, 0x8C, 0x2E, 0xF8, 0x44, 0x16, 0xCB, 0x00, 0x88, + 0x28, 0x05, 0x4F, 0x18, 0xA9, 0x78, 0x74, 0xDE, 0x93, 0x1E, 0x43, 0xD7, + 0x0F, 0x21, 0xC6, 0x3C, 0x33, 0x93, 0xBA, 0x9A, 0x4E, 0xEB, 0xAB, 0x9B, + 0x95, 0xB5, 0xCE, 0x7B, 0xA7, 0xA5, 0x02, 0x80, 0x10, 0x82, 0xE2, 0xA2, + 0xC8, 0xF3, 0xAE, 0xEB, 0x21, 0x25, 0x0E, 0xE0, 0x21, 0x96, 0x65, 0x7E, + 0x7C, 0x34, 0x0F, 0x3E, 0x34, 0x5D, 0x6F, 0x22, 0x0E, 0xD6, 0xB6, 0x5D, + 0x37, 0x92, 0x30, 0x30, 0x09, 0x26, 0x1E, 0x9D, 0x9D, 0xCE, 0x26, 0x15, + 0x83, 0x74, 0xBB, 0xBC, 0xED, 0x7A, 0xCB, 0x39, 0x37, 0x46, 0x0F, 0x83, + 0xBD, 0xDE, 0xDD, 0x3E, 0x3F, 0xBF, 0xF8, 0xB7, 0xFF, 0xE6, 0x5F, 0xBF, + 0xF1, 0xF4, 0x11, 0x30, 0x36, 0x0A, 0x8D, 0xA5, 0x54, 0x16, 0x99, 0xF7, + 0x7E, 0x18, 0x2C, 0xE7, 0xBC, 0xEB, 0x06, 0xAD, 0x65, 0xD3, 0xB4, 0xC1, + 0x07, 0xAD, 0xF5, 0xE3, 0x47, 0x0F, 0x48, 0xA8, 0xBA, 0x69, 0x3B, 0x63, + 0x8C, 0x56, 0xF2, 0xE5, 0xAB, 0xAB, 0xE5, 0x72, 0x6D, 0x32, 0x5D, 0x96, + 0x25, 0x63, 0xEC, 0x9D, 0x77, 0xDE, 0x24, 0x6B, 0xBB, 0x27, 0x4F, 0x1E, + 0xFE, 0xED, 0xDF, 0xBD, 0xBF, 0x5E, 0xAD, 0x37, 0xDB, 0xA6, 0xAE, 0xCB, + 0xED, 0xAE, 0x71, 0xCE, 0x4D, 0x26, 0xD5, 0xC7, 0x9F, 0x3E, 0x7F, 0xFC, + 0xF0, 0x14, 0xD3, 0x51, 0x9E, 0x99, 0xBE, 0x1F, 0x6E, 0x6E, 0xD6, 0x5C, + 0xB0, 0xAA, 0x2C, 0xDE, 0xFD, 0xCA, 0x1B, 0x3F, 0xFF, 0xC5, 0x27, 0x42, + 0x88, 0xD3, 0xD3, 0x85, 0x10, 0x62, 0xB9, 0x5C, 0x93, 0xD6, 0xD5, 0xAC, + 0x2E, 0xBD, 0xF7, 0x44, 0x59, 0x24, 0xB5, 0x7B, 0xC4, 0x34, 0x38, 0xCF, + 0x39, 0x73, 0x3E, 0x38, 0x1F, 0xB2, 0xCC, 0x9C, 0x1E, 0xCF, 0x07, 0x6B, + 0xDF, 0xFB, 0xC6, 0xBB, 0xD3, 0x69, 0xBD, 0xDE, 0x34, 0xCF, 0xCF, 0x5F, + 0x39, 0xE7, 0xA5, 0xE4, 0x52, 0x72, 0x8C, 0x18, 0x53, 0x30, 0x3A, 0xC3, + 0x94, 0x98, 0x60, 0x5A, 0x29, 0x6A, 0xF1, 0x4F, 0xEA, 0xE2, 0xB5, 0xC7, + 0x0F, 0xE6, 0xD3, 0x49, 0x51, 0xE4, 0x93, 0xBA, 0x8C, 0x11, 0x5F, 0xBC, + 0xBC, 0x78, 0xFA, 0xF8, 0xEC, 0xE9, 0x93, 0x07, 0x21, 0x04, 0xA5, 0x54, + 0x5D, 0x15, 0x42, 0xCA, 0xDB, 0xE5, 0xE6, 0xD5, 0xE5, 0x0D, 0xE3, 0xFC, + 0xBD, 0x77, 0xDF, 0x3C, 0x9A, 0x4D, 0xBB, 0xC1, 0x3E, 0xBF, 0xB8, 0x5A, + 0xAD, 0x77, 0x11, 0x51, 0x6B, 0x85, 0x29, 0xB5, 0x4D, 0x97, 0x30, 0xE6, + 0xA6, 0x2A, 0xF2, 0x6C, 0xBD, 0xDA, 0x20, 0xE2, 0x7C, 0x56, 0xCF, 0x27, + 0xD5, 0xC5, 0xE5, 0x8D, 0x90, 0x82, 0xA6, 0x35, 0x4F, 0x16, 0xB3, 0xFF, + 0xE1, 0xDF, 0xFC, 0xAB, 0x07, 0xA7, 0x47, 0x4D, 0xDB, 0x3F, 0x79, 0x78, + 0x5A, 0x15, 0x79, 0x6E, 0x14, 0x4B, 0xB0, 0x6B, 0x7B, 0x1F, 0xFC, 0xF3, + 0xE7, 0x17, 0xB4, 0x46, 0xCA, 0x22, 0xDB, 0xEE, 0x5A, 0x96, 0x20, 0x84, + 0xC0, 0x98, 0x28, 0x8B, 0x9C, 0xE4, 0x0C, 0xBC, 0x0F, 0x88, 0x58, 0x55, + 0x85, 0xE0, 0x4C, 0x0A, 0xAE, 0x47, 0x1B, 0x11, 0x2D, 0xA5, 0x14, 0x52, + 0x50, 0xAB, 0x54, 0x0A, 0x49, 0x0D, 0x6B, 0xC1, 0xF6, 0x92, 0x58, 0x89, + 0x25, 0x4E, 0xAC, 0xCF, 0x84, 0x29, 0x29, 0xC1, 0xF9, 0xE8, 0x84, 0x00, + 0xA3, 0xBE, 0x17, 0xA4, 0x34, 0x76, 0xD2, 0x46, 0x0A, 0xC1, 0x21, 0x3C, + 0xA5, 0x7B, 0xC1, 0x09, 0xEF, 0xC5, 0xAC, 0x2F, 0x86, 0xB6, 0xFB, 0x30, + 0xFF, 0xDD, 0x2B, 0xE8, 0xA7, 0x8C, 0x31, 0x20, 0x22, 0x67, 0xDC, 0x7B, + 0x1F, 0x23, 0xD9, 0x8B, 0x30, 0x8A, 0x62, 0xD6, 0x91, 0x33, 0x20, 0x84, + 0x10, 0x63, 0x1C, 0xD9, 0xA1, 0x31, 0x26, 0x25, 0x38, 0x89, 0xE1, 0xD3, + 0xA8, 0xB9, 0x14, 0x3C, 0xCF, 0x75, 0xDB, 0x0E, 0xD6, 0x79, 0x3A, 0x8E, + 0x10, 0x63, 0x4A, 0x20, 0x05, 0xA7, 0x4F, 0xE3, 0x8C, 0xC5, 0xE8, 0x88, + 0xD8, 0x96, 0x69, 0x45, 0xF4, 0xC2, 0x10, 0x82, 0x10, 0xA2, 0xAA, 0x4A, + 0xC6, 0xB8, 0xF7, 0x9E, 0x7C, 0x35, 0xA8, 0x48, 0x8B, 0x88, 0xD6, 0xF9, + 0xE0, 0x03, 0x35, 0x4A, 0x00, 0xC0, 0x79, 0x0F, 0x00, 0x21, 0x20, 0x03, + 0x70, 0x3E, 0x32, 0x00, 0x1A, 0xBB, 0x4F, 0xB0, 0xAF, 0x92, 0x18, 0x8B, + 0x81, 0x59, 0xF0, 0x00, 0x2E, 0x25, 0x48, 0x08, 0x42, 0x70, 0x60, 0x80, + 0x00, 0x08, 0xA0, 0x94, 0x64, 0x80, 0xBF, 0xF8, 0xC5, 0xA7, 0xE7, 0xAF, + 0x96, 0x29, 0xE1, 0xF1, 0xD1, 0x34, 0x91, 0x2B, 0x01, 0x40, 0xC2, 0x71, + 0x4C, 0x69, 0x2F, 0x22, 0x36, 0xE2, 0xFA, 0xFB, 0x13, 0x49, 0x31, 0x8E, + 0x34, 0xB7, 0x10, 0x82, 0x31, 0xA6, 0x2E, 0x33, 0xAD, 0x24, 0x30, 0x86, + 0x18, 0xBD, 0x8F, 0xD4, 0xF2, 0xF3, 0x21, 0xFE, 0xD5, 0x5F, 0xFF, 0x3D, + 0x17, 0xDA, 0x85, 0x00, 0x09, 0xF2, 0x4C, 0xB7, 0x6D, 0x17, 0x42, 0xB8, + 0xBA, 0x5E, 0xAD, 0xB6, 0xBB, 0xF5, 0x7A, 0xD7, 0x74, 0xBD, 0xD2, 0x4A, + 0x2B, 0x65, 0x9D, 0x1F, 0xFA, 0x01, 0x18, 0xD3, 0x79, 0xE6, 0x42, 0x0C, + 0x88, 0x9B, 0xD5, 0x3A, 0x37, 0x06, 0x40, 0x84, 0x18, 0x85, 0x10, 0x82, + 0xF1, 0x9E, 0xCA, 0x46, 0x48, 0x46, 0x69, 0xE7, 0x7D, 0xC0, 0x98, 0x00, + 0x48, 0xAB, 0x7B, 0xDB, 0x74, 0xB7, 0xEB, 0xED, 0xA4, 0x2A, 0x69, 0xDE, + 0x2D, 0x41, 0x0A, 0x18, 0x89, 0x33, 0x39, 0x22, 0x97, 0x08, 0x9C, 0x73, + 0xAD, 0x94, 0x0F, 0xB1, 0x1D, 0x06, 0xCE, 0x98, 0x52, 0x92, 0xC2, 0x3A, + 0x27, 0x4A, 0x8E, 0x14, 0x10, 0x46, 0xA3, 0x3F, 0xF2, 0x52, 0x01, 0x80, + 0x14, 0xB1, 0x2E, 0x8B, 0xA3, 0xF9, 0xB4, 0x1B, 0xEC, 0xE5, 0xD5, 0x35, + 0x11, 0x0E, 0x9C, 0xF3, 0x92, 0x1E, 0x42, 0xA4, 0x94, 0xAA, 0xB2, 0x60, + 0x09, 0x38, 0xE7, 0xD3, 0xC9, 0x84, 0x33, 0x66, 0x8C, 0x66, 0xC0, 0x32, + 0x13, 0x9B, 0x6E, 0x20, 0xC1, 0xF4, 0xA2, 0xCA, 0xEA, 0xAA, 0x6C, 0xBA, + 0x4E, 0x4B, 0x75, 0x7A, 0x32, 0x6F, 0x76, 0x4D, 0x8C, 0x48, 0x7B, 0x55, + 0x4A, 0x58, 0xE4, 0x59, 0x9E, 0x67, 0x09, 0x63, 0xDB, 0x0D, 0xFF, 0xE1, + 0x3F, 0xFE, 0xDF, 0xFF, 0xE2, 0x9F, 0xFF, 0x93, 0xEF, 0xBC, 0xF7, 0xB5, + 0xED, 0xAE, 0xB1, 0xD6, 0x09, 0xCE, 0xCE, 0xCE, 0x8E, 0x21, 0x81, 0x52, + 0x32, 0x25, 0x70, 0xCE, 0xF5, 0x83, 0x65, 0x2C, 0xE5, 0x59, 0x06, 0x90, + 0x84, 0xD0, 0x75, 0x95, 0xF9, 0x10, 0x8D, 0x79, 0xD2, 0x0F, 0xF6, 0xE2, + 0xD5, 0x4D, 0xD7, 0xF7, 0x45, 0x55, 0x1C, 0x4D, 0x27, 0x88, 0xA9, 0x9E, + 0x54, 0xCB, 0xE5, 0xEA, 0x9D, 0xB7, 0xDE, 0x7B, 0xF8, 0xF0, 0x04, 0x63, + 0x64, 0xDF, 0xFB, 0xE6, 0x8F, 0xDF, 0xFF, 0x68, 0xDB, 0xB4, 0x93, 0x69, + 0x05, 0x00, 0x9F, 0x3F, 0x7B, 0xF9, 0xCF, 0x7F, 0xEF, 0xBB, 0xDF, 0xFB, + 0xCE, 0x37, 0x3E, 0xFE, 0xEC, 0x05, 0xED, 0x3A, 0x65, 0x59, 0x2C, 0x37, + 0x1B, 0xC1, 0xC5, 0xCD, 0x72, 0x73, 0x7A, 0x3C, 0x3F, 0x3B, 0x5D, 0xBC, + 0xBA, 0xBC, 0xE1, 0x9C, 0x9D, 0x1E, 0xCF, 0xDB, 0xB6, 0x43, 0xC4, 0x10, + 0xE3, 0x30, 0xAA, 0x15, 0xA6, 0x84, 0x40, 0x73, 0x7B, 0x59, 0xA6, 0x43, + 0x8C, 0x3E, 0x22, 0x63, 0xAC, 0x2A, 0xB2, 0x94, 0xE9, 0x22, 0xCF, 0xBF, + 0xFD, 0x8D, 0xAF, 0x96, 0x65, 0xB1, 0x5E, 0x6F, 0x9D, 0x0F, 0x97, 0x57, + 0x37, 0x46, 0xCB, 0xAA, 0xCC, 0x8B, 0x22, 0x6B, 0xDA, 0x3E, 0x46, 0x54, + 0x4A, 0x85, 0x10, 0x8D, 0xD2, 0x5A, 0xC9, 0xB7, 0x9F, 0x3E, 0xD9, 0x35, + 0xAD, 0x92, 0xF2, 0xE1, 0xE9, 0xC2, 0x18, 0x0D, 0x8C, 0x6D, 0xB6, 0xBB, + 0x3C, 0xD3, 0x6F, 0xBD, 0xFE, 0x90, 0x33, 0x16, 0x22, 0xD2, 0x18, 0x0C, + 0x62, 0xCA, 0x32, 0xF3, 0xE0, 0x78, 0xF6, 0xDA, 0xC3, 0x13, 0x4C, 0x89, + 0x01, 0x08, 0xC1, 0x8E, 0x17, 0x93, 0xA2, 0xD0, 0xEB, 0x6D, 0x13, 0x23, + 0xB6, 0x9D, 0xBD, 0xBA, 0x59, 0x69, 0x25, 0x8F, 0x66, 0xF5, 0x5B, 0x4F, + 0x1F, 0x21, 0xA6, 0xF5, 0x7A, 0xFB, 0xF0, 0xC1, 0x09, 0x4D, 0xCB, 0x4A, + 0xC1, 0x13, 0x30, 0xA9, 0xE4, 0x9B, 0xAF, 0x3F, 0x7E, 0xFA, 0xE4, 0x0C, + 0x18, 0x0C, 0xD6, 0x71, 0xC6, 0xAA, 0x32, 0xEF, 0xFA, 0x01, 0x23, 0xE6, + 0x99, 0xF9, 0xEC, 0xD9, 0x8B, 0x61, 0x70, 0x46, 0xAB, 0x77, 0xDE, 0x78, + 0xED, 0x66, 0xB9, 0x69, 0xBB, 0x41, 0x09, 0x91, 0xD0, 0x0B, 0xA1, 0x74, + 0x66, 0x38, 0xE3, 0xC0, 0x92, 0xF7, 0x31, 0xD3, 0x7A, 0x3A, 0x29, 0x69, + 0x69, 0x73, 0xC1, 0x19, 0x87, 0x31, 0x26, 0x71, 0x26, 0x49, 0x4D, 0x6D, + 0x0F, 0x6F, 0x31, 0x0E, 0x9C, 0x03, 0xDB, 0x3B, 0xBF, 0x51, 0x17, 0x82, + 0xF3, 0x11, 0xDB, 0x3A, 0x64, 0x61, 0x87, 0xBE, 0xD9, 0x3E, 0x06, 0x7D, + 0xB9, 0x9C, 0x4C, 0xF7, 0x1F, 0xE3, 0x5F, 0xC6, 0xEA, 0xF2, 0xF0, 0x86, + 0x87, 0x22, 0xE9, 0x4B, 0x21, 0x8C, 0x7E, 0x91, 0x43, 0xDF, 0x53, 0xB4, + 0xDC, 0x6B, 0x33, 0x80, 0x1D, 0x2C, 0xA9, 0x29, 0x84, 0x80, 0xE4, 0xAB, + 0x40, 0x84, 0xCC, 0x83, 0xEA, 0x16, 0x29, 0x08, 0x91, 0x83, 0xB9, 0x8B, + 0x5E, 0x6B, 0x49, 0x63, 0x77, 0x77, 0xB9, 0x62, 0x4A, 0x5C, 0xEC, 0xE9, + 0xAB, 0x70, 0x68, 0x1E, 0xB0, 0x94, 0x52, 0x44, 0xB2, 0x6F, 0x49, 0x44, + 0x34, 0x0D, 0xDE, 0xDB, 0xC1, 0x72, 0x46, 0x33, 0xE7, 0x63, 0x23, 0x21, + 0x84, 0x68, 0x07, 0xB7, 0x0F, 0x2C, 0xC0, 0x38, 0x4B, 0x9E, 0x08, 0x9C, + 0x8C, 0xE2, 0x3D, 0xA9, 0x4D, 0x20, 0x03, 0xBE, 0xD7, 0x14, 0x43, 0x20, + 0x6B, 0xC3, 0xFB, 0xCE, 0xBB, 0x0C, 0x90, 0x01, 0x07, 0xCE, 0x79, 0x08, + 0xF1, 0x07, 0x7F, 0xF7, 0xB3, 0x97, 0xAF, 0x96, 0xC7, 0xC7, 0x8B, 0xAA, + 0xCC, 0x86, 0xC1, 0x1A, 0x93, 0x01, 0xD9, 0xC3, 0xE0, 0x78, 0xD1, 0x71, + 0x94, 0x2C, 0x1B, 0x5D, 0xD7, 0x10, 0x53, 0xC0, 0x44, 0x3D, 0x41, 0x60, + 0x40, 0xE5, 0xB0, 0xD1, 0x72, 0xCC, 0x6E, 0x62, 0x0C, 0x21, 0x32, 0xC6, + 0xA5, 0x14, 0xE7, 0x97, 0xB7, 0x7F, 0xFB, 0xC3, 0x9F, 0x36, 0x6D, 0x6F, + 0x8C, 0xB9, 0xB9, 0x59, 0x9E, 0x9E, 0x2C, 0xBA, 0xB6, 0xBB, 0xBE, 0x5D, + 0x4A, 0x21, 0x07, 0x17, 0xDA, 0xB6, 0x0F, 0x31, 0x1A, 0x63, 0x12, 0xE2, + 0x30, 0x0C, 0xC1, 0x07, 0xEB, 0x9D, 0xE4, 0x7C, 0x87, 0x18, 0x30, 0x52, + 0xA1, 0x6D, 0x8C, 0x4E, 0x09, 0x72, 0x6E, 0x22, 0xC6, 0x18, 0xA8, 0x8D, + 0x8F, 0x3E, 0x44, 0xCE, 0x85, 0x92, 0x2A, 0x45, 0x4F, 0x07, 0x19, 0x11, + 0x7D, 0x08, 0x65, 0x6E, 0x8A, 0xDC, 0xB4, 0xFD, 0x20, 0x84, 0x50, 0x52, + 0xF1, 0x40, 0x0E, 0xB2, 0x89, 0x33, 0x4E, 0x02, 0xE3, 0x2E, 0x44, 0x00, + 0xE8, 0x86, 0x01, 0x31, 0x91, 0x76, 0x3B, 0x29, 0x34, 0x08, 0xCE, 0x9C, + 0x73, 0x87, 0x5B, 0x2A, 0xD3, 0xBA, 0xED, 0x07, 0x96, 0x92, 0x14, 0xA2, + 0x98, 0x98, 0x94, 0xF0, 0xE6, 0x76, 0x1D, 0x42, 0x48, 0x98, 0xB4, 0xD6, + 0x9C, 0x31, 0xF2, 0xF5, 0x20, 0x12, 0x9D, 0xE6, 0x22, 0x01, 0x70, 0x01, + 0xC0, 0x18, 0xE9, 0x6B, 0x13, 0x63, 0x9A, 0x33, 0x16, 0x63, 0x90, 0x52, + 0xD6, 0xD5, 0x7C, 0x36, 0xA9, 0x18, 0x83, 0xA3, 0xF9, 0xA4, 0xAA, 0x4A, + 0x2D, 0xE5, 0x62, 0x3E, 0xA9, 0xEB, 0x72, 0xB5, 0xDE, 0x76, 0x5D, 0xDF, + 0x77, 0xC3, 0x64, 0x52, 0xE7, 0xB9, 0x59, 0xAE, 0xB7, 0xF5, 0x60, 0x5F, + 0xBE, 0xBC, 0xFC, 0xCB, 0xEF, 0xFF, 0xA0, 0xAE, 0x8A, 0x07, 0x67, 0xC7, + 0x3E, 0x84, 0xE5, 0xA6, 0xD9, 0x6C, 0x1B, 0x21, 0x44, 0xDF, 0x0F, 0x8B, + 0xC5, 0x3C, 0x33, 0xCA, 0x7B, 0xA7, 0x35, 0x5D, 0x16, 0x8C, 0x21, 0x12, + 0x3F, 0x5B, 0x4B, 0x91, 0x19, 0xDD, 0xB5, 0x7D, 0x66, 0x8C, 0xD6, 0x0A, + 0x18, 0xF3, 0xC1, 0x7B, 0xEF, 0xCA, 0xB2, 0x78, 0x79, 0x71, 0x55, 0x96, + 0x39, 0xE7, 0xEC, 0xF8, 0x68, 0xF6, 0x2F, 0x7F, 0xFF, 0x7B, 0xEB, 0xCD, + 0xEE, 0x27, 0xEF, 0xFF, 0x72, 0xB3, 0xD9, 0x0A, 0x21, 0x7F, 0xFA, 0xF3, + 0x0F, 0xBF, 0xFA, 0xCE, 0x1B, 0x88, 0x8F, 0xB6, 0xBB, 0xA6, 0x3C, 0x5D, + 0x08, 0xCE, 0x83, 0x0F, 0xD6, 0x3A, 0xA3, 0xD5, 0xC5, 0xE5, 0xCD, 0xE9, + 0xF1, 0xD1, 0x76, 0xD7, 0x5C, 0xDF, 0xAC, 0xA4, 0xE0, 0x4F, 0x1E, 0x9F, + 0x9D, 0xBF, 0xBC, 0xCC, 0x33, 0x43, 0x7E, 0x5D, 0xB6, 0xB7, 0x6D, 0xDF, + 0x1B, 0xAD, 0xB3, 0x4C, 0x03, 0x80, 0x56, 0x4A, 0xAB, 0x94, 0x52, 0x62, + 0x8C, 0x77, 0xDD, 0xF0, 0xE6, 0xD3, 0x47, 0xD6, 0xFA, 0x4F, 0x3F, 0x3F, + 0x5F, 0x1C, 0x1F, 0x11, 0x60, 0x52, 0xD7, 0x25, 0x63, 0x40, 0x53, 0x3E, + 0xCE, 0x39, 0xEB, 0xDC, 0x30, 0xB8, 0x94, 0x92, 0x10, 0x2C, 0xCB, 0xCC, + 0xCD, 0xED, 0x0A, 0x23, 0x6E, 0x77, 0xED, 0x8C, 0xF3, 0xAA, 0xCC, 0x63, + 0x88, 0xC3, 0xE0, 0x82, 0x0F, 0x24, 0x42, 0x2B, 0xB9, 0x60, 0xC0, 0x12, + 0x20, 0xE7, 0xAC, 0x2C, 0xCA, 0x2C, 0xD3, 0x90, 0xD8, 0x76, 0xD7, 0x12, + 0x0F, 0x70, 0x3E, 0xA9, 0x4F, 0x16, 0x73, 0xCE, 0xD9, 0xE5, 0xD5, 0xF2, + 0x68, 0x56, 0x15, 0x79, 0x26, 0x38, 0xCF, 0x33, 0x1D, 0x22, 0x3E, 0x7D, + 0xED, 0x8C, 0x31, 0xC6, 0x19, 0x0B, 0x3E, 0x28, 0x25, 0x38, 0x17, 0xEF, + 0xBC, 0xF3, 0x54, 0x4B, 0x39, 0x58, 0xCB, 0x18, 0x5B, 0x2E, 0xD7, 0x4A, + 0x2B, 0xC4, 0xE8, 0x9C, 0xCF, 0x33, 0xB3, 0x5A, 0x6F, 0xAF, 0xAE, 0x96, + 0xF3, 0xF9, 0x94, 0x44, 0x3D, 0x69, 0x1B, 0xBB, 0xBD, 0x5D, 0x2D, 0x57, + 0x6B, 0x32, 0x95, 0x3A, 0x9A, 0x4D, 0x69, 0xE2, 0xC7, 0x68, 0x5D, 0xE4, + 0xB9, 0x51, 0x52, 0x4B, 0x21, 0x24, 0x1F, 0x69, 0x9D, 0x82, 0x53, 0x7F, + 0x69, 0x1F, 0xBF, 0x0E, 0x41, 0xEA, 0x6E, 0xFA, 0xE5, 0x3E, 0x23, 0x8C, + 0xED, 0x41, 0x31, 0xD8, 0xB3, 0x9D, 0xE0, 0x1E, 0xB4, 0xFF, 0xC5, 0x6A, + 0xF1, 0xCB, 0x8F, 0xC3, 0xFF, 0x21, 0xF4, 0x69, 0x3F, 0xDD, 0xFC, 0x85, + 0x90, 0xF7, 0xA5, 0xDF, 0x25, 0x6D, 0x9B, 0x88, 0xD8, 0xB6, 0x3D, 0x1D, + 0x8A, 0x75, 0xA1, 0xED, 0x2D, 0x00, 0x18, 0xAD, 0xB4, 0x96, 0xD6, 0xFA, + 0x03, 0xF7, 0x82, 0xF2, 0x35, 0x00, 0xF0, 0x3E, 0x14, 0x59, 0x4E, 0x1D, + 0x52, 0x21, 0x85, 0xB7, 0xCE, 0x68, 0x45, 0x70, 0x15, 0x51, 0x10, 0x49, + 0x52, 0x9F, 0x8E, 0x86, 0x88, 0x6F, 0x9C, 0x31, 0x9A, 0x4E, 0x20, 0xD3, + 0x17, 0x00, 0x88, 0x31, 0xD2, 0x18, 0x04, 0x31, 0xB0, 0x68, 0x74, 0x31, + 0xC6, 0xE8, 0xAC, 0xDF, 0x07, 0x35, 0x00, 0x00, 0x88, 0x29, 0x71, 0x8E, + 0x08, 0x98, 0x22, 0x5D, 0x18, 0xC1, 0xD2, 0x01, 0x80, 0xBD, 0x3B, 0x79, + 0x00, 0x04, 0xE0, 0x6C, 0x9C, 0xB3, 0x24, 0x78, 0x5B, 0x08, 0x39, 0x0C, + 0xF6, 0x87, 0x3F, 0xFA, 0xE5, 0x72, 0xB9, 0x3B, 0x3A, 0x9A, 0x53, 0x23, + 0x5C, 0xC9, 0x8C, 0x4B, 0x11, 0x31, 0x25, 0x60, 0x04, 0x7B, 0x50, 0x5D, + 0x49, 0xAE, 0x1C, 0x21, 0x92, 0x5B, 0x79, 0x22, 0xE4, 0x92, 0xE4, 0xAB, + 0xB4, 0x22, 0x46, 0x1F, 0xA7, 0x0E, 0x3A, 0x62, 0xCA, 0x8C, 0xB9, 0x59, + 0xAE, 0xFF, 0xF7, 0x3F, 0xFB, 0xCB, 0xA6, 0x1D, 0x8C, 0xD6, 0x31, 0x46, + 0x6B, 0xFD, 0xD1, 0x6C, 0x96, 0x19, 0x73, 0xB3, 0xDC, 0x2C, 0x37, 0xAD, + 0x14, 0x22, 0x44, 0xEC, 0x07, 0xDB, 0x5B, 0xCB, 0x80, 0x61, 0x44, 0x29, + 0x78, 0xEF, 0x7A, 0x60, 0x20, 0x94, 0xC6, 0x84, 0x21, 0x44, 0x25, 0x15, + 0xCD, 0x4B, 0x7A, 0x1F, 0x7C, 0x8C, 0x80, 0x04, 0x33, 0x4B, 0xB2, 0xF3, + 0xE3, 0x42, 0x60, 0x44, 0xEF, 0x23, 0x63, 0xA0, 0x95, 0x22, 0x57, 0x27, + 0xAE, 0x24, 0x00, 0x18, 0xAD, 0x09, 0x99, 0xA3, 0xAB, 0x20, 0x84, 0x18, + 0xAC, 0x8B, 0x91, 0xBA, 0xAE, 0x18, 0xA8, 0xDD, 0x89, 0x91, 0x4A, 0x4E, + 0xCE, 0xB9, 0xE0, 0x2C, 0x25, 0x14, 0x42, 0x90, 0x44, 0xA7, 0x10, 0x82, + 0x33, 0xC8, 0x8D, 0x9E, 0x54, 0x65, 0x6F, 0x07, 0xAD, 0x54, 0xD3, 0x0F, + 0x11, 0x93, 0x14, 0x3C, 0x37, 0x9A, 0xC6, 0x08, 0x32, 0x25, 0x50, 0x1C, + 0xF2, 0x6E, 0x72, 0xDE, 0x93, 0x29, 0x25, 0xEF, 0x7D, 0x9E, 0x67, 0x24, + 0xD8, 0x6D, 0x8C, 0x36, 0x46, 0x57, 0x55, 0x61, 0xB4, 0x5E, 0x6F, 0x77, + 0x90, 0xE0, 0xE1, 0x83, 0x13, 0x6B, 0x5D, 0x82, 0x54, 0x95, 0xC5, 0xB4, + 0x2A, 0x95, 0xE4, 0x09, 0xA7, 0x21, 0x44, 0xA9, 0x84, 0xD6, 0x7A, 0x3A, + 0xA9, 0x76, 0xBB, 0x86, 0x73, 0x56, 0x64, 0x46, 0x30, 0xA6, 0xA4, 0x34, + 0x5A, 0xD9, 0xDE, 0x26, 0x4C, 0xC7, 0xA7, 0xB3, 0x5D, 0xD3, 0x1A, 0xAD, + 0x04, 0xE7, 0x5A, 0x4B, 0xC6, 0xC0, 0x39, 0xAB, 0x85, 0x34, 0x52, 0x25, + 0x48, 0x82, 0x31, 0x48, 0x49, 0x49, 0x38, 0x5E, 0xCC, 0xBE, 0xF5, 0x8D, + 0xAF, 0xDC, 0xAE, 0xD6, 0x6D, 0xDB, 0x67, 0xD9, 0x44, 0x2A, 0xF1, 0xE4, + 0xF1, 0x83, 0xB7, 0xDF, 0x7C, 0x0D, 0x49, 0xFD, 0x9A, 0xA5, 0xAB, 0xDB, + 0xD5, 0x67, 0x9F, 0xBD, 0xDC, 0xAC, 0x77, 0x52, 0xB0, 0x94, 0xF0, 0xEA, + 0xEA, 0x26, 0x33, 0x66, 0x3A, 0xAD, 0x8E, 0x8F, 0x66, 0x7D, 0x3F, 0x18, + 0xAD, 0xF3, 0xCC, 0x34, 0x6D, 0x4B, 0xCC, 0xEA, 0x7E, 0x18, 0x5E, 0x7F, + 0xF2, 0xE0, 0xE6, 0x66, 0xDD, 0x0D, 0x56, 0x69, 0x5D, 0x57, 0x65, 0xDF, + 0x0F, 0x67, 0xA7, 0xC7, 0x3E, 0xF8, 0x75, 0xD3, 0x1A, 0xA5, 0x84, 0x88, + 0xD6, 0xF9, 0x8A, 0xC8, 0x40, 0xA3, 0x46, 0x13, 0x66, 0x99, 0x7A, 0xEB, + 0x8D, 0xC7, 0x7D, 0x6F, 0xAD, 0x73, 0x52, 0xCA, 0xAB, 0x9B, 0x55, 0x4A, + 0xC9, 0x5A, 0xC2, 0x3D, 0xB4, 0x10, 0x42, 0x29, 0xED, 0x7D, 0x24, 0xD3, + 0xA0, 0x87, 0x93, 0xC9, 0x0F, 0xFE, 0xE1, 0x7D, 0xE7, 0xC3, 0xF1, 0x7C, + 0xBA, 0xDD, 0x35, 0x6F, 0xBC, 0xFE, 0x48, 0x4A, 0x01, 0x90, 0x8A, 0xDC, + 0x38, 0x1F, 0x06, 0xE7, 0x00, 0x98, 0xD2, 0x2A, 0x84, 0x80, 0x31, 0x0D, + 0xD6, 0x31, 0xCE, 0x13, 0x22, 0xED, 0x04, 0xC0, 0x98, 0x60, 0x5C, 0x29, + 0xA2, 0xD0, 0x8A, 0x07, 0x67, 0x47, 0x74, 0x7B, 0xD0, 0xDA, 0xE1, 0x8C, + 0x4B, 0xA5, 0x62, 0x0C, 0xDE, 0x47, 0x63, 0xF4, 0xD1, 0xD1, 0x54, 0x08, + 0x21, 0x59, 0x8A, 0x21, 0x50, 0x5F, 0x6B, 0x52, 0xE5, 0x42, 0x0A, 0xEF, + 0x63, 0x66, 0xB4, 0xE0, 0xFC, 0x66, 0xB9, 0x7E, 0xFD, 0xC9, 0x03, 0x00, + 0x10, 0x1C, 0x52, 0xC2, 0xF9, 0xB4, 0xAE, 0xCA, 0x62, 0xB3, 0xD9, 0x1C, + 0xCD, 0xA7, 0xCE, 0x85, 0x80, 0x51, 0x2B, 0x59, 0xE4, 0xB9, 0x52, 0x52, + 0x70, 0x6E, 0x8C, 0x56, 0x4A, 0x70, 0x21, 0x20, 0xDD, 0x39, 0x28, 0x1E, + 0x86, 0x94, 0xD9, 0x38, 0xEE, 0x72, 0x08, 0x4D, 0xE3, 0xCF, 0xFB, 0xB9, + 0xD2, 0xBD, 0xAC, 0x06, 0x0E, 0xCB, 0x74, 0xFF, 0x04, 0xF8, 0x47, 0x93, + 0xB2, 0x2F, 0x84, 0xB2, 0x7B, 0x16, 0x6B, 0x7B, 0xF5, 0xAC, 0x2F, 0x24, + 0x62, 0x30, 0x92, 0x0A, 0xC6, 0x67, 0x8B, 0x3F, 0xF9, 0xA3, 0x3F, 0xEC, + 0xBA, 0xA1, 0xEB, 0x6D, 0x37, 0x38, 0xEB, 0xC3, 0x60, 0x83, 0xF3, 0x31, + 0x04, 0xA4, 0xD5, 0x6C, 0x8C, 0x1A, 0xAC, 0x0F, 0x61, 0x94, 0xAF, 0x21, + 0xA9, 0x0D, 0xC6, 0x46, 0xB1, 0x1A, 0xEB, 0xC2, 0x98, 0xA9, 0xA5, 0x91, + 0x72, 0x4D, 0x08, 0x28, 0xCD, 0x11, 0x11, 0x5B, 0x4F, 0x08, 0xCE, 0xB9, + 0x90, 0x92, 0x4B, 0x41, 0x7D, 0x1F, 0xC4, 0x3B, 0xBB, 0xDC, 0xD1, 0x75, + 0x76, 0xB4, 0xD3, 0x42, 0x8C, 0x31, 0x06, 0x1F, 0x7D, 0x40, 0x1A, 0xD8, + 0x8E, 0x98, 0x22, 0x26, 0x8A, 0x87, 0x31, 0x01, 0x30, 0x26, 0xD8, 0x48, + 0x08, 0xE6, 0x5F, 0xB4, 0x05, 0xD8, 0xEF, 0x07, 0xFC, 0x20, 0xD2, 0x2D, + 0xA4, 0x14, 0x52, 0x5C, 0x5F, 0xDD, 0xFC, 0xEC, 0x17, 0xCF, 0x84, 0xCA, + 0x66, 0xF3, 0x69, 0x55, 0x95, 0x5A, 0x49, 0xAD, 0x64, 0x56, 0x64, 0x04, + 0x39, 0x8E, 0x4C, 0xA8, 0xF1, 0xA2, 0x8C, 0x47, 0x15, 0x63, 0xDA, 0x27, + 0x8C, 0x42, 0x2B, 0x99, 0x65, 0x4A, 0x29, 0xA9, 0xA5, 0x8C, 0x31, 0x1A, + 0xA3, 0x0F, 0xDD, 0xAB, 0x8F, 0x3F, 0x3B, 0xFF, 0x0F, 0x7F, 0xFA, 0x17, + 0xBF, 0xFA, 0xF4, 0x45, 0x9E, 0x67, 0x59, 0x66, 0xB6, 0x4D, 0xC7, 0x18, + 0x1F, 0xAC, 0x6B, 0xDA, 0xBE, 0xED, 0x87, 0xC1, 0xBA, 0x7E, 0xB0, 0x21, + 0x44, 0x2E, 0xF8, 0x58, 0x71, 0xC7, 0x48, 0x85, 0x9A, 0x52, 0xD2, 0x39, + 0xCB, 0xB9, 0x70, 0x21, 0xC6, 0x84, 0x5A, 0x29, 0xE7, 0x3C, 0x79, 0xF0, + 0x70, 0xC6, 0xA4, 0x92, 0x5A, 0x29, 0x93, 0x11, 0x1C, 0x24, 0xAD, 0xF7, + 0xD6, 0x7B, 0x63, 0x34, 0x9D, 0x78, 0x8C, 0x81, 0x3A, 0x33, 0x2E, 0x84, + 0x18, 0xA3, 0xF7, 0x9E, 0x2A, 0x74, 0xCA, 0x59, 0x48, 0x58, 0xD9, 0x3A, + 0xA7, 0x15, 0x6D, 0x2A, 0x4C, 0x4A, 0x4E, 0x13, 0x60, 0x87, 0xE6, 0x37, + 0x67, 0xCC, 0x87, 0xA0, 0x95, 0x2A, 0xCB, 0x42, 0x0A, 0xE1, 0xBD, 0x67, + 0x0C, 0x26, 0xD3, 0x8A, 0x04, 0x0F, 0xBC, 0xF5, 0x55, 0x91, 0x49, 0xC1, + 0x63, 0x8C, 0x82, 0xB1, 0xB2, 0xC8, 0xA4, 0xE0, 0x82, 0x71, 0xC6, 0x41, + 0x1B, 0x9D, 0x52, 0x8A, 0x88, 0xB9, 0x31, 0x11, 0x91, 0x33, 0x6E, 0x32, + 0x93, 0x19, 0xAD, 0x94, 0x2C, 0xCA, 0x62, 0xD7, 0xB4, 0xC3, 0x60, 0xE7, + 0xB3, 0x89, 0xF7, 0x61, 0xB3, 0xDD, 0x70, 0xC6, 0xF2, 0xCC, 0x50, 0x8E, + 0x0B, 0x09, 0x48, 0x70, 0xB5, 0x2E, 0xCB, 0x49, 0x5D, 0x4C, 0x26, 0x55, + 0x5D, 0x16, 0x0F, 0xCF, 0x8E, 0x17, 0x8B, 0x99, 0xE0, 0x8C, 0x33, 0x26, + 0xA5, 0xD0, 0x5A, 0x68, 0x29, 0x33, 0xAD, 0xC8, 0x05, 0x9D, 0x76, 0x0E, + 0xC1, 0xF8, 0x41, 0x23, 0x21, 0xED, 0x79, 0xDC, 0x0C, 0x40, 0x6B, 0xF5, + 0xF9, 0xF3, 0x0B, 0xC2, 0xF2, 0x26, 0x55, 0xD1, 0x34, 0x4D, 0x08, 0x51, + 0x2A, 0xA9, 0x94, 0x6C, 0xDB, 0xFE, 0xEA, 0x7A, 0x79, 0x79, 0x79, 0x43, + 0x70, 0x47, 0xDF, 0xDB, 0x2C, 0xCB, 0xBC, 0x0F, 0xD7, 0xB7, 0x2B, 0xA5, + 0xA4, 0xD1, 0x3A, 0xC6, 0x90, 0x52, 0xCA, 0x8C, 0xBE, 0x5D, 0x6E, 0x48, + 0x82, 0xD5, 0x68, 0x35, 0xA9, 0xCB, 0x61, 0xB0, 0xD3, 0xBA, 0x8C, 0x29, + 0xA5, 0x84, 0xE4, 0x07, 0x36, 0x58, 0x5B, 0xE4, 0xD9, 0xC9, 0x62, 0x4E, + 0x44, 0x0D, 0x0A, 0x1F, 0x84, 0xE1, 0xD0, 0x8A, 0xD5, 0x5A, 0x1F, 0xCD, + 0xA7, 0x98, 0xF0, 0xE3, 0x4F, 0x9E, 0x5B, 0xE7, 0xDB, 0xAE, 0xCF, 0x32, + 0x4D, 0xC3, 0x3D, 0x55, 0x59, 0x38, 0xEF, 0x76, 0x4D, 0xF7, 0xD5, 0xB7, + 0x9F, 0xCE, 0x26, 0x35, 0xED, 0x95, 0x5D, 0xD7, 0xEF, 0xDA, 0x2E, 0x61, + 0x42, 0xC4, 0xC5, 0xD1, 0x34, 0xCF, 0x33, 0x80, 0x34, 0x9B, 0x4D, 0x4E, + 0x16, 0xF3, 0xC9, 0xB4, 0xD2, 0x5A, 0xF9, 0x10, 0xA4, 0x90, 0x4D, 0xDB, + 0x59, 0xE7, 0xA5, 0xE4, 0x44, 0x00, 0xE6, 0x8C, 0x0B, 0x35, 0x7A, 0x4D, + 0x2B, 0xB2, 0x23, 0x17, 0x5C, 0x0A, 0xAE, 0xA5, 0xD4, 0x4A, 0x4B, 0xC1, + 0x85, 0x10, 0x99, 0xD1, 0x46, 0x89, 0x3C, 0x33, 0x4A, 0x4A, 0xE2, 0xD3, + 0x52, 0x6E, 0x2E, 0xA5, 0xE0, 0x8C, 0x93, 0x65, 0xA7, 0x75, 0xBE, 0x2E, + 0xF3, 0xF9, 0x6C, 0x22, 0x38, 0x23, 0x52, 0xCB, 0xE2, 0x68, 0x76, 0x79, + 0x7D, 0x2B, 0x85, 0xAC, 0xEB, 0x42, 0x6B, 0x19, 0x42, 0x28, 0xF2, 0x4C, + 0x29, 0x41, 0x3A, 0xBA, 0x75, 0x55, 0xD4, 0x75, 0xA1, 0x0D, 0x59, 0x2B, + 0x00, 0x8C, 0xD3, 0x60, 0x9C, 0x3C, 0x17, 0xEF, 0xE6, 0x8A, 0x38, 0xC9, + 0x92, 0x1E, 0xDA, 0x8B, 0xEC, 0xDE, 0x62, 0x1C, 0x51, 0xAD, 0x7B, 0x89, + 0x58, 0x4A, 0x89, 0x1F, 0x06, 0x6C, 0xBE, 0x1C, 0xC5, 0xD2, 0x48, 0x80, + 0xBD, 0xF7, 0x8A, 0x2F, 0x1B, 0x24, 0x1E, 0x5E, 0xF2, 0xEB, 0x65, 0xA9, + 0xB4, 0xD6, 0xED, 0xDA, 0x61, 0xB0, 0x7E, 0x5C, 0xD2, 0xFB, 0x60, 0x89, + 0x88, 0xA0, 0x65, 0xDF, 0x3B, 0xF2, 0x7C, 0xC6, 0xFD, 0x9B, 0xB0, 0x94, + 0x30, 0x26, 0x00, 0x08, 0x11, 0x05, 0xE7, 0x42, 0xB0, 0x18, 0x11, 0x80, + 0x91, 0xF4, 0x25, 0x1B, 0x73, 0x01, 0xE2, 0x28, 0x8C, 0xF3, 0x95, 0x90, + 0xF0, 0x70, 0x39, 0x22, 0x12, 0x2E, 0x05, 0x8C, 0x33, 0x64, 0x54, 0x2A, + 0x22, 0xE9, 0x12, 0x92, 0xF8, 0xD9, 0x3E, 0xC2, 0xA5, 0x94, 0x00, 0x90, + 0xE4, 0x47, 0x18, 0x26, 0xE0, 0x0C, 0xF6, 0xCE, 0xBB, 0x5F, 0xA0, 0x9F, + 0x1C, 0x76, 0x84, 0xFD, 0x1C, 0x16, 0x00, 0xE3, 0x46, 0xAB, 0x18, 0xFD, + 0xCF, 0x7E, 0xFE, 0xE9, 0x72, 0xDD, 0x1F, 0x2D, 0x16, 0x4A, 0x89, 0x10, + 0x02, 0x83, 0xA4, 0x94, 0x14, 0x42, 0x24, 0x84, 0xC4, 0x88, 0xFB, 0x4A, + 0x19, 0x2F, 0x0B, 0x01, 0x0F, 0xFB, 0x4C, 0x88, 0x09, 0x68, 0x21, 0x71, + 0x2E, 0x04, 0xE3, 0x9C, 0x13, 0x4C, 0xA6, 0x35, 0xC9, 0x60, 0xC0, 0xC5, + 0xE5, 0xCD, 0x5F, 0xFE, 0xCD, 0x8F, 0x7F, 0xF6, 0xCB, 0x4F, 0xA7, 0x93, + 0xC9, 0x9B, 0x4F, 0x5F, 0xDF, 0xB5, 0x6D, 0xD3, 0x0E, 0xDB, 0xA6, 0x2B, + 0x32, 0xD3, 0x59, 0x9B, 0x69, 0xC3, 0x39, 0xB3, 0xD6, 0xF9, 0x10, 0x18, + 0x63, 0x55, 0x51, 0x30, 0xC6, 0x20, 0xA5, 0xB2, 0xC8, 0xB9, 0xE0, 0xDE, + 0x05, 0x17, 0xBC, 0x14, 0x22, 0xC4, 0x80, 0x18, 0x81, 0xB1, 0x18, 0xE2, + 0xE0, 0x9D, 0x92, 0xB2, 0x20, 0xD6, 0xA0, 0x94, 0xD6, 0xBA, 0x7D, 0x90, + 0x8A, 0x21, 0x62, 0x55, 0xE4, 0x14, 0xFA, 0xC3, 0xFE, 0x06, 0x72, 0x34, + 0x85, 0x9C, 0x92, 0xE0, 0x34, 0x3D, 0x9A, 0x38, 0xE7, 0x11, 0x43, 0x99, + 0x1B, 0xE7, 0x03, 0xE1, 0xAE, 0x09, 0x10, 0x00, 0x19, 0xC8, 0x4C, 0x2B, + 0xDA, 0xA2, 0x21, 0x41, 0x8C, 0x31, 0xA4, 0xC4, 0x39, 0xA7, 0xA0, 0xB9, + 0xDD, 0xED, 0xCA, 0x22, 0x9F, 0x4C, 0xAA, 0xF9, 0x6C, 0x12, 0x62, 0x04, + 0x8C, 0x4D, 0xD3, 0x85, 0x10, 0x72, 0xA3, 0x89, 0xF9, 0xE9, 0x43, 0x40, + 0x44, 0x48, 0x50, 0x15, 0x15, 0x0D, 0x09, 0x91, 0xAC, 0x93, 0x10, 0x82, + 0x2C, 0x66, 0xA8, 0x6F, 0xBB, 0x5A, 0x6D, 0xFA, 0x61, 0x58, 0x1C, 0x4D, + 0x8D, 0xD6, 0x4D, 0xDB, 0x32, 0xC6, 0x04, 0x17, 0x4D, 0xDB, 0xB5, 0x5D, + 0xE7, 0xBD, 0x57, 0x42, 0x4E, 0x67, 0x35, 0xB0, 0xC4, 0x81, 0xD7, 0x93, + 0x72, 0x56, 0x54, 0xF3, 0x49, 0x05, 0x00, 0x5A, 0x2B, 0x12, 0x23, 0x94, + 0x99, 0xA6, 0xF1, 0x7B, 0xB2, 0xC8, 0x42, 0xF2, 0xCB, 0xE2, 0x8C, 0x4B, + 0x89, 0x7B, 0x65, 0x37, 0x62, 0xBA, 0x70, 0xC1, 0x95, 0x12, 0x29, 0xC9, + 0xC5, 0x7C, 0xE2, 0x5D, 0x98, 0xD4, 0xE5, 0x83, 0xE3, 0xB9, 0xD6, 0xBA, + 0xDD, 0xB5, 0xBB, 0x6D, 0x73, 0xF6, 0xE0, 0xB8, 0x2C, 0x0B, 0xAD, 0xE4, + 0x3B, 0x6F, 0x3E, 0xE9, 0xBB, 0xA1, 0xB7, 0x43, 0x88, 0x68, 0xAD, 0x9D, + 0xD4, 0xA5, 0xF7, 0xFE, 0xE3, 0x4F, 0x9E, 0x4F, 0x26, 0x55, 0x55, 0xE6, + 0x94, 0x3F, 0x16, 0x79, 0xB6, 0xDE, 0x6C, 0x0A, 0xCC, 0x2E, 0xAF, 0x6E, + 0xEB, 0xAA, 0xA8, 0xCB, 0xDC, 0x3B, 0xB7, 0x98, 0x4F, 0xFA, 0xCC, 0xEC, + 0x9A, 0x56, 0x4A, 0xF1, 0xF8, 0xE1, 0x69, 0x8C, 0xD1, 0x64, 0xCA, 0x64, + 0xCA, 0x5A, 0x8F, 0x38, 0x5A, 0x43, 0xC2, 0x5E, 0x08, 0x3E, 0x84, 0xA4, + 0xB5, 0x2A, 0x72, 0xF3, 0xE0, 0xF4, 0xC8, 0x68, 0xB5, 0xD9, 0x36, 0x3E, + 0xF8, 0xCD, 0xB6, 0x31, 0x5A, 0x2A, 0x25, 0xB0, 0xC5, 0xB2, 0xC8, 0xDE, + 0xFB, 0xC6, 0x57, 0xC8, 0x3F, 0x7C, 0xFD, 0xC9, 0xE7, 0xDE, 0x87, 0x7E, + 0x18, 0x6E, 0xD7, 0xDB, 0xF9, 0x7C, 0x7A, 0xB3, 0xDC, 0x28, 0xD9, 0xC4, + 0x18, 0x37, 0xDB, 0x06, 0x11, 0x67, 0xD3, 0xFA, 0xD1, 0xC3, 0x33, 0x62, + 0xAE, 0x19, 0x2D, 0x31, 0xA5, 0x82, 0xDC, 0xD2, 0x18, 0xCD, 0xFB, 0x1E, + 0x7A, 0x82, 0x64, 0xC6, 0xCA, 0x18, 0x10, 0x75, 0x06, 0x18, 0x03, 0xB9, + 0x5F, 0x0F, 0x29, 0x25, 0xD2, 0x7D, 0x1D, 0x53, 0x17, 0x92, 0x0E, 0xA4, + 0xD0, 0xCB, 0xA9, 0x2A, 0x82, 0x18, 0x62, 0x5D, 0x17, 0x84, 0x41, 0x7B, + 0xEF, 0x8B, 0xDC, 0xE4, 0x66, 0x94, 0xA6, 0xE0, 0x5C, 0x90, 0x32, 0x4F, + 0x4A, 0x29, 0xCB, 0x74, 0x6E, 0xB4, 0x52, 0x42, 0xDC, 0x15, 0x3D, 0x8C, + 0x01, 0x70, 0x0E, 0x7C, 0xBF, 0x08, 0x01, 0x80, 0x41, 0x22, 0x4F, 0x5B, + 0x0A, 0x0C, 0x74, 0x14, 0xFB, 0x15, 0x79, 0x3F, 0x00, 0xC1, 0x01, 0x20, + 0xDB, 0x87, 0x9E, 0x7F, 0x24, 0x17, 0x4B, 0x40, 0x7E, 0x02, 0xF7, 0x05, + 0x66, 0xF0, 0xFE, 0xD3, 0xEE, 0xC7, 0xAF, 0x5F, 0xFF, 0x3B, 0xFB, 0xF1, + 0x8F, 0x7E, 0x64, 0xAD, 0xC7, 0x98, 0x12, 0xDC, 0x4D, 0xF9, 0x00, 0x80, + 0x52, 0x02, 0xC6, 0xF9, 0x55, 0x82, 0xA5, 0xE0, 0xD0, 0x44, 0x60, 0xC0, + 0x38, 0x63, 0x62, 0x9C, 0xE1, 0x4C, 0xFB, 0x69, 0xC4, 0x43, 0x3E, 0xC9, + 0xEE, 0x7F, 0x20, 0x03, 0xE0, 0x0C, 0x0E, 0x40, 0x20, 0xFD, 0x6F, 0x7A, + 0xAF, 0x43, 0x30, 0xA2, 0x91, 0xF0, 0xC3, 0xCB, 0x49, 0x54, 0x36, 0x84, + 0x18, 0xC7, 0xF6, 0xE8, 0xFE, 0x4B, 0x12, 0x64, 0xF4, 0x73, 0x37, 0xE8, + 0x40, 0xE9, 0x49, 0x1A, 0x5D, 0x29, 0x19, 0xE7, 0x20, 0x84, 0x12, 0x9C, + 0x6D, 0xD6, 0xEB, 0x5F, 0x7D, 0x7A, 0xBE, 0x69, 0xDC, 0xD9, 0xD9, 0x89, + 0xD6, 0x9A, 0x01, 0x6A, 0x25, 0x13, 0xB5, 0x69, 0x95, 0x4C, 0x04, 0xAB, + 0x21, 0x60, 0x42, 0x80, 0x44, 0xE9, 0xE7, 0xE1, 0xAD, 0x10, 0x11, 0x11, + 0x8C, 0x51, 0x63, 0x14, 0x06, 0x96, 0x12, 0x92, 0xF3, 0x18, 0xE7, 0xFC, + 0x83, 0x8F, 0x3E, 0xFF, 0xD3, 0xFF, 0xEB, 0xAF, 0x97, 0xEB, 0x46, 0x08, + 0x9E, 0x19, 0x13, 0x70, 0x2C, 0xA7, 0x07, 0x6B, 0xE9, 0x1E, 0x2F, 0x8B, + 0xDC, 0x87, 0x40, 0x12, 0x92, 0x4A, 0xCA, 0x04, 0xD0, 0x0D, 0xBD, 0xE0, + 0x7C, 0x52, 0x55, 0x21, 0x86, 0xA1, 0xB7, 0x00, 0x49, 0x6B, 0x35, 0x0C, + 0xCE, 0xE4, 0x06, 0x43, 0xB4, 0xCE, 0x2B, 0xAD, 0xCA, 0x2C, 0xA3, 0x04, + 0xB6, 0xED, 0x7A, 0xEB, 0x2C, 0x49, 0xFA, 0x0E, 0xCE, 0x03, 0x80, 0x92, + 0x2A, 0x86, 0x20, 0x25, 0x67, 0x8C, 0x13, 0x4B, 0x96, 0xF8, 0xBA, 0x31, + 0x46, 0x52, 0x41, 0x29, 0xF3, 0xDC, 0x68, 0xD5, 0x5B, 0x2B, 0x38, 0xDF, + 0x75, 0x5D, 0x91, 0x65, 0x1C, 0xA0, 0x19, 0x06, 0x1F, 0x82, 0x91, 0x2A, + 0x33, 0x26, 0xEE, 0x39, 0xC6, 0x07, 0xD6, 0x4B, 0x96, 0x91, 0x11, 0x37, + 0xCE, 0x67, 0xB5, 0x31, 0x3A, 0xCF, 0xB3, 0x9B, 0x9B, 0x55, 0xF4, 0x1E, + 0x23, 0x29, 0x7A, 0xF3, 0xC1, 0x5A, 0xE7, 0xA3, 0x0F, 0x41, 0x2B, 0x21, + 0x38, 0x07, 0x80, 0x2C, 0x23, 0xD3, 0x5E, 0x25, 0xF7, 0x02, 0x9C, 0x79, + 0x9E, 0x0F, 0xC3, 0xB0, 0xD9, 0xEC, 0xA4, 0x94, 0x99, 0x51, 0xB3, 0xD9, + 0x04, 0x80, 0x8A, 0x74, 0x34, 0x5A, 0xFB, 0x10, 0x88, 0xA9, 0xAF, 0x94, + 0x98, 0x54, 0x65, 0x51, 0x66, 0x45, 0x9E, 0x17, 0xB9, 0xA9, 0xAB, 0xA2, + 0xC8, 0x8C, 0x90, 0x52, 0x08, 0x01, 0x90, 0x48, 0x00, 0x85, 0x76, 0x50, + 0x2E, 0x78, 0xC2, 0x91, 0xE9, 0xC2, 0xF7, 0xD2, 0x9E, 0x87, 0xDD, 0x98, + 0xFE, 0x80, 0x31, 0x61, 0x8A, 0xD6, 0xFA, 0xAE, 0x1B, 0xB4, 0x52, 0xC4, + 0x1A, 0x0D, 0x31, 0x32, 0x80, 0xAE, 0xB7, 0xB4, 0xF3, 0x20, 0xC6, 0x18, + 0xA2, 0xB5, 0x0E, 0x11, 0xB7, 0x4D, 0xE3, 0x43, 0x9C, 0x4E, 0x27, 0x4D, + 0xDB, 0x3B, 0xE7, 0xE6, 0xB3, 0xE9, 0x7C, 0x3E, 0x1D, 0xAC, 0x3D, 0x59, + 0xCC, 0x2F, 0x2F, 0x6F, 0x9A, 0x6E, 0x28, 0xCB, 0xBC, 0xD9, 0xB5, 0xAF, + 0x3F, 0x79, 0xE0, 0xBC, 0x97, 0x52, 0x69, 0xAD, 0xF3, 0xDC, 0x90, 0x6C, + 0x1C, 0x85, 0x2C, 0xE2, 0x48, 0xEE, 0xEF, 0x8D, 0xC4, 0x58, 0x22, 0xCE, + 0x04, 0xD5, 0x25, 0x8C, 0xB1, 0xDB, 0xE5, 0x7A, 0xBB, 0x6D, 0xD6, 0x9B, + 0xC6, 0x0E, 0xCE, 0x79, 0xEF, 0x7C, 0xB8, 0x5D, 0x6F, 0xD7, 0x9B, 0xDD, + 0x57, 0xDF, 0x79, 0x73, 0x52, 0x57, 0x98, 0xF0, 0xFC, 0xE5, 0x65, 0x88, + 0xB1, 0xEB, 0xFA, 0xD5, 0x7A, 0xF3, 0xF5, 0x77, 0xDF, 0x8E, 0x21, 0x36, + 0x4D, 0x97, 0xE7, 0xA6, 0x2A, 0x73, 0x5A, 0x71, 0x45, 0x91, 0x55, 0x55, + 0x51, 0x57, 0x45, 0x0C, 0x48, 0x5A, 0x37, 0x98, 0xB0, 0xC8, 0x33, 0xAA, + 0x00, 0x52, 0x22, 0x3D, 0x84, 0x71, 0xB1, 0x60, 0x4A, 0x52, 0x70, 0xB9, + 0x9F, 0xCC, 0x1B, 0x43, 0x1B, 0x03, 0x6A, 0xB3, 0xC2, 0x18, 0xE8, 0xD2, + 0x9E, 0xE4, 0x00, 0x00, 0x10, 0x61, 0xEC, 0xBC, 0x53, 0xD1, 0x03, 0x00, + 0x31, 0xE0, 0x72, 0xB5, 0x19, 0x06, 0x77, 0xD0, 0x23, 0xA0, 0xE8, 0x86, + 0x09, 0x39, 0xE7, 0x75, 0x51, 0xE4, 0x85, 0x21, 0xF7, 0x36, 0x62, 0x35, + 0xD0, 0x5A, 0x53, 0x5A, 0x4A, 0xC9, 0x29, 0x6D, 0x10, 0x82, 0x09, 0x12, + 0x71, 0x66, 0x2C, 0x01, 0x19, 0xC6, 0x52, 0x38, 0x62, 0x23, 0x7F, 0x64, + 0xFC, 0xDE, 0xD8, 0xBE, 0x48, 0xBC, 0xCF, 0x9F, 0xF8, 0x72, 0x48, 0xA2, + 0x63, 0x40, 0x24, 0x43, 0xD9, 0x2F, 0x53, 0x31, 0x0E, 0xBF, 0x1C, 0x08, + 0x19, 0xF4, 0x26, 0xFB, 0x3E, 0x66, 0x0A, 0x88, 0xE2, 0x0F, 0xFE, 0xA7, + 0x7F, 0x47, 0x29, 0x55, 0x1A, 0xCB, 0x43, 0x3E, 0xAA, 0xE4, 0x70, 0xE2, + 0x7C, 0x1F, 0x32, 0xBA, 0x71, 0xBC, 0x60, 0x54, 0x10, 0x04, 0x36, 0x86, + 0x8E, 0x2F, 0xC9, 0x49, 0x8C, 0x3E, 0x6E, 0x63, 0x04, 0x60, 0x0C, 0x12, + 0x30, 0xBE, 0xD7, 0x03, 0x18, 0x4F, 0x87, 0xF1, 0xFB, 0xE1, 0x94, 0x73, + 0x4E, 0x6F, 0x3E, 0x16, 0x87, 0x82, 0x23, 0x1E, 0x7C, 0x19, 0x80, 0xCA, + 0xC5, 0x7B, 0x09, 0x17, 0xDB, 0xE7, 0xF7, 0x89, 0x74, 0x7C, 0xEE, 0x27, + 0x63, 0x52, 0x0A, 0xEF, 0xFD, 0x67, 0x9F, 0x9F, 0x5F, 0x5C, 0xEF, 0x12, + 0x53, 0x79, 0x6E, 0xCA, 0xB2, 0x60, 0x80, 0x8C, 0xB1, 0x57, 0xAF, 0x6E, + 0x9B, 0x76, 0x98, 0xD4, 0xC5, 0x3E, 0x8B, 0xA1, 0x2F, 0x1E, 0x02, 0x41, + 0x65, 0xFB, 0x9D, 0x87, 0xE6, 0xEC, 0xB5, 0x56, 0x4A, 0x09, 0x7A, 0x5F, + 0xA5, 0x24, 0x29, 0x2E, 0x38, 0x1F, 0x7F, 0xF5, 0xD9, 0xF9, 0x7F, 0xFE, + 0x7F, 0xFE, 0xCB, 0x6A, 0xD3, 0x92, 0xD6, 0xEB, 0x60, 0x6D, 0x37, 0x58, + 0xCE, 0xB9, 0x75, 0x8E, 0x68, 0xFD, 0x5A, 0xCA, 0x93, 0xC5, 0x3C, 0x01, + 0xE4, 0x99, 0x01, 0x80, 0x10, 0x42, 0x4C, 0x98, 0x00, 0x7C, 0xF0, 0x0C, + 0xC6, 0xD9, 0x26, 0x9A, 0x5F, 0x61, 0x8C, 0x21, 0xC6, 0x04, 0xA9, 0x2A, + 0x0A, 0xB5, 0x8F, 0x2F, 0xBD, 0x1D, 0xE8, 0x76, 0xED, 0x07, 0xCB, 0x38, + 0xA7, 0x76, 0x07, 0x63, 0x4C, 0x4B, 0xA9, 0x8D, 0xB6, 0xCE, 0xF9, 0x18, + 0x0F, 0x83, 0xB1, 0x74, 0xDE, 0x01, 0x63, 0x99, 0x67, 0x9C, 0x31, 0xE7, + 0xBD, 0x0F, 0x11, 0x60, 0x74, 0xB1, 0x75, 0xDE, 0x0B, 0xCE, 0x95, 0x52, + 0xE4, 0x4A, 0x47, 0xA5, 0x34, 0xED, 0xB7, 0x09, 0x80, 0x6A, 0xF9, 0xAA, + 0xC8, 0x31, 0x84, 0xBE, 0xED, 0xEC, 0xE0, 0x76, 0x0D, 0xF1, 0x27, 0x24, + 0x63, 0xDC, 0x79, 0x4F, 0xD7, 0x39, 0x33, 0x9A, 0xA6, 0x3E, 0x84, 0x10, + 0xC6, 0x18, 0xAD, 0xA5, 0xD6, 0xA6, 0x28, 0x72, 0xEF, 0xBD, 0xD6, 0xDA, + 0x79, 0x7F, 0x79, 0x73, 0x1B, 0x63, 0x34, 0x5A, 0xD5, 0x65, 0x49, 0x22, + 0x65, 0x00, 0x69, 0x18, 0x6C, 0xD7, 0x0F, 0xB3, 0xE9, 0xA4, 0xAE, 0x8A, + 0x2C, 0xD7, 0x55, 0x55, 0x54, 0x65, 0x2E, 0x04, 0x57, 0x4A, 0x52, 0x46, + 0x4C, 0x14, 0x53, 0x18, 0x69, 0xCA, 0xC0, 0xF6, 0xE2, 0xE4, 0x87, 0x7F, + 0x0A, 0x29, 0x18, 0x67, 0x64, 0x4F, 0x7A, 0xB8, 0xEB, 0x68, 0xB1, 0xD2, + 0x3E, 0xAA, 0xB5, 0xA4, 0xE9, 0x1C, 0x36, 0x56, 0xA6, 0x2A, 0xA5, 0xD4, + 0x0D, 0xB6, 0x6D, 0xFB, 0xE0, 0x7D, 0xD7, 0x0D, 0xCE, 0xF9, 0xF1, 0xC9, + 0x63, 0x0A, 0x03, 0x0C, 0x20, 0x45, 0x1C, 0x06, 0x6B, 0xAD, 0x23, 0x09, + 0xA3, 0xE3, 0xC5, 0x7C, 0xB5, 0xDA, 0x26, 0x48, 0xD3, 0x49, 0x45, 0xB8, + 0xE1, 0xE5, 0xD5, 0x6D, 0xD3, 0x77, 0xD3, 0x49, 0x8D, 0x88, 0x64, 0xC6, + 0x21, 0x47, 0xDD, 0x05, 0xB9, 0xBF, 0x57, 0xD9, 0x1E, 0xDF, 0xA1, 0x9E, + 0x1A, 0x00, 0x40, 0x91, 0x67, 0xD3, 0x49, 0x3D, 0xA9, 0x8B, 0xB2, 0xC8, + 0x1E, 0x9E, 0x1D, 0x57, 0x55, 0x99, 0x19, 0xFD, 0xE4, 0xF1, 0xD9, 0x57, + 0xDF, 0x7E, 0xFA, 0xE9, 0xB3, 0xF3, 0x67, 0x2F, 0x2E, 0x84, 0x10, 0x6F, + 0x3D, 0x7D, 0xF2, 0xC1, 0x87, 0x1F, 0xCF, 0xA6, 0x93, 0x27, 0x8F, 0x1E, + 0x5C, 0x5E, 0xDD, 0x08, 0x21, 0x86, 0xC1, 0x16, 0x79, 0x0E, 0x29, 0x49, + 0x21, 0x62, 0xC4, 0x10, 0xE3, 0xB4, 0xAE, 0xA5, 0x14, 0xCE, 0x7A, 0x60, + 0x69, 0x3A, 0xA9, 0x29, 0x93, 0x08, 0x21, 0xB2, 0x51, 0xAD, 0x13, 0xD9, + 0x3E, 0x9B, 0x60, 0x9C, 0xC2, 0x07, 0x4B, 0x00, 0x98, 0x18, 0x12, 0x07, + 0x2C, 0xD1, 0x7C, 0xE2, 0x28, 0x7F, 0x45, 0x92, 0x58, 0x71, 0x0C, 0x10, + 0x87, 0x4B, 0x31, 0x62, 0x32, 0x5C, 0xF0, 0x2C, 0x33, 0x4A, 0x09, 0x25, + 0x25, 0xB9, 0x39, 0x8E, 0x18, 0x77, 0x82, 0x3C, 0x33, 0x26, 0x53, 0x34, + 0x42, 0x40, 0xE0, 0x38, 0xC1, 0x44, 0x42, 0x12, 0x32, 0xC1, 0xE9, 0x2B, + 0x90, 0xFB, 0x52, 0x08, 0xC6, 0xB9, 0xC8, 0xC4, 0x90, 0x6A, 0xC3, 0xB4, + 0x2F, 0x1E, 0xD3, 0x9D, 0x0F, 0xC7, 0xBE, 0xB4, 0x84, 0x7B, 0x40, 0xFE, + 0xFD, 0x10, 0xF6, 0x85, 0x08, 0xF3, 0xFF, 0x5B, 0x45, 0xDE, 0x69, 0x37, + 0xDC, 0x7F, 0xD0, 0xE7, 0x49, 0xDA, 0xD5, 0x31, 0x21, 0x85, 0x0C, 0x3A, + 0x14, 0xC1, 0x18, 0x75, 0x84, 0xE9, 0x2A, 0xC0, 0x3D, 0x45, 0xFC, 0x83, + 0xB5, 0x07, 0x5D, 0xA2, 0xFB, 0xF6, 0xBB, 0x6C, 0x7F, 0xCC, 0xE4, 0x95, + 0x9B, 0x46, 0xE9, 0xB4, 0xC4, 0xD9, 0x58, 0x0F, 0xEE, 0x2B, 0x46, 0xB2, + 0xA1, 0x4C, 0x69, 0x3F, 0xDF, 0x73, 0xFF, 0x88, 0x49, 0xD6, 0x96, 0x76, + 0xE0, 0xC3, 0xDF, 0x0F, 0x51, 0xEC, 0x70, 0x7E, 0x87, 0xFC, 0x95, 0xED, + 0x3F, 0x57, 0x2B, 0x19, 0x83, 0xFB, 0xFB, 0x1F, 0xFF, 0x72, 0xF0, 0x60, + 0x8C, 0x86, 0x68, 0x8F, 0xE6, 0xB3, 0xF5, 0x7A, 0x7B, 0x79, 0xB3, 0x0C, + 0x01, 0x11, 0xF1, 0xB5, 0x47, 0xA7, 0x84, 0xD5, 0xD1, 0x65, 0x62, 0x9C, + 0x90, 0x3E, 0xD8, 0xCF, 0xB2, 0x02, 0xE7, 0x9C, 0xB0, 0x09, 0x80, 0xB1, + 0x83, 0x49, 0x5C, 0x50, 0xEB, 0x7D, 0xF0, 0xF1, 0xC7, 0xEF, 0x7F, 0xF4, + 0x83, 0x7F, 0xF8, 0xF9, 0xB6, 0xED, 0x69, 0xD7, 0x02, 0x06, 0x52, 0xA9, + 0x80, 0x96, 0xD6, 0x80, 0x1C, 0x69, 0xA5, 0xC9, 0x59, 0x37, 0x0C, 0x43, + 0x88, 0x68, 0xB4, 0x62, 0x9C, 0x0B, 0x06, 0x44, 0x46, 0xE9, 0xAC, 0xCB, + 0xB5, 0xA2, 0x01, 0x14, 0x48, 0x29, 0x20, 0x6A, 0x25, 0xB4, 0x54, 0x5A, + 0x49, 0xEB, 0x5C, 0x4A, 0x29, 0x62, 0x4C, 0x29, 0xD1, 0xEC, 0x55, 0xA6, + 0x75, 0xD8, 0x47, 0x31, 0x44, 0x44, 0xCE, 0x31, 0xC6, 0xC1, 0x39, 0x06, + 0x2C, 0x37, 0x3A, 0x37, 0xAA, 0x1F, 0x1C, 0x63, 0x90, 0x67, 0x66, 0xBD, + 0x8B, 0x82, 0x5A, 0x87, 0x42, 0xF8, 0x60, 0xBD, 0xF7, 0x4A, 0x88, 0xD1, + 0x8E, 0x41, 0x48, 0x9A, 0x9C, 0x4D, 0x88, 0xB4, 0xB5, 0xB2, 0x71, 0x5E, + 0x75, 0x6F, 0x8C, 0x12, 0x23, 0x6D, 0x04, 0x7D, 0xD7, 0x0B, 0xFA, 0xEA, + 0x13, 0xB3, 0x6E, 0x60, 0x8C, 0x49, 0x29, 0x33, 0x23, 0x46, 0xEB, 0x56, + 0xCE, 0x95, 0x14, 0x11, 0xB1, 0xEB, 0x06, 0x29, 0x95, 0x56, 0x52, 0xD4, + 0x95, 0xF7, 0xC1, 0x59, 0x97, 0x69, 0x6D, 0xB4, 0x9E, 0x4D, 0x6B, 0x25, + 0xA5, 0xD6, 0x6A, 0xBB, 0x6D, 0xDA, 0xB6, 0xCF, 0x32, 0xBD, 0x38, 0x9A, + 0x3F, 0x7A, 0x70, 0x52, 0x96, 0x99, 0xB3, 0x8E, 0xBE, 0x68, 0x25, 0xA5, + 0x56, 0x8A, 0x0B, 0x9E, 0x48, 0x0B, 0x94, 0x8D, 0x9B, 0xC7, 0x1D, 0x6F, + 0x7E, 0xCF, 0x33, 0xA2, 0x9B, 0x8D, 0xED, 0xF7, 0xED, 0xFD, 0xFE, 0x0A, + 0x00, 0x18, 0x23, 0x26, 0x84, 0x10, 0x62, 0xDA, 0x9B, 0x9C, 0xD2, 0x59, + 0x84, 0x10, 0xD7, 0x9B, 0x9D, 0x0F, 0x91, 0x98, 0x8F, 0x4D, 0xDB, 0x37, + 0x6D, 0x9F, 0x17, 0x46, 0x70, 0x5E, 0x55, 0x05, 0x62, 0x8C, 0x91, 0x29, + 0xAD, 0xDB, 0xA6, 0x9B, 0x4C, 0xEB, 0xED, 0xAE, 0x81, 0x9E, 0x97, 0x45, + 0x5E, 0x21, 0xBE, 0xF9, 0xC6, 0xE3, 0x4F, 0x3F, 0x7B, 0x71, 0x75, 0xBD, + 0x44, 0x8C, 0x4F, 0x1E, 0x3F, 0x14, 0x52, 0x3C, 0x7B, 0xF6, 0xB2, 0x69, + 0xBA, 0x37, 0x9F, 0x3E, 0xAE, 0xAB, 0x2A, 0x86, 0xF8, 0xEA, 0xEA, 0xB6, + 0x2C, 0xF2, 0x49, 0x5D, 0xE6, 0x79, 0xC6, 0xF6, 0xF0, 0xC8, 0xFD, 0x03, + 0x3B, 0x04, 0xB8, 0xBA, 0x2E, 0xC8, 0x56, 0x56, 0x69, 0x35, 0x9F, 0xD5, + 0x42, 0x88, 0xF3, 0x97, 0x57, 0xB7, 0xCB, 0xD5, 0xC3, 0xB3, 0xE3, 0x6F, + 0x7D, 0xFD, 0xED, 0x4F, 0x3E, 0x3B, 0x9F, 0xD6, 0xD5, 0xC9, 0x62, 0x4E, + 0x8A, 0xD2, 0x04, 0x4D, 0xAE, 0x36, 0x9B, 0x69, 0x55, 0x35, 0x9D, 0xCB, + 0x33, 0x53, 0xCA, 0x6C, 0xDB, 0x34, 0x47, 0xB3, 0x09, 0x30, 0xCA, 0xC1, + 0x23, 0xE7, 0x0C, 0xC7, 0x79, 0x12, 0x86, 0x91, 0x98, 0xE7, 0x89, 0x30, + 0xE8, 0x84, 0x29, 0x7E, 0xA1, 0x58, 0xBB, 0x5B, 0x83, 0x77, 0x2B, 0x7B, + 0x5C, 0xA2, 0xB0, 0x9F, 0x45, 0x61, 0x87, 0xDD, 0x7A, 0x9F, 0x61, 0xF1, + 0xB2, 0xCC, 0xB3, 0x4C, 0x7B, 0x47, 0x2A, 0x8F, 0x91, 0x3E, 0x4B, 0x4A, + 0xB1, 0xD7, 0x2E, 0xE4, 0x84, 0xA6, 0x2B, 0x25, 0x95, 0x96, 0x87, 0x92, + 0x25, 0x8D, 0xE8, 0x76, 0x4A, 0x7C, 0x1F, 0x9B, 0x00, 0x00, 0x00, 0x81, + 0xD3, 0x6F, 0x14, 0xCB, 0x0E, 0x2C, 0xFC, 0x7B, 0x87, 0x95, 0x0E, 0x09, + 0xD3, 0x61, 0x69, 0x8F, 0x8F, 0x7D, 0x5F, 0xF2, 0x1F, 0x0D, 0x61, 0x87, + 0xFF, 0x8E, 0x09, 0xDF, 0x1E, 0x33, 0xA5, 0x3B, 0x66, 0x14, 0x74, 0xFA, + 0x77, 0x7F, 0xF0, 0xEF, 0x0F, 0xB9, 0x18, 0x00, 0x8C, 0x48, 0x3C, 0xD5, + 0xAB, 0xFB, 0x1B, 0xEB, 0xFE, 0x85, 0xB8, 0x1F, 0xCB, 0xF6, 0x57, 0xE6, + 0xEE, 0x5A, 0xDE, 0x5D, 0x2E, 0x36, 0x86, 0x98, 0x03, 0x74, 0x35, 0xD6, + 0x98, 0xFB, 0x38, 0xCE, 0xBE, 0xF8, 0x38, 0x7C, 0x44, 0xFA, 0x02, 0xE0, + 0xF5, 0xC5, 0x8F, 0xBD, 0x8F, 0x88, 0xD1, 0xCD, 0xCF, 0x39, 0x00, 0x68, + 0xAD, 0x33, 0xA3, 0x3E, 0xFC, 0xF0, 0x93, 0xBF, 0x7F, 0xFF, 0xE3, 0x5D, + 0xE3, 0xEA, 0xAA, 0xAC, 0xAA, 0x0A, 0x80, 0x7D, 0xFE, 0xE2, 0xE2, 0xE7, + 0x1F, 0x7D, 0x1E, 0x31, 0x19, 0xAD, 0x1F, 0x9E, 0x2E, 0xCE, 0x4E, 0xE6, + 0xDA, 0x68, 0xCE, 0x79, 0x22, 0x29, 0x0F, 0x18, 0x6B, 0xB4, 0x7D, 0xFC, + 0xA2, 0x68, 0x4B, 0x52, 0x3C, 0x90, 0x12, 0x30, 0xCE, 0x03, 0x46, 0xEB, + 0x63, 0xDF, 0xD9, 0xBF, 0xFA, 0xDB, 0x1F, 0xFF, 0xDD, 0x8F, 0x7E, 0xD1, + 0x74, 0x03, 0x9D, 0xBA, 0x94, 0x52, 0x49, 0xC9, 0x39, 0xC7, 0x7D, 0x1C, + 0xCF, 0x8D, 0x41, 0x44, 0xC9, 0x05, 0x67, 0x40, 0xB8, 0x15, 0x5D, 0x6E, + 0x2E, 0xC4, 0x30, 0x58, 0xEF, 0x03, 0x90, 0x31, 0x0C, 0x1F, 0xBF, 0x7C, + 0xEF, 0xBD, 0x56, 0x4A, 0x30, 0xE6, 0x83, 0x4F, 0x69, 0x24, 0xDF, 0xE6, + 0x46, 0x33, 0x00, 0x25, 0x04, 0x11, 0x56, 0x09, 0xE0, 0xE0, 0x7C, 0xEC, + 0x78, 0x77, 0xC3, 0x30, 0x1A, 0xF9, 0xC5, 0x48, 0x43, 0x14, 0xD6, 0xB9, + 0x22, 0x33, 0x14, 0x31, 0xAD, 0xF7, 0x9C, 0x3A, 0x21, 0x6C, 0xD4, 0x3D, + 0xB1, 0xCE, 0x29, 0x29, 0x29, 0x71, 0x20, 0xBA, 0x3D, 0x65, 0xA2, 0x54, + 0x93, 0x52, 0xAB, 0x94, 0x86, 0xAE, 0xB8, 0x14, 0x45, 0x9E, 0x65, 0x46, + 0x0B, 0xC1, 0x89, 0x74, 0x06, 0x9C, 0xC5, 0x84, 0x24, 0x52, 0x4A, 0xC1, + 0x94, 0xFE, 0x9E, 0x65, 0xA6, 0x2A, 0x73, 0xCE, 0x59, 0x3F, 0xD8, 0x10, + 0x3C, 0x03, 0x98, 0xCF, 0xA6, 0x84, 0x3A, 0x69, 0xA5, 0xAC, 0xB3, 0x98, + 0xB0, 0x2A, 0xCB, 0x87, 0x0F, 0x8E, 0xE7, 0xB3, 0x5A, 0x0A, 0x21, 0x85, + 0x18, 0xED, 0x1A, 0x8D, 0x51, 0x52, 0x71, 0x4E, 0x3A, 0x71, 0x89, 0xB6, + 0x8A, 0xF1, 0x4E, 0x4D, 0x94, 0x5C, 0x8C, 0xDB, 0x79, 0x42, 0x86, 0xA3, + 0x86, 0x25, 0x30, 0x06, 0x94, 0xAF, 0x1F, 0xFA, 0xE6, 0x98, 0x92, 0xB5, + 0xCE, 0x59, 0x4F, 0x8D, 0x22, 0xEF, 0x43, 0x08, 0x71, 0xDB, 0xB4, 0x4D, + 0xD3, 0x0D, 0x83, 0x23, 0x0E, 0xE3, 0xB6, 0xE9, 0x9A, 0xB6, 0x5F, 0xAE, + 0xB6, 0xE4, 0x6C, 0x40, 0x6C, 0x5B, 0xC1, 0x09, 0x39, 0x8D, 0x5C, 0x88, + 0xA6, 0x69, 0x79, 0x4A, 0x65, 0x59, 0x1C, 0x1D, 0xCD, 0x72, 0x63, 0x9A, + 0xA6, 0xED, 0xBA, 0xE1, 0xE5, 0xAB, 0xEB, 0x49, 0x5D, 0xAD, 0xD7, 0xDB, + 0x61, 0x18, 0x8A, 0x3C, 0xAB, 0xCB, 0x62, 0x52, 0x17, 0x42, 0x88, 0x7E, + 0xB0, 0x9B, 0x4D, 0xC3, 0x38, 0xCB, 0xF3, 0x7C, 0x8F, 0x36, 0xDC, 0xAD, + 0x97, 0xC3, 0x22, 0x3D, 0x6C, 0xB7, 0x5A, 0x2B, 0x63, 0x14, 0x3D, 0xE1, + 0xE4, 0x78, 0x5E, 0x15, 0xF9, 0xE5, 0xD5, 0x8D, 0x1D, 0xDC, 0x7C, 0x3E, + 0x99, 0x4E, 0xEB, 0xBA, 0x2A, 0x8E, 0xE6, 0xD3, 0xA3, 0xF9, 0xB4, 0x1F, + 0xAC, 0x1D, 0xAC, 0x52, 0xB2, 0xAE, 0x4A, 0xA5, 0x55, 0x8C, 0x71, 0x52, + 0x95, 0x55, 0x55, 0x1C, 0xF0, 0xE5, 0x84, 0xD4, 0xFC, 0x19, 0xF7, 0xDD, + 0xB1, 0x78, 0x1B, 0xA5, 0xE7, 0xC7, 0x1B, 0xE6, 0x7E, 0x2C, 0x38, 0x5C, + 0xD2, 0x3B, 0x3E, 0xE4, 0xF8, 0xAF, 0xFD, 0xB8, 0xCB, 0x98, 0x97, 0xE0, + 0x3D, 0x08, 0x9B, 0x8F, 0xC6, 0xD2, 0x1C, 0x84, 0x10, 0x59, 0xA6, 0x8D, + 0xD1, 0x5A, 0x6B, 0xC1, 0x19, 0x99, 0x46, 0x32, 0xC6, 0xB4, 0x51, 0xA4, + 0x4F, 0x7D, 0x3F, 0xB2, 0x88, 0x11, 0xDE, 0x01, 0xAA, 0x9A, 0x28, 0xF7, + 0xDD, 0xC7, 0x0A, 0xF8, 0x12, 0x48, 0xFF, 0xC5, 0x98, 0xF5, 0x6B, 0x21, + 0x6C, 0x8C, 0xB6, 0x80, 0x29, 0x01, 0xBB, 0x0B, 0x64, 0x29, 0xDD, 0xCF, + 0xEC, 0xBE, 0x10, 0xA5, 0xD3, 0xBD, 0x5F, 0xD2, 0x21, 0x2E, 0xFF, 0xC1, + 0x1F, 0xFC, 0x7B, 0x00, 0x92, 0xA0, 0xD9, 0x9F, 0xFB, 0xDE, 0x59, 0xF6, + 0xFE, 0x27, 0x7F, 0x21, 0x9C, 0xA4, 0xBB, 0x48, 0x04, 0xC0, 0xEE, 0xA3, + 0xEF, 0x8C, 0x8D, 0x68, 0x18, 0xDB, 0x07, 0x9A, 0xB1, 0x89, 0x39, 0xBE, + 0x42, 0x70, 0xC6, 0x19, 0x67, 0xC4, 0x61, 0x39, 0x3C, 0x81, 0x0B, 0xC6, + 0x00, 0x84, 0x10, 0x52, 0x09, 0xE2, 0x70, 0x32, 0x80, 0x34, 0x36, 0xBC, + 0xEF, 0xB1, 0xEF, 0xEE, 0xE5, 0xC6, 0x87, 0x3B, 0x49, 0x6B, 0x73, 0x73, + 0xBB, 0xBC, 0xBA, 0xBC, 0xFC, 0xF0, 0xD3, 0xEB, 0xC4, 0x55, 0x51, 0x64, + 0xD6, 0xDA, 0x66, 0xD7, 0x0C, 0x2E, 0xBC, 0xB8, 0xB8, 0xAE, 0xCA, 0xF2, + 0xC9, 0xC3, 0x93, 0x22, 0x37, 0x67, 0x27, 0x47, 0x45, 0x99, 0x0B, 0xC1, + 0x52, 0x4A, 0xDE, 0xC7, 0x88, 0x29, 0x84, 0x08, 0x00, 0xC4, 0xA8, 0xA0, + 0xA3, 0x40, 0x24, 0x17, 0xEB, 0x84, 0x29, 0x05, 0x44, 0x4C, 0x18, 0x7C, + 0x74, 0x3E, 0x7C, 0xF0, 0xE1, 0xA7, 0x7F, 0xF7, 0xE3, 0x0F, 0xB6, 0x4D, + 0x97, 0x18, 0x4B, 0x71, 0x64, 0x1E, 0x73, 0xCE, 0x7D, 0xC4, 0xB6, 0x1B, + 0x28, 0x2E, 0x53, 0x62, 0x41, 0xC5, 0xAC, 0x0F, 0x51, 0x69, 0x45, 0x6A, + 0x4D, 0xD6, 0x79, 0x7A, 0x73, 0x22, 0x16, 0x30, 0x60, 0x04, 0xD3, 0x42, + 0xA2, 0x21, 0x6E, 0xC6, 0x39, 0x0B, 0x31, 0xC4, 0x84, 0x52, 0xC8, 0xE0, + 0x63, 0xD7, 0x0F, 0x5C, 0x70, 0x4C, 0x40, 0xBD, 0x02, 0x17, 0x02, 0x1B, + 0x0B, 0xD5, 0xD4, 0x0F, 0x56, 0x49, 0x05, 0x90, 0xA4, 0x94, 0x8C, 0xB1, + 0xC1, 0x3A, 0x1F, 0xA3, 0x92, 0xE2, 0x78, 0x3E, 0xEB, 0x07, 0xBB, 0xD9, + 0xB5, 0x34, 0x22, 0x9E, 0x00, 0x9C, 0xF3, 0x31, 0x22, 0x05, 0x17, 0xC6, + 0x98, 0xE0, 0x3C, 0x33, 0xBA, 0x28, 0xB2, 0x18, 0x91, 0x84, 0xAD, 0xE9, + 0x64, 0x69, 0x2A, 0x10, 0x21, 0xF1, 0xBD, 0x47, 0x15, 0xC9, 0xF5, 0xD1, + 0x17, 0x1E, 0x11, 0x23, 0x22, 0x5D, 0xF6, 0x18, 0x51, 0x29, 0x41, 0x96, + 0x6E, 0x54, 0x05, 0x73, 0xCE, 0x31, 0xA5, 0xB2, 0x28, 0xA6, 0xD3, 0xBA, + 0xC8, 0x32, 0xAD, 0xA5, 0x75, 0xAE, 0x69, 0xBB, 0xE9, 0xA4, 0x7E, 0xF4, + 0xE0, 0x78, 0x36, 0xAD, 0xF2, 0x2C, 0x4B, 0x98, 0x7A, 0x6B, 0x81, 0x81, + 0x14, 0x82, 0x73, 0x1E, 0x31, 0xF6, 0xBD, 0xBD, 0xC3, 0x31, 0xD2, 0x21, + 0xAD, 0x4E, 0x29, 0x21, 0x01, 0xBB, 0xFB, 0x3B, 0x70, 0xCF, 0xFF, 0xDE, + 0xCF, 0xA9, 0x24, 0xEA, 0x03, 0x20, 0x38, 0xE7, 0xBB, 0x6E, 0x68, 0x49, + 0xE1, 0x56, 0x70, 0xC4, 0xD4, 0xF5, 0x03, 0xA9, 0xEE, 0x6C, 0xB6, 0xBB, + 0xC1, 0x3A, 0x00, 0xB6, 0x6B, 0xDA, 0x2C, 0x33, 0x93, 0xAA, 0xF0, 0x21, + 0x5E, 0x5F, 0x2F, 0x8F, 0x17, 0xB3, 0xBA, 0x2A, 0x9D, 0xF3, 0x93, 0xE9, + 0x84, 0x52, 0x57, 0x48, 0x18, 0x62, 0xB8, 0xBA, 0xBA, 0x5D, 0xAD, 0x77, + 0x14, 0x5C, 0xAE, 0x6F, 0x56, 0xE7, 0x2F, 0xAF, 0x5E, 0x5D, 0x5D, 0x7F, + 0xED, 0xDD, 0xB7, 0x2F, 0x5E, 0x5D, 0x39, 0xEF, 0xDB, 0xAE, 0x2F, 0xF2, + 0x2C, 0x33, 0xA6, 0xEF, 0x87, 0x4D, 0xD3, 0x22, 0x22, 0x89, 0x3D, 0x1C, + 0x6E, 0xF5, 0xBB, 0x7C, 0x01, 0x31, 0xED, 0x69, 0x92, 0x87, 0x8D, 0x5D, + 0x4A, 0x51, 0x55, 0xF9, 0xE2, 0x68, 0x3A, 0x4E, 0x0B, 0xCC, 0xEA, 0x22, + 0x37, 0x65, 0x91, 0x7D, 0xFD, 0xDD, 0x37, 0x19, 0x83, 0xEB, 0xDB, 0x65, + 0x66, 0x34, 0x39, 0xC3, 0x1B, 0xA3, 0x39, 0x87, 0xB2, 0xC8, 0x4F, 0x8E, + 0xE7, 0xFD, 0x30, 0x44, 0xF2, 0x6A, 0x13, 0x42, 0x48, 0xAE, 0x8D, 0x1A, + 0xDF, 0x30, 0xDD, 0xC1, 0x61, 0x00, 0x10, 0x43, 0x74, 0x36, 0x50, 0x32, + 0x7B, 0x08, 0x1F, 0x89, 0x04, 0x95, 0x0F, 0x12, 0xC5, 0xA4, 0x3B, 0x13, + 0xEE, 0x34, 0xE2, 0x69, 0x4D, 0xEF, 0xBB, 0x79, 0xFB, 0x75, 0x0D, 0x77, + 0x20, 0x11, 0xE3, 0x4C, 0x2A, 0xC1, 0xEF, 0x39, 0xCF, 0x4A, 0x75, 0xA7, + 0x8C, 0x70, 0xA8, 0xA2, 0x00, 0x40, 0xDC, 0xAB, 0x87, 0xC6, 0xA2, 0xE8, + 0x7E, 0x4A, 0x08, 0x77, 0x03, 0xC8, 0xF7, 0xA3, 0xD5, 0xFD, 0xA0, 0x36, + 0xC6, 0x32, 0x48, 0x90, 0x00, 0x71, 0x8C, 0x47, 0xFF, 0xE8, 0xB3, 0xBF, + 0xF0, 0xFB, 0xAF, 0xC1, 0xFC, 0x87, 0x98, 0x38, 0x16, 0xFF, 0x78, 0x17, + 0x29, 0xEF, 0xBF, 0x3E, 0xED, 0xB1, 0x80, 0x2F, 0xC4, 0x31, 0x18, 0xA1, + 0xB0, 0x43, 0x8D, 0xFC, 0x85, 0x74, 0x0C, 0xF6, 0x32, 0xF9, 0x87, 0x97, + 0x70, 0x6A, 0xFF, 0x8F, 0x98, 0xD6, 0x5D, 0x81, 0x9A, 0xF6, 0xD8, 0x47, + 0x4A, 0x69, 0xBC, 0xD9, 0x85, 0x18, 0xBF, 0xB3, 0xF1, 0x72, 0x44, 0xBA, + 0xE1, 0xF7, 0xB1, 0xF2, 0x4E, 0xA5, 0x9A, 0xA2, 0x4F, 0x9E, 0x67, 0x6D, + 0xD3, 0x9C, 0xBF, 0x7C, 0xE5, 0x43, 0x52, 0x26, 0xE3, 0x52, 0x5C, 0x5E, + 0xDF, 0x38, 0x49, 0xF1, 0xFE, 0x7F, 0x00, 0x00, 0x20, 0x00, 0x49, 0x44, + 0x41, 0x54, 0xEB, 0xA9, 0x6D, 0x9D, 0x17, 0xF9, 0x83, 0xD3, 0xE3, 0xF9, + 0x6C, 0x62, 0xB4, 0x9C, 0xD4, 0x25, 0x63, 0x10, 0x02, 0x3A, 0x1F, 0x86, + 0xC1, 0xB1, 0xBD, 0x07, 0x0F, 0xD5, 0x8F, 0x00, 0x60, 0xAD, 0x1B, 0x17, + 0x18, 0x1F, 0xC5, 0x60, 0x11, 0x21, 0x46, 0x5C, 0xAD, 0x36, 0xEB, 0xCD, + 0x8E, 0x92, 0x6D, 0x29, 0x25, 0xDD, 0x7C, 0x74, 0x26, 0xDE, 0xFB, 0x83, + 0xE0, 0x5F, 0xD7, 0xDB, 0x22, 0x33, 0x59, 0x96, 0x61, 0x4A, 0xDD, 0x30, + 0xA4, 0xBD, 0x1E, 0x06, 0x83, 0xC4, 0x39, 0x23, 0x12, 0x89, 0x60, 0x0C, + 0x53, 0x52, 0x52, 0x0D, 0xB6, 0x53, 0x4A, 0x0A, 0xC6, 0x63, 0x8C, 0x42, + 0x48, 0x29, 0xA5, 0x75, 0xCE, 0x79, 0x97, 0x00, 0xA8, 0xF8, 0x1A, 0xAC, + 0x4D, 0x90, 0x38, 0xB0, 0x22, 0xCB, 0x18, 0x63, 0x11, 0x31, 0xC6, 0xA8, + 0x94, 0x24, 0x3D, 0x83, 0x10, 0xD1, 0x3A, 0x5F, 0x64, 0x59, 0xEF, 0x5C, + 0x44, 0x8C, 0x09, 0xBB, 0x61, 0x50, 0x52, 0x5A, 0xE7, 0xA8, 0x63, 0xC0, + 0x39, 0xE3, 0x5C, 0x72, 0xC6, 0x85, 0xE0, 0x9E, 0x00, 0x2F, 0x80, 0xBE, + 0xB7, 0xE4, 0x1E, 0x26, 0x84, 0x20, 0x3A, 0x52, 0x4A, 0x49, 0x08, 0xA1, + 0xB5, 0x8C, 0x21, 0x48, 0x86, 0x84, 0x69, 0x47, 0x8C, 0x90, 0x80, 0xBA, + 0xEA, 0x09, 0x58, 0x88, 0xE8, 0xFC, 0xA0, 0xA4, 0x34, 0x4C, 0x65, 0x99, + 0x01, 0x80, 0xB6, 0x6D, 0x85, 0x94, 0xDE, 0xFB, 0x2C, 0x33, 0xB3, 0xE9, + 0x64, 0x52, 0x17, 0x5A, 0xC8, 0x10, 0x42, 0x9E, 0x4D, 0x67, 0xD3, 0x8A, + 0x25, 0xA0, 0x5E, 0x98, 0x54, 0x42, 0x1B, 0x99, 0x58, 0xE2, 0x3C, 0x97, + 0x52, 0x38, 0xEB, 0xFA, 0xDE, 0x5A, 0xEF, 0x74, 0x50, 0xC1, 0x7B, 0xAD, + 0x55, 0xA6, 0x15, 0x22, 0x61, 0x91, 0x4C, 0x70, 0xC1, 0xC5, 0x21, 0x86, + 0xDE, 0x01, 0x0E, 0x1C, 0x00, 0x81, 0xC5, 0x98, 0x12, 0x26, 0xC6, 0x20, + 0xC4, 0x68, 0x07, 0xD7, 0xB4, 0x3D, 0x09, 0x43, 0x5B, 0xE7, 0x11, 0xB1, + 0xEF, 0xAD, 0xB5, 0x6E, 0xBD, 0xDE, 0x0E, 0xD6, 0x01, 0xE7, 0x5D, 0x37, + 0x18, 0x25, 0x81, 0xB3, 0x18, 0x62, 0x99, 0x9B, 0xDC, 0xA8, 0xF6, 0xFF, + 0x63, 0xEB, 0xCD, 0x9A, 0x24, 0xBB, 0x92, 0xF4, 0xB0, 0xE3, 0x7E, 0xD6, + 0xBB, 0xC4, 0x92, 0x6B, 0x2D, 0x68, 0xA0, 0xD1, 0x1B, 0xBA, 0x87, 0x33, + 0x3D, 0x9C, 0x19, 0x6E, 0x46, 0x72, 0x86, 0xA4, 0xC4, 0x07, 0xD2, 0x28, + 0x93, 0xDE, 0xF4, 0x07, 0x24, 0xD3, 0x33, 0x4D, 0x7F, 0x4B, 0x4F, 0x92, + 0xCC, 0x64, 0x32, 0xA3, 0x89, 0x12, 0xCD, 0x38, 0x22, 0xC7, 0xA6, 0xD5, + 0xEC, 0xE9, 0x1D, 0xDD, 0x0D, 0x34, 0x80, 0xAA, 0x42, 0x56, 0xE5, 0x1A, + 0xEB, 0x5D, 0xCE, 0xEA, 0x7A, 0xF0, 0x1B, 0x91, 0x09, 0x90, 0xF9, 0x50, + 0x56, 0x28, 0x64, 0x46, 0x64, 0x44, 0xDC, 0xEB, 0xC7, 0xFD, 0xF3, 0x6F, + 0xD9, 0xF7, 0x4C, 0xEF, 0x02, 0x41, 0xCF, 0x9F, 0x9D, 0x3F, 0xDC, 0x6F, + 0xCE, 0x4F, 0x4F, 0x36, 0xDB, 0x6D, 0xC9, 0xF1, 0xE1, 0x61, 0x1D, 0x62, + 0xBC, 0xBC, 0x3C, 0x3B, 0x3D, 0x5D, 0xF6, 0xA3, 0xBF, 0xBA, 0xBA, 0x7E, + 0x73, 0x75, 0xFD, 0xC1, 0xFB, 0x2F, 0x5F, 0xBD, 0xBA, 0x2A, 0x99, 0x4A, + 0x29, 0x7F, 0xFC, 0x87, 0x1F, 0x35, 0x75, 0xD5, 0xF5, 0xC3, 0xCD, 0xED, + 0xBD, 0x35, 0xFA, 0xF2, 0xE2, 0x94, 0x9B, 0x32, 0xDE, 0xB7, 0xF2, 0xED, + 0xCA, 0xC3, 0x7B, 0x39, 0x8C, 0xE1, 0xC7, 0x32, 0x57, 0x8A, 0x00, 0x28, + 0xCB, 0x45, 0x7B, 0x7E, 0xB6, 0x00, 0x80, 0x18, 0xD2, 0x66, 0xBB, 0xFF, + 0xEC, 0xF3, 0xD7, 0x3E, 0x44, 0x89, 0x20, 0x48, 0x9C, 0x9E, 0x2C, 0xAA, + 0xCA, 0x0D, 0xE3, 0x68, 0xB4, 0x6B, 0xEB, 0x4A, 0x29, 0xA9, 0x92, 0xD4, + 0x52, 0x4A, 0x29, 0x99, 0x68, 0x91, 0xD2, 0x94, 0x61, 0x5E, 0x68, 0x1A, + 0x2A, 0x85, 0x10, 0x39, 0xE7, 0x71, 0x0C, 0xDC, 0x46, 0xE5, 0x4C, 0x87, + 0x98, 0xC4, 0xC7, 0x1A, 0x07, 0x20, 0x72, 0x39, 0x2C, 0x2C, 0xBF, 0x3A, + 0x54, 0x0A, 0xA0, 0x03, 0xE8, 0x7E, 0xA8, 0xC5, 0x04, 0x80, 0x42, 0x02, + 0x0A, 0x41, 0x91, 0x8A, 0x10, 0x42, 0x49, 0x48, 0x49, 0xF0, 0x90, 0x6E, + 0xC9, 0xA6, 0x08, 0x88, 0x60, 0x8C, 0x9E, 0x7C, 0x5D, 0xF9, 0x60, 0xE3, + 0x90, 0x07, 0xCE, 0x44, 0x64, 0xFE, 0x3D, 0x09, 0xFA, 0x6A, 0x3F, 0xF5, + 0xB4, 0xE2, 0x1C, 0x07, 0x2A, 0x71, 0x70, 0x94, 0x79, 0xAC, 0x41, 0x45, + 0x14, 0x9A, 0x2C, 0x6B, 0x9E, 0xFC, 0xF8, 0xB1, 0x70, 0x4D, 0xE3, 0x68, + 0x79, 0xD2, 0x88, 0x89, 0x69, 0x7B, 0xFB, 0x95, 0x6D, 0xC0, 0x64, 0x6D, + 0x78, 0x78, 0x4D, 0x00, 0x4F, 0xF6, 0x8F, 0xFC, 0x98, 0xC7, 0x77, 0xE1, + 0xB1, 0x8A, 0x3D, 0xBE, 0x24, 0xFC, 0xDA, 0x37, 0x4C, 0x95, 0x0C, 0x0E, + 0x15, 0x8E, 0xFF, 0x11, 0x05, 0x02, 0x4A, 0xC5, 0x9D, 0xD7, 0x93, 0x29, + 0xF2, 0xF0, 0x17, 0xC1, 0x9C, 0x80, 0x83, 0x93, 0x8F, 0x10, 0x42, 0x1B, + 0x85, 0x12, 0x52, 0x02, 0x2E, 0x65, 0x78, 0x58, 0xDB, 0xF0, 0x6B, 0x46, + 0x44, 0x63, 0x34, 0x0A, 0xF1, 0xD9, 0xEF, 0xBF, 0xF8, 0xED, 0x17, 0xD7, + 0x31, 0x89, 0x58, 0xC4, 0x7A, 0xB3, 0xEB, 0xFA, 0x61, 0x1C, 0x87, 0xE5, + 0x7C, 0x81, 0x44, 0x4E, 0xCB, 0x79, 0x5B, 0x97, 0x94, 0xAC, 0x92, 0x27, + 0xCB, 0x56, 0x00, 0x84, 0x94, 0xFA, 0x7E, 0xF4, 0x31, 0x2B, 0x84, 0xA3, + 0x6D, 0x2E, 0x11, 0xC5, 0x94, 0xC7, 0xC1, 0x33, 0x0E, 0xCD, 0xD7, 0x68, + 0x2A, 0x25, 0xA5, 0x42, 0x85, 0x52, 0xCE, 0xFD, 0xE8, 0x53, 0xCA, 0xB3, + 0xA6, 0x11, 0x02, 0x43, 0x8C, 0x59, 0x2B, 0x1E, 0x73, 0x24, 0x4E, 0xC2, + 0xF1, 0xC3, 0x67, 0x25, 0xC6, 0x18, 0xFA, 0xD1, 0x57, 0xCE, 0x31, 0x29, + 0x81, 0xED, 0x76, 0x05, 0x95, 0x29, 0x05, 0x8E, 0x88, 0xC3, 0x25, 0x0B, + 0x11, 0xE7, 0x63, 0xE7, 0x54, 0x94, 0x52, 0x29, 0xE7, 0x98, 0x32, 0x22, + 0x32, 0x3C, 0x2F, 0x40, 0x14, 0x22, 0xA9, 0x54, 0x08, 0xA1, 0xAA, 0x8D, + 0x35, 0x3A, 0xC4, 0x04, 0x42, 0xC4, 0x9C, 0x89, 0x04, 0x22, 0x94, 0x42, + 0x08, 0x22, 0x11, 0x19, 0x23, 0x43, 0x02, 0x00, 0xE8, 0xFB, 0x71, 0x1C, + 0xFD, 0xBC, 0x6D, 0x52, 0x56, 0x4C, 0x09, 0xB6, 0x5A, 0xEF, 0xFB, 0x81, + 0x94, 0x4A, 0x19, 0xD9, 0x60, 0x6B, 0x18, 0x3D, 0x00, 0xA4, 0x92, 0x35, + 0x4E, 0x4B, 0xA8, 0x72, 0x18, 0xAB, 0x59, 0x0E, 0x9D, 0xA9, 0x68, 0x90, + 0xBC, 0x16, 0x98, 0xEE, 0x55, 0x29, 0x49, 0x88, 0x61, 0xF4, 0x42, 0x40, + 0xED, 0xF4, 0xAC, 0x6D, 0xA4, 0xC4, 0xBE, 0xEB, 0xFB, 0x7E, 0x98, 0x2F, + 0x66, 0x27, 0xCB, 0x85, 0xB5, 0x66, 0xDE, 0x36, 0x8B, 0x79, 0x6D, 0xAD, + 0x65, 0x53, 0x2D, 0x00, 0x0C, 0x21, 0x54, 0x95, 0x6B, 0x1A, 0x87, 0x52, + 0x2A, 0x84, 0xB6, 0xAE, 0xB8, 0xA5, 0xEA, 0xFB, 0x31, 0xC6, 0x04, 0x60, + 0x0E, 0xE6, 0x9D, 0x2C, 0xF3, 0x28, 0x90, 0x40, 0x29, 0x2C, 0x54, 0x28, + 0x4F, 0xBF, 0x15, 0x02, 0x0B, 0xCF, 0x11, 0x00, 0x0A, 0x81, 0xC8, 0x85, + 0xB3, 0x7F, 0xD8, 0x49, 0x62, 0xBD, 0xD9, 0x1D, 0xBC, 0xD4, 0xE3, 0xBE, + 0x1B, 0xBC, 0xF7, 0x85, 0xA8, 0xE4, 0x52, 0x48, 0xB0, 0xE1, 0x60, 0x88, + 0xA9, 0x1F, 0x7C, 0x5D, 0x39, 0x1F, 0x02, 0x08, 0x51, 0x55, 0x96, 0x88, + 0xEE, 0x6E, 0x57, 0x2F, 0x9E, 0x5F, 0xC6, 0x98, 0x62, 0x88, 0x4D, 0x53, + 0x0D, 0x83, 0xAF, 0x9C, 0x13, 0x42, 0x28, 0xAD, 0xEE, 0xEF, 0x56, 0xBB, + 0x5D, 0x67, 0xAC, 0x79, 0xFE, 0xEC, 0x7C, 0xBB, 0xDD, 0xAF, 0x56, 0x1B, + 0x67, 0xCC, 0x7C, 0xDE, 0xDE, 0xDD, 0x3D, 0x28, 0xAD, 0x1F, 0xD6, 0x9B, + 0xB3, 0x93, 0x93, 0x8B, 0xB3, 0x13, 0xAD, 0x65, 0x4C, 0xF9, 0xEE, 0x6E, + 0x35, 0x9F, 0x37, 0x55, 0xE5, 0x10, 0x05, 0x80, 0xCC, 0x79, 0xBA, 0xF2, + 0x79, 0x03, 0x73, 0xEC, 0x74, 0x8E, 0x77, 0xCA, 0xD4, 0x25, 0x14, 0x22, + 0x2A, 0x28, 0xD1, 0x39, 0xF3, 0xC1, 0xFB, 0x2F, 0x11, 0x41, 0x2A, 0xF5, + 0xEA, 0xD5, 0xD5, 0xC3, 0x6A, 0x8B, 0x9C, 0x7A, 0xD5, 0x36, 0x00, 0x90, + 0x53, 0xB6, 0xC6, 0x84, 0x10, 0xA4, 0x92, 0x8F, 0xBD, 0x18, 0xBF, 0x27, + 0x38, 0xF5, 0xC5, 0x42, 0x50, 0x8C, 0xB9, 0x94, 0xA2, 0xB5, 0x12, 0x05, + 0x98, 0x82, 0x0E, 0x87, 0x80, 0x56, 0xEF, 0xC3, 0x84, 0xA0, 0x4D, 0x12, + 0xD1, 0x69, 0x84, 0x94, 0xC7, 0x60, 0x69, 0x44, 0xDE, 0xC2, 0x19, 0xAD, + 0x27, 0xBE, 0x0B, 0x0A, 0x39, 0x7D, 0x16, 0xC4, 0x03, 0x63, 0x16, 0x99, + 0x5D, 0x82, 0xD9, 0x7D, 0x13, 0x25, 0x68, 0xA5, 0x53, 0xCE, 0x28, 0x26, + 0x9B, 0x79, 0x22, 0x2A, 0x4C, 0x2B, 0xE3, 0xFC, 0xDB, 0x63, 0xD7, 0x73, + 0x60, 0x2B, 0x1C, 0x9F, 0xB7, 0x1C, 0x52, 0x2F, 0x0E, 0xE5, 0xE8, 0xB1, + 0x26, 0x1C, 0x6B, 0x10, 0x5B, 0x2E, 0x88, 0xC7, 0x07, 0xFA, 0x7A, 0xCB, + 0xC5, 0x30, 0x97, 0x38, 0x16, 0xB2, 0xAF, 0x0F, 0xAD, 0xD3, 0xCF, 0xAA, + 0xC7, 0xC6, 0x4B, 0x7C, 0xFD, 0x69, 0x9E, 0xD6, 0xF2, 0xAF, 0xB5, 0xB8, + 0x08, 0x02, 0x0F, 0x50, 0x17, 0xFF, 0x14, 0xAF, 0x32, 0x1F, 0x6B, 0x30, + 0x27, 0x0B, 0xA1, 0x80, 0x29, 0x68, 0x17, 0x40, 0x70, 0x62, 0xC8, 0x23, + 0x84, 0xCF, 0x99, 0x02, 0x00, 0x42, 0xA3, 0x2C, 0x82, 0x62, 0xCE, 0x20, + 0x84, 0x02, 0x49, 0x00, 0xF1, 0xA0, 0x6E, 0x22, 0x24, 0x9C, 0x58, 0x91, + 0x20, 0x04, 0xE5, 0xC4, 0x3B, 0x14, 0x79, 0xBF, 0x5A, 0x5F, 0xDF, 0xAE, + 0xAE, 0xEE, 0xF6, 0xBB, 0xA1, 0xDC, 0x3F, 0xAC, 0xBA, 0x6E, 0x98, 0xCF, + 0xE7, 0x75, 0x5D, 0x3F, 0x7F, 0x76, 0x69, 0x8C, 0x42, 0x21, 0xC6, 0x71, + 0xA8, 0xAD, 0x7E, 0x71, 0x79, 0xB6, 0x3C, 0x99, 0x23, 0x42, 0x2E, 0x65, + 0xF0, 0x71, 0xBD, 0x1B, 0x4A, 0x29, 0x46, 0x2B, 0x2B, 0x44, 0x65, 0x0D, + 0x00, 0xC4, 0x18, 0xF7, 0xDD, 0xA0, 0x94, 0xAC, 0xB5, 0xE2, 0x93, 0xA2, + 0x30, 0xD2, 0x9F, 0x4B, 0xCC, 0xC9, 0x87, 0x20, 0xA5, 0x34, 0xCE, 0x38, + 0x67, 0x41, 0xCA, 0xFB, 0xD5, 0x7A, 0xDE, 0x36, 0xA5, 0x50, 0x8C, 0x51, + 0xE2, 0x74, 0xB4, 0xD5, 0x95, 0x1D, 0xBD, 0x6F, 0xAA, 0x4A, 0x6B, 0x1D, + 0x62, 0x2C, 0xB9, 0xA8, 0x83, 0x87, 0x9C, 0x44, 0x04, 0xC0, 0x61, 0xF4, + 0x56, 0x2B, 0x67, 0x8C, 0x35, 0x5A, 0x21, 0x72, 0xD9, 0x22, 0x22, 0x90, + 0x8C, 0xC8, 0x62, 0x2E, 0x91, 0x55, 0x44, 0xD6, 0x98, 0xF5, 0x6E, 0x8F, + 0x24, 0xAC, 0x35, 0x7C, 0xB8, 0xF4, 0xFD, 0xC0, 0x74, 0x07, 0x89, 0x98, + 0x45, 0x16, 0x42, 0x18, 0xA3, 0x01, 0xA0, 0x50, 0x61, 0x91, 0xD0, 0xD4, + 0x45, 0x4E, 0x6F, 0x57, 0x41, 0x00, 0x3F, 0x7A, 0x9E, 0xD8, 0x89, 0x68, + 0xF4, 0x01, 0x00, 0x0F, 0xBA, 0x52, 0xC1, 0x84, 0x49, 0x3A, 0xEC, 0xB0, + 0x94, 0x92, 0xD6, 0x72, 0x59, 0x41, 0x91, 0x27, 0x4A, 0x07, 0x9F, 0xFF, + 0xC0, 0xE2, 0x53, 0x8E, 0x6D, 0x46, 0x14, 0x40, 0xCC, 0x53, 0x8D, 0x31, + 0x6A, 0x6D, 0x96, 0x8B, 0xF9, 0x8B, 0xCB, 0x73, 0x01, 0x62, 0xB9, 0x68, + 0xD9, 0x1C, 0x2D, 0xA7, 0x22, 0x11, 0x52, 0xCE, 0xD8, 0x56, 0x95, 0xB3, + 0x5C, 0x94, 0x8C, 0x94, 0x4A, 0x2B, 0x94, 0x90, 0x62, 0xA9, 0x9C, 0xF1, + 0xB5, 0x0B, 0x21, 0x29, 0x25, 0x95, 0x96, 0xCC, 0x82, 0x8E, 0x21, 0x5B, + 0xA5, 0x89, 0x94, 0x10, 0x07, 0x66, 0xB5, 0x10, 0x00, 0x42, 0xD1, 0xB4, + 0xDC, 0xE4, 0x3D, 0xDA, 0xC4, 0xDA, 0xCF, 0x79, 0xDF, 0xF5, 0xEB, 0xCD, + 0x2E, 0x84, 0x94, 0x4B, 0x09, 0x21, 0x16, 0x22, 0x4E, 0xD5, 0x74, 0xCE, + 0x08, 0x80, 0x31, 0x84, 0x14, 0x73, 0x4C, 0x29, 0xC6, 0xB8, 0xD9, 0xEE, + 0x72, 0x2E, 0x28, 0xB1, 0xF1, 0x55, 0xE5, 0x6C, 0xA1, 0x32, 0x8C, 0xE3, + 0xD9, 0xC9, 0xB2, 0xEB, 0x46, 0x57, 0x19, 0xA5, 0x65, 0x4A, 0xA8, 0xA4, + 0x1C, 0x86, 0x7E, 0x31, 0x6F, 0x1F, 0x36, 0xBB, 0x10, 0x53, 0xF0, 0xF1, + 0xF2, 0xE2, 0xE4, 0xE6, 0x76, 0xB5, 0xEF, 0x87, 0x1F, 0x7C, 0xEF, 0xC3, + 0xC5, 0xAC, 0xD9, 0xEE, 0xFB, 0xEB, 0x9B, 0x7B, 0xAD, 0x54, 0x4E, 0xA9, + 0xA9, 0x9C, 0x73, 0x96, 0x97, 0x9E, 0x88, 0xB2, 0xAE, 0x2D, 0xA2, 0x40, + 0x94, 0x44, 0x32, 0x04, 0x51, 0x26, 0xBE, 0x6E, 0x39, 0x9E, 0x8E, 0x8F, + 0xF7, 0xC5, 0x13, 0x09, 0x4A, 0x53, 0x57, 0xC7, 0xE1, 0xE8, 0x7B, 0xDF, + 0xFD, 0xE6, 0x27, 0x9F, 0xBE, 0x7A, 0x73, 0x75, 0x6D, 0x9D, 0x6D, 0xDB, + 0xBA, 0x9D, 0xD5, 0xDA, 0x68, 0xA5, 0xA4, 0x75, 0x86, 0x3B, 0xDF, 0x23, + 0x2E, 0x29, 0xA5, 0x24, 0x41, 0x2C, 0xDA, 0x53, 0x5A, 0x71, 0x3A, 0x3D, + 0x5F, 0xD2, 0xEC, 0xCD, 0x4D, 0x45, 0x10, 0xD1, 0x38, 0x8E, 0x88, 0xC0, + 0x4D, 0x1C, 0x97, 0x92, 0x98, 0x92, 0x20, 0xC1, 0x52, 0x33, 0x22, 0xC1, + 0x00, 0xE8, 0x91, 0x61, 0xAB, 0x25, 0x00, 0x30, 0xC2, 0x23, 0xD2, 0x21, + 0x8E, 0x93, 0x48, 0xA4, 0x9C, 0x33, 0x07, 0xD0, 0x95, 0x52, 0x4A, 0x61, + 0x55, 0x01, 0x80, 0xA0, 0x4C, 0xE5, 0xC0, 0xF2, 0x04, 0x40, 0x41, 0x54, + 0x10, 0xA5, 0x40, 0x12, 0xC4, 0x8B, 0xFF, 0xA7, 0xF9, 0x6E, 0x5C, 0xC2, + 0xF0, 0x70, 0x1D, 0x1E, 0xCA, 0x53, 0xF9, 0x5A, 0x8D, 0x2F, 0x87, 0x9A, + 0xFB, 0xD5, 0x59, 0xF2, 0x91, 0xBB, 0xC1, 0xB5, 0xE4, 0xD1, 0xC3, 0xFE, + 0xBF, 0x3C, 0x5A, 0x0A, 0x21, 0x84, 0xFC, 0x1F, 0xFE, 0xC7, 0xFF, 0xE9, + 0x58, 0x7A, 0xE0, 0x49, 0x1B, 0x25, 0x9E, 0x80, 0xEE, 0xD3, 0x9F, 0x00, + 0x47, 0x66, 0x06, 0xFF, 0xB7, 0x10, 0x13, 0x7E, 0xCC, 0x9D, 0x09, 0x1C, + 0xC2, 0x8B, 0xC4, 0x01, 0x8C, 0x07, 0x00, 0x79, 0xC8, 0x3B, 0x61, 0xDE, + 0xBF, 0x94, 0x92, 0x3D, 0x42, 0xAD, 0xB5, 0x7E, 0x0C, 0xBB, 0x7D, 0x57, + 0x72, 0x46, 0x9C, 0x0E, 0x61, 0x89, 0x28, 0x51, 0x1E, 0x18, 0x44, 0x02, + 0x01, 0x39, 0xCC, 0x86, 0xF5, 0x10, 0x88, 0xA8, 0x8D, 0xD2, 0x1A, 0x3F, + 0xFB, 0xEC, 0xCD, 0x2F, 0x7F, 0xFB, 0xBA, 0xF3, 0xE5, 0xED, 0xCD, 0xEA, + 0xDD, 0xCD, 0xFD, 0xBE, 0xEB, 0x17, 0xCB, 0x65, 0xD3, 0x34, 0x6F, 0xAF, + 0x6F, 0xD7, 0xEB, 0x6D, 0x49, 0x79, 0xDE, 0x56, 0x56, 0xCB, 0xC5, 0x62, + 0xF6, 0xEC, 0xF2, 0x0C, 0x51, 0xEE, 0xF6, 0xC3, 0x7A, 0xDB, 0xDF, 0xDE, + 0x6D, 0x56, 0x9B, 0x7D, 0x88, 0x49, 0x6B, 0xC9, 0xBD, 0x6C, 0xD7, 0xF5, + 0x31, 0x3E, 0x4A, 0xB2, 0x63, 0xCA, 0x24, 0x80, 0x8A, 0x48, 0x31, 0x87, + 0x18, 0x47, 0x1F, 0x46, 0x1F, 0x73, 0x21, 0xF6, 0x60, 0x92, 0x92, 0x7B, + 0x05, 0x99, 0x73, 0x6A, 0x5A, 0x97, 0x4B, 0xD9, 0xEE, 0x7A, 0x29, 0x71, + 0xD6, 0xD4, 0x4D, 0x5D, 0x49, 0x29, 0x07, 0x1F, 0xD8, 0xF9, 0x83, 0xA8, + 0x28, 0x25, 0x63, 0xCC, 0x1C, 0x1F, 0x1D, 0x62, 0x6C, 0x2A, 0x57, 0x59, + 0x03, 0xAC, 0x1F, 0x2A, 0x39, 0x67, 0x02, 0xC4, 0x9C, 0x73, 0xCA, 0x49, + 0x6B, 0xA5, 0xD5, 0x94, 0xAF, 0x93, 0x72, 0x1E, 0x43, 0xAC, 0x9D, 0x65, + 0x5B, 0x7D, 0xB6, 0xAB, 0x56, 0x0A, 0x8D, 0xD1, 0xFC, 0x11, 0x66, 0xA2, + 0xB6, 0x76, 0xFC, 0x29, 0x9D, 0xCC, 0x1A, 0x63, 0x54, 0x37, 0x8C, 0xD3, + 0x59, 0x07, 0x22, 0xA6, 0x1C, 0x63, 0x02, 0x80, 0xDA, 0xB9, 0x5C, 0x32, + 0x15, 0xE6, 0xE6, 0x09, 0x22, 0x62, 0x43, 0x15, 0xA5, 0x50, 0x2B, 0xC9, + 0x50, 0xB1, 0x35, 0x06, 0x04, 0x39, 0x6B, 0xFA, 0xBE, 0xCF, 0x39, 0x57, + 0xD6, 0xA6, 0x94, 0x38, 0x5A, 0xD6, 0x28, 0x85, 0x52, 0x92, 0x20, 0x25, + 0xA5, 0x96, 0xD2, 0x1A, 0x6D, 0x94, 0x74, 0xD6, 0x96, 0x92, 0x11, 0xE1, + 0xF2, 0xE2, 0xEC, 0xEC, 0x64, 0x7E, 0xB2, 0x9C, 0x9F, 0x9D, 0x2E, 0x97, + 0x8B, 0xB6, 0xAD, 0x2A, 0xAB, 0x75, 0x5D, 0x39, 0x6B, 0x94, 0x44, 0xE4, + 0x89, 0x75, 0x4A, 0x6F, 0x41, 0xC1, 0x47, 0x19, 0xDF, 0xDB, 0x29, 0x25, + 0x86, 0xF0, 0x58, 0x75, 0x10, 0x62, 0xF4, 0x63, 0xF0, 0x3E, 0x70, 0xF6, + 0x1A, 0x95, 0x29, 0x7A, 0x90, 0x2F, 0xCE, 0x69, 0x76, 0x28, 0x13, 0xF5, + 0x29, 0xA5, 0xEC, 0x7D, 0xD8, 0xEC, 0x3A, 0x1F, 0xE2, 0x6A, 0xBB, 0xBF, + 0x7B, 0x58, 0x6F, 0x76, 0xFB, 0xD1, 0x87, 0x9C, 0x0B, 0xE3, 0xAD, 0x6D, + 0x5B, 0x2F, 0x16, 0xF3, 0x61, 0xF0, 0xEB, 0xED, 0x4E, 0x08, 0xA1, 0x94, + 0xEC, 0xC7, 0x91, 0x48, 0x74, 0x5D, 0x1F, 0x53, 0xCA, 0xB9, 0xAC, 0x36, + 0x5B, 0x21, 0x88, 0x4D, 0x38, 0xB8, 0xBB, 0x31, 0x46, 0x87, 0x18, 0xEB, + 0xBA, 0xCA, 0xA5, 0xD4, 0x75, 0x75, 0x77, 0xBF, 0x9A, 0xCF, 0xDB, 0xC5, + 0x62, 0xF6, 0xE9, 0x67, 0xAF, 0x66, 0x6D, 0xF3, 0x67, 0x7F, 0xF2, 0xB7, + 0xEA, 0xCA, 0x2A, 0xA5, 0x38, 0x90, 0x8D, 0x84, 0x40, 0x04, 0x6B, 0xED, + 0x76, 0xD7, 0x69, 0x25, 0xAB, 0xCA, 0x4D, 0x10, 0x89, 0x10, 0x4A, 0x49, + 0x14, 0x82, 0x19, 0xFF, 0x5F, 0xBB, 0x83, 0xF8, 0x53, 0x7B, 0xAC, 0x65, + 0x87, 0x81, 0x88, 0x0F, 0xB9, 0x10, 0x53, 0x4A, 0xF9, 0xF9, 0xE5, 0xF9, + 0x72, 0x31, 0x3B, 0x3F, 0x5B, 0xD6, 0x95, 0x63, 0x2F, 0x39, 0xFE, 0x06, + 0xEE, 0xA1, 0xA4, 0x94, 0x39, 0xE5, 0xE0, 0x03, 0xCB, 0xBC, 0x84, 0x20, + 0x46, 0x4E, 0xB4, 0xD1, 0x6C, 0xAE, 0x85, 0x80, 0x85, 0x88, 0x4F, 0xA0, + 0x18, 0x63, 0xCE, 0x85, 0xCB, 0x59, 0x88, 0x31, 0xA6, 0x04, 0x20, 0x4A, + 0x21, 0x1F, 0xA3, 0x20, 0x06, 0x6A, 0x48, 0x69, 0xD9, 0x54, 0xD6, 0x68, + 0x75, 0xBC, 0xAF, 0x59, 0xD3, 0xC2, 0x15, 0x21, 0xA5, 0x34, 0xFA, 0x49, + 0xDB, 0x3B, 0x19, 0x06, 0xC8, 0x29, 0xD7, 0x95, 0x6D, 0x23, 0x00, 0x20, + 0x67, 0xF6, 0x07, 0xA4, 0x47, 0x68, 0x88, 0xFB, 0x98, 0xC7, 0x60, 0x0D, + 0xE2, 0xDF, 0xFC, 0xF0, 0x85, 0x52, 0x4A, 0x25, 0x51, 0x1F, 0x4D, 0x0A, + 0x0E, 0xF0, 0x68, 0x4E, 0x25, 0x4F, 0xD9, 0x69, 0xD3, 0xCF, 0x1D, 0xA7, + 0xC0, 0x63, 0xD1, 0x62, 0xEA, 0xD8, 0x63, 0x03, 0xF6, 0x58, 0xC8, 0xE0, + 0x48, 0xC8, 0x20, 0x22, 0x05, 0x07, 0x44, 0x0A, 0xE0, 0xF1, 0x09, 0xC4, + 0x57, 0xDB, 0xB1, 0xE9, 0xDA, 0x12, 0xC7, 0x42, 0xF5, 0x08, 0x87, 0x01, + 0xD0, 0x93, 0x6F, 0x9B, 0x8A, 0xE1, 0xD3, 0xA5, 0x24, 0x01, 0x4B, 0x97, + 0xA4, 0x94, 0x53, 0x21, 0xCB, 0x39, 0x4B, 0x04, 0x41, 0x74, 0xF5, 0xF6, + 0xEE, 0xE1, 0x61, 0x8B, 0x08, 0x4D, 0x6D, 0xCF, 0xCF, 0x16, 0xA7, 0xA7, + 0x4B, 0xEB, 0x2C, 0x1C, 0x5C, 0xAD, 0xB5, 0x06, 0x7D, 0xF8, 0x4D, 0x72, + 0x2E, 0x56, 0x83, 0xD2, 0xEA, 0xEA, 0xDD, 0xED, 0xE7, 0x5F, 0x5C, 0x5D, + 0xDD, 0xED, 0x3F, 0x79, 0x75, 0x33, 0xF8, 0x90, 0x49, 0x34, 0x75, 0x3D, + 0x84, 0xB8, 0xD9, 0xED, 0x86, 0x71, 0xAC, 0x9C, 0x5D, 0xAD, 0xD6, 0xBD, + 0x96, 0x20, 0xCE, 0x96, 0x8B, 0xC5, 0xC9, 0x72, 0xD1, 0x0F, 0xBE, 0xEB, + 0x86, 0xCF, 0xBF, 0xBC, 0xF9, 0xFC, 0xD5, 0x55, 0x5D, 0x55, 0x8B, 0xF9, + 0x6C, 0xB5, 0x5E, 0xAD, 0xDB, 0x5A, 0x02, 0x48, 0x84, 0x93, 0xD3, 0x05, + 0xBB, 0xF0, 0x16, 0x22, 0xC6, 0x89, 0x15, 0x41, 0x16, 0x25, 0x97, 0xCC, + 0x81, 0x5D, 0x63, 0x08, 0x39, 0xE6, 0x9C, 0x4B, 0x5D, 0x39, 0x00, 0x0C, + 0x31, 0xDF, 0xEE, 0xEF, 0x53, 0x4A, 0x61, 0x1F, 0x73, 0xE2, 0xD4, 0x4E, + 0x77, 0x7E, 0xBA, 0x8C, 0x29, 0xAF, 0x37, 0xDB, 0xDA, 0x59, 0xAB, 0x5B, + 0xBE, 0x56, 0x42, 0x88, 0xDE, 0x87, 0xDA, 0xB9, 0x92, 0xF3, 0xAC, 0xA9, + 0x25, 0x42, 0x8C, 0x91, 0x3F, 0xC5, 0x98, 0xB2, 0x44, 0x29, 0x88, 0x4A, + 0x2E, 0x7C, 0x38, 0x20, 0xA0, 0x35, 0x96, 0x25, 0xEA, 0x56, 0x6B, 0x25, + 0x55, 0xCE, 0x89, 0x49, 0x06, 0x52, 0xA2, 0x44, 0x74, 0x86, 0xED, 0x61, + 0x33, 0x22, 0x6E, 0x76, 0x1D, 0xE7, 0x2D, 0xC7, 0x94, 0x78, 0x33, 0x3C, + 0xFA, 0x60, 0x8C, 0xE1, 0x6B, 0x8B, 0x4F, 0xDD, 0x89, 0xF7, 0x2F, 0x91, + 0x59, 0x9D, 0x65, 0x72, 0x2E, 0x21, 0x04, 0xA8, 0x2B, 0x27, 0x04, 0x79, + 0xEF, 0x2B, 0xEB, 0xAE, 0xEF, 0x1F, 0x10, 0xA1, 0xA9, 0xA7, 0xA4, 0xB5, + 0xFD, 0x30, 0x02, 0x40, 0x53, 0x59, 0xA1, 0x00, 0x11, 0x72, 0xC8, 0xC4, + 0x2D, 0x12, 0xD1, 0xAC, 0x69, 0x51, 0x4A, 0x89, 0xB8, 0x98, 0xCF, 0xBE, + 0xF1, 0xE2, 0xD2, 0x55, 0x66, 0x3E, 0xAF, 0x67, 0x4D, 0x25, 0x51, 0x2A, + 0x25, 0x51, 0x42, 0x4E, 0x44, 0x24, 0x8C, 0x31, 0xA5, 0xE4, 0x7E, 0x08, + 0x29, 0x27, 0x29, 0x65, 0x26, 0x12, 0x25, 0xC9, 0x88, 0x52, 0x4A, 0xA5, + 0x55, 0xED, 0x5C, 0x3F, 0xFA, 0xE0, 0x23, 0x37, 0x2C, 0x39, 0x95, 0x14, + 0xD3, 0xFD, 0x6A, 0x5B, 0x39, 0xDB, 0xCE, 0x1A, 0xA3, 0x54, 0x29, 0x45, + 0x00, 0x2F, 0xC8, 0x80, 0x8B, 0x17, 0x08, 0xC1, 0x91, 0x05, 0xEC, 0x6D, + 0x97, 0x73, 0xD9, 0xEF, 0xFB, 0xDD, 0xBE, 0x1F, 0x46, 0xEF, 0x9C, 0xE3, + 0x51, 0x28, 0xC4, 0x20, 0x04, 0x2D, 0x97, 0x73, 0x00, 0xD1, 0x2F, 0x5A, + 0x57, 0xBB, 0xD7, 0xAF, 0xAF, 0x76, 0xFB, 0x2E, 0x97, 0xE9, 0x7D, 0xE8, + 0xFA, 0x21, 0x9A, 0x04, 0x20, 0x3E, 0xFD, 0xE2, 0x8D, 0x94, 0xB8, 0x98, + 0xB5, 0x31, 0x24, 0xE3, 0x0C, 0x02, 0xCC, 0xDA, 0xE6, 0xED, 0xBB, 0x9B, + 0x6F, 0x7F, 0xE7, 0x43, 0x96, 0x91, 0xED, 0xF6, 0xFB, 0x6F, 0xBE, 0xFF, + 0xF2, 0x4F, 0xFF, 0xE8, 0x07, 0xFB, 0xFD, 0xFE, 0x77, 0xBF, 0xFB, 0xEC, + 0x7B, 0xDF, 0xFB, 0xD6, 0xCD, 0xCD, 0xFD, 0x38, 0x8E, 0x31, 0xC4, 0xE5, + 0x72, 0x5E, 0x4A, 0x71, 0xD6, 0x2C, 0x66, 0x0D, 0x77, 0x43, 0x4C, 0xB8, + 0x61, 0x20, 0x1D, 0x10, 0xAC, 0xD5, 0xA5, 0x1C, 0x97, 0x89, 0xC0, 0xDB, + 0x92, 0x52, 0x26, 0xA2, 0x35, 0x93, 0xF2, 0x8F, 0x15, 0x8D, 0x1B, 0x52, + 0x63, 0xF4, 0xB7, 0x3F, 0xFC, 0x46, 0x55, 0x59, 0x5E, 0xB5, 0xA5, 0x9C, + 0x01, 0x80, 0x68, 0x62, 0x6F, 0xF1, 0x77, 0xA6, 0x98, 0x42, 0x0C, 0x39, + 0x4D, 0x0B, 0x99, 0x71, 0xF4, 0x8C, 0x6F, 0x96, 0x44, 0x39, 0x65, 0x29, + 0x11, 0x15, 0x08, 0x02, 0xAD, 0x15, 0x63, 0x85, 0x88, 0xE8, 0xBD, 0x17, + 0x42, 0xA4, 0x9C, 0x52, 0xCE, 0x54, 0x38, 0x9E, 0x1D, 0x53, 0x21, 0x40, + 0x74, 0x6C, 0x07, 0x8A, 0x70, 0xEC, 0x98, 0x0E, 0x45, 0x93, 0x4A, 0xA1, + 0x94, 0x52, 0x4E, 0x45, 0x94, 0xC2, 0x5D, 0x03, 0x11, 0x01, 0xA2, 0x94, + 0x68, 0x94, 0x94, 0x12, 0x33, 0xB3, 0xC8, 0x00, 0x8B, 0xA4, 0x42, 0x65, + 0x1A, 0x09, 0xA7, 0x82, 0x0B, 0x84, 0x53, 0x23, 0xF6, 0xB5, 0x61, 0x0E, + 0x0E, 0xD3, 0x80, 0xE4, 0x7F, 0x43, 0x40, 0xC4, 0x94, 0x4A, 0x29, 0x59, + 0xB0, 0xE1, 0x2D, 0x28, 0x1F, 0xC2, 0xA1, 0xBA, 0x89, 0x23, 0x94, 0xC6, + 0xE5, 0xF0, 0x38, 0x68, 0xFE, 0x67, 0x85, 0x8C, 0xBF, 0xE7, 0x71, 0x6F, + 0xAB, 0x10, 0x8E, 0xEB, 0xA3, 0x47, 0x5C, 0xEB, 0x50, 0x93, 0x04, 0x08, + 0xA0, 0x63, 0x0A, 0xDD, 0x93, 0xD5, 0xE1, 0xB1, 0x76, 0x3D, 0x3D, 0x6A, + 0x0E, 0x3C, 0xD8, 0xAF, 0xB4, 0x8F, 0x88, 0x72, 0xB7, 0xEF, 0x73, 0xCA, + 0xC6, 0xEA, 0xD9, 0xAC, 0x2E, 0x39, 0xDC, 0xDC, 0xDC, 0x2B, 0xA5, 0xC7, + 0x61, 0xF4, 0x31, 0xF3, 0xC7, 0x9C, 0x8B, 0x58, 0x6D, 0xFA, 0x5C, 0x68, + 0x36, 0xAB, 0xB5, 0xD6, 0xCE, 0x18, 0x6D, 0x4C, 0x29, 0x19, 0xC4, 0x04, + 0x2B, 0x56, 0xCE, 0x3E, 0xAC, 0xB7, 0x9F, 0x7C, 0xFC, 0xE9, 0x2F, 0x7F, + 0xF3, 0xFA, 0x66, 0x33, 0xEC, 0xBA, 0x51, 0x49, 0x79, 0x79, 0xF9, 0x6C, + 0xF4, 0x81, 0xA8, 0xD4, 0x75, 0x7D, 0xB2, 0x98, 0xBD, 0x7D, 0x7B, 0x1D, + 0xC6, 0xB1, 0xAD, 0xAA, 0x59, 0xDB, 0x66, 0xC2, 0x87, 0xCD, 0x3E, 0xA4, + 0x3C, 0x0C, 0xE3, 0xA7, 0x9F, 0xBD, 0x7E, 0x7D, 0x75, 0xB3, 0xEF, 0xFA, + 0xC5, 0xAC, 0xCD, 0x39, 0xB5, 0x6D, 0xBD, 0xDF, 0x75, 0x29, 0xC5, 0x3F, + 0xFC, 0xC1, 0x77, 0x88, 0xC8, 0x7B, 0xAF, 0xB5, 0x66, 0xB9, 0xB8, 0x56, + 0x2A, 0xC6, 0x44, 0x82, 0x52, 0x4E, 0xC3, 0x18, 0xB6, 0xBB, 0xCE, 0xFB, + 0xA8, 0x94, 0x2A, 0xB9, 0xC4, 0x94, 0x36, 0xDB, 0xDD, 0xDD, 0xDD, 0x6A, + 0xD7, 0xF5, 0x29, 0xE5, 0x93, 0xE5, 0xFC, 0x83, 0xEF, 0xBC, 0xAC, 0x2A, + 0x57, 0x57, 0x6E, 0x3E, 0x6F, 0xFA, 0x7E, 0xD8, 0xED, 0x7B, 0x3E, 0x0C, + 0x47, 0x1F, 0x46, 0x1F, 0xBC, 0x0F, 0xDF, 0xFD, 0xF6, 0x37, 0xC7, 0x61, + 0x58, 0xAD, 0x36, 0xFB, 0xAE, 0x0F, 0x31, 0x21, 0x1C, 0x50, 0x21, 0x10, + 0x3E, 0x78, 0xE7, 0x2C, 0x9F, 0x0A, 0x13, 0x07, 0x42, 0x10, 0xEF, 0x19, + 0x23, 0x07, 0xF0, 0xC8, 0x69, 0x8B, 0x4A, 0x00, 0x80, 0xC0, 0xFA, 0x3B, + 0x44, 0xE4, 0x66, 0x8D, 0x04, 0xF5, 0xA3, 0x3F, 0xD4, 0x44, 0xE4, 0x19, + 0x93, 0x90, 0xDD, 0xEF, 0xA8, 0xB2, 0x16, 0x00, 0xB4, 0x52, 0x7C, 0x20, + 0x83, 0x10, 0x45, 0x10, 0x77, 0x93, 0x39, 0x67, 0xEF, 0x43, 0x11, 0xA4, + 0x50, 0x32, 0x3A, 0x3D, 0x6B, 0xEB, 0x94, 0x92, 0xB3, 0xA6, 0xF7, 0x41, + 0x69, 0xD5, 0x38, 0x6B, 0x8D, 0x61, 0xD0, 0x42, 0x6B, 0xCD, 0xB7, 0x53, + 0x53, 0x39, 0x02, 0x31, 0xFA, 0xF1, 0xEC, 0x64, 0xF9, 0xEC, 0xD9, 0xD9, + 0xF9, 0xF9, 0x72, 0xB1, 0x68, 0x8C, 0x54, 0x88, 0x02, 0x25, 0x32, 0xD5, + 0x0E, 0x90, 0x10, 0x10, 0x89, 0xFC, 0x98, 0x00, 0x68, 0xBA, 0x7B, 0x89, + 0x63, 0xD9, 0x89, 0x6F, 0x9B, 0x94, 0xF3, 0x76, 0xBB, 0x0F, 0x29, 0xC9, + 0x03, 0x68, 0xED, 0x43, 0xDC, 0x77, 0x3D, 0x11, 0x19, 0x33, 0xD1, 0x44, + 0x00, 0x40, 0x40, 0xCC, 0xB9, 0x10, 0x95, 0x9C, 0x0B, 0xE7, 0x46, 0xE3, + 0x21, 0x3E, 0x34, 0x97, 0x5C, 0xA6, 0x2D, 0x27, 0x29, 0xA5, 0x72, 0x4E, + 0x1C, 0xA1, 0x06, 0x00, 0x9F, 0x7F, 0xF1, 0xE5, 0x62, 0x31, 0xAB, 0x2A, + 0x3B, 0x9B, 0x35, 0xE3, 0x38, 0xBE, 0x7D, 0x77, 0xC3, 0xCC, 0x7E, 0xAD, + 0x95, 0x0F, 0x7D, 0x37, 0x8C, 0x4D, 0xDD, 0xB4, 0x4D, 0xF5, 0xEB, 0xDF, + 0x7E, 0xFE, 0x9D, 0x0F, 0xDF, 0x3B, 0x3F, 0x3B, 0x01, 0x00, 0x57, 0x39, + 0xA5, 0x25, 0xCA, 0x67, 0xFB, 0xFD, 0x7E, 0x36, 0x6B, 0xAD, 0x96, 0x7A, + 0x31, 0x5B, 0xAF, 0x36, 0xDF, 0xFE, 0xF6, 0x07, 0x9B, 0xF5, 0xF6, 0xE1, + 0x61, 0x7D, 0x7D, 0x7D, 0xBB, 0x5C, 0xCE, 0xF9, 0x59, 0x52, 0x8C, 0xC6, + 0x9A, 0xCD, 0x76, 0x7B, 0x7E, 0x7E, 0x2A, 0x01, 0xB2, 0x10, 0xC0, 0x46, + 0x95, 0x40, 0x39, 0x97, 0x31, 0x44, 0x8E, 0xDD, 0x62, 0x4E, 0xB2, 0x10, + 0x13, 0xFB, 0x1F, 0x11, 0x63, 0x4C, 0x30, 0xE9, 0xBA, 0x94, 0xD6, 0x00, + 0x13, 0xBF, 0xA7, 0x20, 0xE2, 0x72, 0x39, 0x03, 0x01, 0x6C, 0xFA, 0xCA, + 0x66, 0xA2, 0x21, 0x44, 0xC6, 0x10, 0xF9, 0x45, 0xA5, 0x94, 0x48, 0x90, + 0xD6, 0x3A, 0xF8, 0x41, 0x4A, 0xCD, 0x5C, 0x93, 0xA9, 0x07, 0x94, 0xC2, + 0x4A, 0xA3, 0xF4, 0x94, 0x65, 0xEB, 0xC7, 0xB0, 0xDD, 0x6E, 0x05, 0x73, + 0xB0, 0x4B, 0xCE, 0xA5, 0xE4, 0x54, 0x48, 0x88, 0xE0, 0x47, 0x29, 0x51, + 0x2A, 0x94, 0x28, 0x6B, 0x6B, 0x58, 0x3D, 0x9E, 0x73, 0x66, 0xE9, 0xED, + 0xB1, 0x34, 0xF0, 0xF5, 0x1F, 0x53, 0x3E, 0x12, 0x6E, 0x78, 0x79, 0x80, + 0x70, 0x8C, 0x62, 0x93, 0x0E, 0x39, 0xD9, 0x9A, 0x72, 0x2E, 0xBC, 0x64, + 0xCE, 0x47, 0xBA, 0x3C, 0x30, 0xAB, 0xEC, 0x31, 0xEB, 0xE3, 0x58, 0x22, + 0x73, 0x3E, 0x02, 0x50, 0xC4, 0xD2, 0x1E, 0x21, 0x48, 0x4A, 0x00, 0x90, + 0x44, 0x84, 0x48, 0x14, 0x59, 0x69, 0xF7, 0x18, 0xCA, 0x45, 0x93, 0x82, + 0xE2, 0xB1, 0xA5, 0x3D, 0xCA, 0x16, 0x9F, 0xF4, 0x62, 0xE2, 0xE8, 0xA8, + 0x31, 0x15, 0x32, 0xF6, 0xA5, 0x79, 0xBA, 0x92, 0x9D, 0xCA, 0x16, 0x4C, + 0x0B, 0x72, 0xF8, 0x2F, 0xD5, 0xAF, 0xAF, 0x61, 0xFC, 0x38, 0xB5, 0x66, + 0xD3, 0xCF, 0x73, 0xE9, 0xE3, 0xB6, 0x72, 0x1C, 0xFD, 0xCD, 0xDD, 0x46, + 0x29, 0xA5, 0x7D, 0xBA, 0x5F, 0xED, 0xAD, 0x56, 0x25, 0xC3, 0x30, 0x0E, + 0x39, 0x97, 0x7D, 0x3F, 0xA6, 0x94, 0x51, 0x88, 0xC1, 0xC7, 0xA6, 0x76, + 0xC6, 0x68, 0x01, 0x03, 0x95, 0x0E, 0x88, 0x9E, 0xBF, 0xB8, 0x68, 0x67, + 0xB3, 0x18, 0xA2, 0xD3, 0x2A, 0xC6, 0xF8, 0x37, 0xBF, 0xFC, 0xE4, 0xE3, + 0x4F, 0xDE, 0xAC, 0xB6, 0xE3, 0xF5, 0xC3, 0x46, 0x1B, 0x5B, 0xD5, 0xD5, + 0x72, 0x31, 0xCF, 0xB9, 0x84, 0x18, 0x2B, 0xE7, 0x4E, 0xE6, 0x7A, 0xF5, + 0xB0, 0xA6, 0x52, 0x9A, 0xBA, 0x46, 0xC4, 0xA6, 0x69, 0x56, 0x9B, 0xED, + 0xEB, 0x37, 0x5F, 0x4A, 0x94, 0x39, 0x97, 0x9B, 0xBB, 0x15, 0x5B, 0xA7, + 0x8F, 0xE3, 0xC8, 0xB6, 0x70, 0x5F, 0xBC, 0x7E, 0x73, 0xB2, 0x98, 0x1F, + 0x48, 0x7F, 0x88, 0x87, 0x76, 0x29, 0xA4, 0x54, 0x88, 0x72, 0x2A, 0x21, + 0xA6, 0x74, 0x90, 0xB9, 0x0C, 0xA3, 0xE7, 0x17, 0xAC, 0xB5, 0x56, 0x5A, + 0x9D, 0x9D, 0x2E, 0x97, 0xB3, 0xF6, 0xD9, 0xB3, 0xF3, 0xDD, 0xBE, 0x7B, + 0x78, 0x58, 0xDD, 0xE4, 0xCC, 0x26, 0xBA, 0x5D, 0x3F, 0xF4, 0xE3, 0x08, + 0x02, 0x9C, 0xB3, 0x8C, 0xCA, 0xEF, 0xF7, 0x5D, 0xB7, 0xDF, 0x4B, 0x29, + 0x59, 0xB1, 0xC8, 0xCA, 0x41, 0x25, 0x65, 0x88, 0xF1, 0x58, 0x3A, 0x61, + 0x02, 0x44, 0x33, 0x5B, 0xA7, 0x1F, 0x97, 0xD0, 0x25, 0x53, 0x8C, 0x11, + 0x10, 0x73, 0x4C, 0x23, 0x00, 0x07, 0x61, 0xE4, 0x9C, 0x8D, 0xD6, 0x46, + 0x6B, 0x1F, 0x83, 0xB3, 0x06, 0xA5, 0xC4, 0x42, 0x5A, 0x21, 0x5F, 0x04, + 0xA5, 0x14, 0x2D, 0xE5, 0xE0, 0xBD, 0x91, 0x52, 0x08, 0x42, 0x10, 0x5A, + 0x4A, 0x6E, 0xFE, 0x9D, 0x35, 0x4C, 0x02, 0xD0, 0x4A, 0x8D, 0x3E, 0xF8, + 0x18, 0x1B, 0xE7, 0x86, 0xE2, 0xAD, 0xD1, 0x31, 0xA5, 0x61, 0x0C, 0xE0, + 0x44, 0x4A, 0x49, 0x21, 0x38, 0x6B, 0x38, 0xE0, 0x56, 0x49, 0x99, 0x92, + 0x2E, 0x54, 0x8C, 0x92, 0x85, 0x28, 0x84, 0x50, 0x39, 0x7B, 0x71, 0x7E, + 0x72, 0x71, 0xB6, 0xA8, 0x2A, 0xA3, 0x18, 0x5A, 0x98, 0x6C, 0xA0, 0x1F, + 0x31, 0xA0, 0x9C, 0x13, 0x4A, 0xE4, 0x05, 0x45, 0x26, 0x86, 0x44, 0x28, + 0x13, 0x89, 0x89, 0x7E, 0xCC, 0x0B, 0x3E, 0x8E, 0xA3, 0xA2, 0x18, 0xD3, + 0x30, 0x7A, 0x89, 0x28, 0x15, 0xE6, 0x5C, 0x62, 0x88, 0x39, 0xE5, 0x10, + 0x13, 0x11, 0x6D, 0xB6, 0xBB, 0xAE, 0x1F, 0x53, 0xCA, 0x8B, 0x45, 0x5B, + 0x57, 0x4E, 0x49, 0xA9, 0x94, 0xEC, 0xFB, 0xF1, 0xFE, 0x61, 0x73, 0x73, + 0xBB, 0x1A, 0xBD, 0x4F, 0x39, 0xDD, 0xDF, 0x3F, 0x30, 0x54, 0xA4, 0x94, + 0xF2, 0x21, 0xFA, 0x10, 0xB7, 0xBB, 0xFD, 0x7C, 0xD6, 0x02, 0x40, 0x5D, + 0x57, 0x3F, 0xFC, 0xA3, 0x1F, 0xBC, 0x7E, 0xFD, 0xF6, 0xFE, 0xFE, 0xA1, + 0xEB, 0x87, 0x42, 0xE4, 0x43, 0xF4, 0x61, 0x0D, 0x42, 0xC4, 0x10, 0x7F, + 0xF5, 0xDB, 0xCF, 0x5E, 0x3C, 0xDB, 0xFD, 0xED, 0x1F, 0x7E, 0x64, 0xAD, + 0x36, 0x46, 0xCF, 0x67, 0xED, 0x30, 0x8E, 0x4A, 0x29, 0xAD, 0xE4, 0x38, + 0xC6, 0x61, 0x1C, 0xC7, 0x7E, 0x38, 0x3D, 0x99, 0x2B, 0x89, 0xDD, 0xBE, + 0x73, 0x5A, 0xCD, 0x9A, 0x5A, 0x49, 0xB9, 0xEF, 0xFA, 0x13, 0xA3, 0x79, + 0x6D, 0x3D, 0x6F, 0x6B, 0x09, 0x53, 0x94, 0x19, 0x0A, 0x21, 0x10, 0x2A, + 0x6B, 0x4A, 0x61, 0x17, 0x99, 0x3C, 0xFA, 0x30, 0xA1, 0x7B, 0x82, 0xA4, + 0x54, 0x3C, 0x2A, 0x32, 0xEA, 0x24, 0x11, 0x98, 0xEC, 0x6D, 0x0C, 0xC7, + 0x0C, 0x8B, 0x5C, 0x4A, 0x8A, 0x69, 0xBF, 0xEB, 0x8C, 0xD5, 0x06, 0x55, + 0x4A, 0x49, 0x29, 0xC9, 0x5E, 0x66, 0x47, 0x07, 0xC0, 0x83, 0xC5, 0x6B, + 0x1A, 0x06, 0x0F, 0x00, 0xCE, 0x59, 0xCB, 0xEA, 0x54, 0x60, 0x21, 0x70, + 0x8E, 0x21, 0x5F, 0x5D, 0x5D, 0xA7, 0x9C, 0x6B, 0xE7, 0x0A, 0x95, 0x18, + 0x53, 0xDF, 0x8F, 0xC7, 0x4E, 0x50, 0x29, 0x9B, 0x52, 0x46, 0x05, 0x5A, + 0xA2, 0xB3, 0x9A, 0x3D, 0x9A, 0x52, 0x2E, 0xCC, 0x22, 0xA0, 0x3C, 0x35, + 0x95, 0x39, 0x67, 0x10, 0x42, 0x4A, 0x40, 0x40, 0x63, 0x94, 0x31, 0x8F, + 0x36, 0xCE, 0x52, 0x4A, 0x00, 0x7C, 0x42, 0xB6, 0x98, 0x96, 0x8C, 0x78, + 0x40, 0xAF, 0x78, 0xDF, 0x40, 0x07, 0x2E, 0x9B, 0xE0, 0xD2, 0x76, 0x58, + 0x2F, 0xF0, 0xED, 0xC3, 0xF9, 0x8C, 0xF0, 0x28, 0x30, 0x10, 0x44, 0xC0, + 0x4F, 0x6A, 0xB4, 0xE6, 0x47, 0xCD, 0xB9, 0x14, 0x0E, 0x18, 0x04, 0x36, + 0xAD, 0x98, 0xF0, 0x7A, 0x64, 0x0C, 0xF5, 0x91, 0x59, 0xF6, 0x95, 0x2A, + 0xC6, 0x7F, 0x4E, 0x32, 0xD1, 0xA7, 0xFF, 0xFA, 0xB4, 0xA1, 0x3A, 0xF4, + 0x5B, 0x5F, 0xEF, 0xC2, 0xC4, 0x13, 0x12, 0x05, 0x08, 0xE2, 0xB6, 0xED, + 0xE9, 0x28, 0x0A, 0x00, 0xDE, 0x47, 0xA2, 0x78, 0xF5, 0xEE, 0xFE, 0xDD, + 0xCD, 0xC3, 0x62, 0xDE, 0x7A, 0x1F, 0x72, 0xCA, 0x52, 0xE1, 0x37, 0xDE, + 0xBB, 0xCC, 0x5E, 0x0C, 0x3E, 0x22, 0xCA, 0x7E, 0xE8, 0x11, 0xB1, 0x02, + 0x8C, 0xA9, 0xEC, 0xF7, 0x03, 0x08, 0xD0, 0x46, 0x75, 0xFD, 0xF0, 0xD9, + 0x67, 0x5F, 0x9E, 0x9E, 0xCE, 0x3F, 0xF8, 0xE0, 0xBD, 0xAB, 0x77, 0x77, + 0xFF, 0xE1, 0xFF, 0xFB, 0xF5, 0xEB, 0xB7, 0xF7, 0x21, 0x96, 0xBB, 0xF5, + 0xB6, 0xA9, 0x6B, 0x76, 0x94, 0x16, 0x02, 0x4A, 0x2E, 0xEB, 0xF5, 0xE6, + 0x36, 0xDE, 0x0E, 0xDD, 0x60, 0x8C, 0xF6, 0x21, 0xE6, 0x94, 0x2E, 0xCE, + 0x4F, 0xFF, 0xFA, 0x3F, 0xFD, 0x6C, 0xB3, 0xD9, 0x4A, 0x29, 0x9D, 0xB5, + 0xAC, 0x31, 0xCA, 0xE3, 0x18, 0x43, 0xA9, 0xE7, 0x6D, 0xDB, 0x36, 0x54, + 0xCA, 0xF3, 0xCB, 0x8B, 0xCB, 0xCB, 0xD3, 0x98, 0x92, 0xCE, 0xBA, 0xAE, + 0x2B, 0x22, 0x4A, 0x31, 0x17, 0x11, 0x51, 0xC9, 0x92, 0xC5, 0xE8, 0x7D, + 0x4C, 0xB9, 0x94, 0x62, 0xAD, 0x01, 0xC4, 0x7D, 0x37, 0x28, 0xA5, 0x86, + 0x71, 0xDC, 0x6E, 0x36, 0x46, 0x4B, 0x00, 0xE8, 0xFA, 0xFE, 0x77, 0xBF, + 0xFB, 0x6C, 0xB5, 0xD9, 0x71, 0xF4, 0x06, 0x11, 0x71, 0xC3, 0x55, 0xD7, + 0x95, 0x10, 0x6C, 0x42, 0x99, 0xA5, 0x94, 0x77, 0xF7, 0x0F, 0x6D, 0x5D, + 0x31, 0xD0, 0x90, 0x12, 0xC5, 0x94, 0x46, 0x1F, 0xD8, 0x7A, 0x8C, 0xAB, + 0x95, 0xB3, 0x16, 0x00, 0xD8, 0x65, 0x21, 0xE5, 0x1C, 0x73, 0x66, 0xEE, + 0x98, 0x96, 0x32, 0x17, 0x92, 0x12, 0x8D, 0xD6, 0x60, 0x35, 0x8F, 0x30, + 0x31, 0x26, 0x29, 0x91, 0xA8, 0x8C, 0xDE, 0x17, 0x22, 0xAD, 0x75, 0x3F, + 0x8C, 0x31, 0x46, 0x21, 0x84, 0x35, 0x1A, 0x04, 0x94, 0x92, 0x25, 0xF2, + 0xF9, 0xCC, 0x4B, 0x06, 0x29, 0x04, 0x85, 0x90, 0x99, 0xB5, 0x20, 0xA5, + 0x34, 0x46, 0x1B, 0xAD, 0x52, 0x2E, 0x08, 0x18, 0x52, 0x72, 0x56, 0x6B, + 0x85, 0x5D, 0x3F, 0xFA, 0x90, 0x4A, 0x2E, 0x00, 0xA2, 0xAD, 0xAB, 0x52, + 0x4A, 0x4C, 0xD9, 0x68, 0x4D, 0xEC, 0xE5, 0x6F, 0xAC, 0x52, 0x12, 0x84, + 0x28, 0x85, 0xE6, 0xB3, 0x66, 0x39, 0x6F, 0x95, 0x62, 0x7E, 0x00, 0xA0, + 0x9C, 0xC8, 0x77, 0xD3, 0xC0, 0x00, 0x4C, 0xF5, 0x42, 0x63, 0x74, 0x10, + 0x02, 0x62, 0x52, 0x20, 0x32, 0x11, 0xA7, 0xFD, 0x92, 0x28, 0x25, 0x11, + 0x11, 0x69, 0xA3, 0x42, 0x08, 0x2C, 0xDD, 0x4D, 0x69, 0xF2, 0x05, 0xD3, + 0x5A, 0xC5, 0x94, 0xBC, 0x0F, 0x5C, 0x16, 0xBB, 0x7E, 0x78, 0x58, 0x6D, + 0x87, 0xD1, 0x4B, 0x89, 0x02, 0x05, 0x8F, 0x93, 0x29, 0x27, 0x22, 0xEA, + 0x3B, 0xDF, 0x0F, 0x03, 0x8F, 0x69, 0xB9, 0x64, 0x0E, 0x91, 0xCE, 0xB9, + 0x74, 0x5D, 0x77, 0x1C, 0xC4, 0xAC, 0x35, 0xDE, 0x87, 0x71, 0xF4, 0x17, + 0xE7, 0x27, 0x55, 0x65, 0xA5, 0xC2, 0xEB, 0x9B, 0x7B, 0x63, 0xCC, 0x6A, + 0xBD, 0xED, 0xBA, 0x9E, 0x6A, 0x5B, 0x55, 0xF6, 0xF7, 0x9F, 0xBF, 0x19, + 0x7C, 0xF8, 0x6F, 0xFE, 0xC5, 0x5F, 0x54, 0xD6, 0xAE, 0xD6, 0xDB, 0xD3, + 0xE5, 0x22, 0xE5, 0xEC, 0x7D, 0xC8, 0x39, 0x39, 0xA3, 0x4B, 0xC9, 0x80, + 0xC2, 0x58, 0x5D, 0x72, 0xEE, 0xF6, 0xFD, 0xF2, 0x64, 0x51, 0x3B, 0x8B, + 0x00, 0xC3, 0x30, 0x2E, 0x96, 0x0B, 0x2E, 0x31, 0x3C, 0xA1, 0x4D, 0x37, + 0x0E, 0x00, 0xF2, 0xAE, 0x57, 0x29, 0x89, 0x58, 0x59, 0xC3, 0xC6, 0xD0, + 0x0C, 0x81, 0xE5, 0x2C, 0xB4, 0x52, 0xA6, 0x72, 0x4A, 0x49, 0x00, 0x61, + 0xB4, 0x14, 0x02, 0x19, 0x14, 0x8A, 0x29, 0x0D, 0xA3, 0x4F, 0x89, 0x2D, + 0xAD, 0x8A, 0xA7, 0x38, 0x9F, 0x35, 0x52, 0xCA, 0x5C, 0x0A, 0xC3, 0xF3, + 0x44, 0x14, 0x63, 0x8C, 0x31, 0xD6, 0x4D, 0x1D, 0x7D, 0x98, 0xCF, 0x5B, + 0x76, 0xEC, 0x41, 0xC4, 0xA1, 0x1F, 0x8D, 0x35, 0x39, 0x07, 0xAD, 0xD4, + 0xBB, 0x77, 0x37, 0xBB, 0x5D, 0x67, 0xAD, 0xF5, 0x21, 0xE6, 0x92, 0xBB, + 0x6E, 0x30, 0x4A, 0xA7, 0x94, 0xD8, 0x19, 0x25, 0xC6, 0x4C, 0xA5, 0xA8, + 0x89, 0x74, 0xA9, 0x9D, 0x55, 0x1C, 0xE1, 0x8A, 0x12, 0x0E, 0xDD, 0xED, + 0x11, 0xA2, 0x2A, 0x12, 0xA4, 0x31, 0x4A, 0xA9, 0x49, 0x50, 0xC8, 0x9F, + 0xC8, 0xF1, 0x96, 0xA7, 0x23, 0xDB, 0x96, 0x44, 0x4A, 0x85, 0x55, 0x53, + 0xC4, 0x5E, 0x52, 0x02, 0x50, 0x88, 0xC8, 0xA3, 0x25, 0x3D, 0x99, 0xD5, + 0x9E, 0x16, 0x16, 0x5E, 0x41, 0x3E, 0x0D, 0xB8, 0x16, 0x93, 0xFD, 0x3C, + 0x00, 0x4C, 0x5C, 0xFD, 0xC3, 0x9A, 0x95, 0xDF, 0x13, 0x3A, 0x36, 0x58, + 0x24, 0x58, 0xF0, 0x4D, 0x07, 0xC4, 0x8C, 0x9E, 0x04, 0x5B, 0x12, 0x11, + 0xFC, 0xF4, 0x27, 0x3F, 0x7F, 0xF2, 0xFF, 0xA6, 0x49, 0x55, 0x1C, 0x46, + 0xD6, 0x23, 0xD9, 0x55, 0x4A, 0x2C, 0xB9, 0x30, 0xFF, 0x5D, 0x10, 0x1D, + 0x86, 0x62, 0x51, 0x26, 0xBD, 0xD1, 0x57, 0xBA, 0x36, 0x22, 0xD2, 0x5A, + 0xDE, 0xDC, 0xAC, 0x7F, 0xF7, 0xD9, 0xDB, 0xB6, 0xA9, 0xAC, 0x31, 0xC3, + 0xE8, 0x79, 0xC2, 0x12, 0x44, 0x1F, 0x7D, 0xF7, 0xFD, 0x93, 0xC5, 0xEC, + 0xD5, 0x9B, 0x6B, 0x00, 0x48, 0x29, 0x73, 0xE3, 0x3A, 0x0C, 0x5E, 0x90, + 0x60, 0x3B, 0x91, 0xB6, 0xAD, 0x6A, 0xE7, 0xD6, 0xDB, 0x5D, 0x28, 0xE5, + 0x8B, 0x37, 0xB7, 0xB7, 0xF7, 0xBB, 0x31, 0xF8, 0x94, 0x4A, 0x11, 0xC2, + 0x39, 0xA7, 0x24, 0x0A, 0x21, 0x86, 0x31, 0xF8, 0x61, 0xF0, 0xE3, 0x48, + 0x42, 0xD4, 0x4D, 0xE3, 0xC7, 0xB1, 0xEB, 0xFB, 0x10, 0x22, 0x15, 0xF2, + 0x21, 0x5A, 0x37, 0x25, 0x62, 0x71, 0x32, 0xD0, 0xDB, 0xB7, 0x37, 0x29, + 0x65, 0x57, 0x59, 0xAD, 0xE4, 0xF3, 0xCB, 0xF3, 0x3F, 0xF8, 0xE8, 0x5B, + 0x75, 0x6D, 0xB5, 0xD6, 0xF3, 0xB6, 0x96, 0x5A, 0x75, 0xDD, 0xC0, 0x71, + 0x1B, 0x24, 0xC8, 0x0F, 0x61, 0x08, 0x61, 0x1C, 0x03, 0xCF, 0xB9, 0x39, + 0x97, 0x92, 0x69, 0xB3, 0xDD, 0xFD, 0xFA, 0x37, 0x9F, 0x8C, 0xA3, 0xCF, + 0x24, 0x62, 0xCA, 0x78, 0x50, 0x14, 0xE4, 0x52, 0x62, 0xCA, 0x21, 0xA5, + 0x52, 0xC8, 0x6A, 0xDD, 0xD4, 0x15, 0x89, 0x89, 0x67, 0x9B, 0x4B, 0x19, + 0x87, 0xA1, 0xA9, 0x1C, 0x37, 0x7A, 0x56, 0x6B, 0x36, 0xDE, 0x91, 0x52, + 0xB1, 0x71, 0x33, 0x22, 0x56, 0xCE, 0x86, 0xC8, 0x6B, 0xB7, 0xE9, 0xEC, + 0xE2, 0x1E, 0x8D, 0x2B, 0x35, 0x4C, 0x15, 0x42, 0x00, 0x40, 0x2E, 0xC5, + 0xFB, 0xD8, 0xD4, 0xEE, 0xE2, 0x64, 0xB6, 0xD9, 0xED, 0xA5, 0x54, 0xC3, + 0xE8, 0x37, 0xFB, 0x9E, 0x3D, 0x70, 0x84, 0x10, 0x56, 0x29, 0xBE, 0x26, + 0xF6, 0xC3, 0x78, 0x3A, 0x9F, 0x91, 0x28, 0xFD, 0x18, 0x80, 0x45, 0xCF, + 0x07, 0x0E, 0xB7, 0x56, 0x32, 0xC4, 0x24, 0xC4, 0xB4, 0xA4, 0x6F, 0x1B, + 0x6B, 0xB5, 0xDC, 0xEC, 0x06, 0x76, 0xC4, 0x6C, 0x6A, 0x77, 0xBE, 0x5C, + 0xE4, 0x92, 0x8D, 0x36, 0xCB, 0xE5, 0x3C, 0xE7, 0xAC, 0x94, 0x6A, 0x9B, + 0xAA, 0xEB, 0x06, 0xAD, 0xE5, 0x72, 0x31, 0xAB, 0x2B, 0x7B, 0x71, 0x76, + 0xBA, 0x58, 0x34, 0x4D, 0xED, 0x8C, 0xD5, 0xEC, 0xB2, 0x70, 0x6C, 0xC7, + 0xF8, 0xB4, 0xA3, 0x52, 0x72, 0x2E, 0x3E, 0x44, 0x76, 0xB8, 0x0B, 0x21, + 0xC5, 0x9C, 0x40, 0x40, 0xCE, 0x14, 0x53, 0x64, 0xAE, 0x55, 0xDF, 0x0D, + 0xBC, 0x0B, 0x1E, 0x86, 0x61, 0x18, 0x3C, 0xA2, 0x54, 0x5A, 0x8E, 0xA3, + 0x8F, 0x21, 0x19, 0x63, 0x06, 0xEF, 0x3F, 0x7F, 0xF5, 0xA5, 0xD1, 0xBA, + 0x6D, 0xEA, 0xB6, 0xAD, 0xB4, 0xD2, 0xF7, 0xEB, 0x4D, 0xD7, 0x0F, 0xEB, + 0xF5, 0x36, 0xA5, 0xDC, 0x54, 0x4E, 0x29, 0x76, 0x5E, 0x2B, 0x27, 0x27, + 0x0B, 0xEF, 0xA3, 0x0F, 0x21, 0x71, 0xD2, 0x44, 0x2E, 0x5A, 0x2B, 0x00, + 0xE1, 0xAC, 0x53, 0x52, 0x56, 0x95, 0x63, 0xC6, 0x1C, 0x51, 0x89, 0x31, + 0x11, 0x51, 0xD7, 0x0D, 0x5D, 0x3F, 0x38, 0xE7, 0xEA, 0xDA, 0x52, 0xA1, + 0x94, 0x8B, 0xB5, 0xEA, 0xBF, 0xFB, 0x97, 0xFF, 0x54, 0x4A, 0x19, 0x42, + 0x38, 0x3D, 0x5D, 0x8C, 0x3E, 0x08, 0x12, 0xDB, 0xCD, 0xB6, 0xAE, 0x9C, + 0x98, 0x90, 0xD9, 0x1C, 0x42, 0x54, 0x4A, 0x5A, 0xE7, 0x38, 0x28, 0x0F, + 0xA5, 0x34, 0x5A, 0x1B, 0xA3, 0x9C, 0xB3, 0x28, 0x25, 0x53, 0xC5, 0xB8, + 0xC9, 0x52, 0x4F, 0x42, 0x4E, 0x85, 0x10, 0xEC, 0xC7, 0xC9, 0x07, 0xDD, + 0xE4, 0x6E, 0x25, 0x41, 0xE0, 0x14, 0x52, 0x16, 0x42, 0xF4, 0x21, 0xEC, + 0xBB, 0x0E, 0x04, 0x18, 0x63, 0xFB, 0x7D, 0xB7, 0x58, 0xCE, 0x85, 0x10, + 0x6D, 0x5D, 0x91, 0x10, 0x9B, 0xDD, 0x1E, 0x11, 0xB8, 0x6D, 0x5F, 0xAD, + 0xD6, 0x31, 0xA4, 0xAA, 0x76, 0x2C, 0x1F, 0x54, 0x52, 0xCD, 0xE6, 0xED, + 0x38, 0x8E, 0x21, 0xC4, 0xA1, 0xF7, 0x55, 0x6D, 0x57, 0xAB, 0xCD, 0xCD, + 0xCD, 0x3D, 0x22, 0xFA, 0x31, 0xA0, 0xC4, 0xDE, 0xFB, 0x8B, 0xF3, 0x53, + 0x09, 0xC8, 0xE9, 0x3C, 0x85, 0x0A, 0x02, 0xB4, 0x6D, 0x75, 0x76, 0xB2, + 0x5C, 0xCC, 0x9B, 0xA6, 0xAE, 0xF8, 0x28, 0x15, 0xC8, 0xE2, 0x81, 0x49, + 0xB3, 0x41, 0x44, 0x39, 0x4F, 0x4B, 0x52, 0xDE, 0x2C, 0xE1, 0x31, 0xCC, + 0xA1, 0x3C, 0xAE, 0x62, 0x0F, 0xDF, 0x3C, 0x79, 0x5E, 0x3D, 0xBD, 0xE5, + 0xF9, 0xCF, 0x03, 0x43, 0x8C, 0xE8, 0xAB, 0x46, 0x5B, 0x87, 0xB9, 0x6E, + 0x2A, 0x5E, 0xA5, 0x3C, 0x76, 0x5B, 0x44, 0x07, 0x1C, 0x8C, 0xA0, 0x7C, + 0x45, 0xF3, 0x48, 0xAC, 0x2C, 0xE4, 0xD2, 0x99, 0x26, 0x21, 0xC3, 0xD7, + 0xD5, 0x02, 0xE2, 0x38, 0x5A, 0x3A, 0xAB, 0xCA, 0x81, 0x91, 0x56, 0x0E, + 0x0F, 0x7A, 0x74, 0x20, 0x10, 0x42, 0xB0, 0xB7, 0xC1, 0xC7, 0xBF, 0x7B, + 0xF5, 0xE5, 0xDB, 0xFB, 0xEF, 0x7C, 0xF8, 0xB2, 0xA9, 0xDD, 0x72, 0x5E, + 0xB3, 0x2B, 0xF1, 0xB1, 0x28, 0x96, 0x03, 0x45, 0xED, 0xF0, 0x4B, 0x53, + 0x08, 0xE9, 0xF5, 0xD5, 0xDD, 0x6A, 0xB3, 0xEB, 0x47, 0xAF, 0x94, 0x54, + 0x88, 0x4C, 0x29, 0xD8, 0xEE, 0xBA, 0x5F, 0x7D, 0xFC, 0xF9, 0xC9, 0xA2, + 0xB9, 0xBC, 0x38, 0xAB, 0x6B, 0x37, 0x9B, 0x35, 0xDB, 0x5D, 0xF7, 0xEE, + 0xFA, 0x7E, 0xBB, 0xEF, 0x97, 0xF3, 0x96, 0x04, 0xA6, 0x22, 0x7A, 0x9F, + 0x6E, 0xEE, 0x6F, 0x5F, 0xBF, 0xBB, 0xBF, 0x7B, 0x58, 0x87, 0x98, 0x16, + 0xF3, 0x59, 0xE5, 0xDC, 0xE8, 0x03, 0x80, 0x44, 0x01, 0x37, 0x77, 0xF7, + 0x77, 0x77, 0x0F, 0x28, 0xA0, 0xA9, 0x6A, 0x96, 0xA9, 0x5E, 0xDF, 0x7C, + 0x11, 0x63, 0x7C, 0xFF, 0x1B, 0x2F, 0x25, 0xCA, 0x52, 0xCA, 0x87, 0x1F, + 0xBE, 0xDF, 0xB6, 0x6D, 0x4E, 0xD1, 0x8F, 0xE3, 0x6A, 0xB5, 0xEE, 0xFA, + 0x41, 0x08, 0xE1, 0x63, 0xD4, 0x56, 0x7F, 0xE3, 0xE2, 0xB2, 0x72, 0x36, + 0xA7, 0x94, 0x92, 0xB4, 0xD6, 0xCC, 0xE7, 0xCD, 0x30, 0x04, 0x63, 0x0C, + 0x6B, 0x6E, 0x86, 0x31, 0xAC, 0x77, 0xFB, 0x98, 0x98, 0xB1, 0x25, 0xCB, + 0x81, 0x25, 0x1C, 0x63, 0x52, 0x4A, 0x65, 0xF2, 0x63, 0x88, 0x29, 0x67, + 0xCB, 0x24, 0x34, 0x29, 0x79, 0x14, 0x2D, 0x24, 0x98, 0x63, 0xCD, 0xD5, + 0x27, 0x95, 0x8C, 0x02, 0x72, 0x4A, 0x4D, 0xED, 0x66, 0x4D, 0xBD, 0xEB, + 0x06, 0x9A, 0x70, 0x5C, 0xA1, 0x95, 0xEE, 0xFA, 0x21, 0xA6, 0x78, 0x7E, + 0x7A, 0xC2, 0x05, 0x28, 0x17, 0x9E, 0x7A, 0xE1, 0x70, 0xCE, 0x89, 0xC3, + 0x5A, 0x87, 0xB8, 0xAE, 0x65, 0x21, 0xB4, 0x92, 0xBC, 0x06, 0xDE, 0x75, + 0xBD, 0x20, 0x06, 0x7A, 0x33, 0x5F, 0x67, 0x42, 0x08, 0xA3, 0x35, 0xBB, + 0x7A, 0xB0, 0x86, 0xC5, 0x28, 0xD5, 0x8F, 0xA3, 0xD5, 0x9A, 0x05, 0xEA, + 0x88, 0xC0, 0x26, 0x30, 0x4A, 0xC9, 0x10, 0xB9, 0x92, 0x4A, 0x44, 0x90, + 0x12, 0xF8, 0x7A, 0x02, 0x14, 0x95, 0xB3, 0xF3, 0x83, 0x32, 0xC6, 0x5A, + 0x53, 0x57, 0xEE, 0xF9, 0xE5, 0xA9, 0x44, 0x59, 0x4A, 0x66, 0x12, 0x69, + 0xDF, 0x8F, 0xD6, 0xE8, 0xB3, 0xD3, 0x45, 0x3B, 0xAB, 0x2A, 0x67, 0x8D, + 0xD1, 0xDC, 0xFA, 0x3D, 0xBD, 0xCA, 0xA7, 0xB2, 0x8B, 0x12, 0x04, 0x80, + 0x83, 0x18, 0x91, 0xB5, 0x7B, 0x29, 0x67, 0xE2, 0x89, 0x42, 0x50, 0x8A, + 0x99, 0x6B, 0x8A, 0x10, 0x22, 0xE5, 0x2C, 0x00, 0x94, 0x91, 0x25, 0x89, + 0x14, 0x79, 0xF5, 0x26, 0xAE, 0xEF, 0x56, 0xF7, 0x0F, 0x0F, 0xFD, 0x30, + 0xA8, 0xD9, 0x4C, 0x1B, 0x15, 0x53, 0x7E, 0x7B, 0x7D, 0xBF, 0xDB, 0xEF, + 0x43, 0x48, 0x29, 0xA5, 0x98, 0xF3, 0xBE, 0xEB, 0x9E, 0x9F, 0x9F, 0xD5, + 0xCE, 0x9D, 0x9C, 0x2E, 0xD6, 0x9B, 0xDD, 0xFD, 0x6A, 0x95, 0x73, 0xD1, + 0x4A, 0x02, 0xC8, 0x22, 0xC4, 0xAE, 0x1F, 0x40, 0x88, 0xD1, 0x47, 0x04, + 0x28, 0x0F, 0x0F, 0x5A, 0x6B, 0x25, 0xA5, 0xD6, 0xAA, 0xAE, 0xAB, 0xB3, + 0x93, 0x13, 0x10, 0x42, 0x4A, 0xEC, 0x86, 0xF1, 0xED, 0xF5, 0xAE, 0xAA, + 0xDC, 0xE9, 0xC9, 0xF2, 0xF6, 0x6E, 0xF5, 0xBF, 0xFC, 0x6F, 0xFF, 0xF6, + 0xBF, 0xFD, 0x97, 0x7F, 0x61, 0xB4, 0xDA, 0xED, 0xFB, 0xAE, 0xEB, 0x96, + 0xF3, 0xF9, 0x7C, 0xD6, 0x0E, 0xC3, 0x40, 0x44, 0x5A, 0xEB, 0xAA, 0x72, + 0xD6, 0xD9, 0x71, 0x18, 0xF9, 0x36, 0x15, 0x44, 0x25, 0xC6, 0x82, 0x28, + 0x48, 0x96, 0xCC, 0x58, 0xB5, 0x14, 0x42, 0x00, 0x51, 0x8C, 0x89, 0xE4, + 0xA4, 0x0F, 0x2B, 0xA5, 0x94, 0xCC, 0xE2, 0x65, 0x22, 0x41, 0x53, 0x11, + 0x10, 0x44, 0x04, 0xA2, 0x08, 0x22, 0x12, 0x2C, 0x6B, 0xCD, 0x45, 0x49, + 0xC5, 0x79, 0x74, 0x6D, 0xED, 0x2A, 0x6B, 0x89, 0x28, 0x95, 0x3C, 0x86, + 0xC0, 0x39, 0x7E, 0xA5, 0x14, 0xCE, 0x15, 0x6F, 0x67, 0x4D, 0xE5, 0x6C, + 0xDF, 0x0D, 0xC6, 0x68, 0xEB, 0xCC, 0x76, 0xBB, 0x2D, 0x85, 0x62, 0x48, + 0xDE, 0xFB, 0xED, 0x76, 0xF7, 0xF6, 0xDD, 0xAD, 0x00, 0x11, 0x63, 0x26, + 0x12, 0x3E, 0x84, 0x98, 0xD3, 0xCB, 0xE7, 0xCF, 0x5E, 0xBF, 0x79, 0xCB, + 0xAD, 0xB4, 0x0F, 0xA1, 0xA9, 0xDD, 0xC9, 0x62, 0x7E, 0xB2, 0x9C, 0x31, + 0xF7, 0x98, 0x1D, 0xAB, 0x44, 0x81, 0x23, 0x80, 0xCE, 0x97, 0x1C, 0x33, + 0x0A, 0x79, 0x60, 0x9D, 0xDA, 0xB3, 0xA3, 0x58, 0xEA, 0xB1, 0x11, 0x2B, + 0xBC, 0x16, 0x78, 0x5A, 0x4D, 0x8E, 0x05, 0x05, 0x11, 0x15, 0xF2, 0x26, + 0x91, 0x8D, 0xBA, 0xBE, 0x2A, 0xAB, 0x14, 0x05, 0x0E, 0x6D, 0x19, 0x3D, + 0x79, 0x00, 0x16, 0x24, 0x30, 0x8C, 0x58, 0xBE, 0x4A, 0x8B, 0x65, 0xA2, + 0x82, 0x10, 0x8F, 0x19, 0xAC, 0x5C, 0x60, 0x8E, 0xF5, 0xEB, 0x49, 0x35, + 0x14, 0x4A, 0x49, 0x29, 0x70, 0xEA, 0xDF, 0x0A, 0x89, 0x42, 0x7C, 0x92, + 0x70, 0x97, 0x25, 0xB4, 0x52, 0x6F, 0xAE, 0x6E, 0x4B, 0xA1, 0x4F, 0x3F, + 0xBF, 0xBE, 0x7B, 0xD8, 0xAC, 0xB7, 0xDD, 0xF7, 0xBE, 0xF5, 0x32, 0xA4, + 0xE4, 0x8C, 0x9A, 0xB5, 0xB5, 0x56, 0x92, 0x61, 0x0E, 0xE7, 0xCC, 0x71, + 0x0F, 0x4A, 0x44, 0x52, 0x62, 0xD7, 0x8F, 0xEB, 0x5D, 0xBF, 0x58, 0xCC, + 0x2A, 0x67, 0x2F, 0xCE, 0x16, 0xA7, 0x27, 0x73, 0x40, 0xB4, 0xD6, 0xEC, + 0x76, 0xDD, 0xEF, 0x3F, 0xFB, 0xB2, 0x1F, 0xC6, 0xBA, 0xA9, 0xAC, 0x33, + 0x85, 0x4A, 0x55, 0xBB, 0x97, 0x2F, 0x2E, 0xBE, 0xE5, 0x4C, 0x53, 0x3B, + 0x6B, 0xCD, 0x6F, 0x3E, 0x79, 0xFD, 0x93, 0x5F, 0x7C, 0xB2, 0xDB, 0xF5, + 0x9C, 0xAE, 0x38, 0x6F, 0xDB, 0x92, 0xF3, 0x6E, 0xDF, 0x57, 0x95, 0x93, + 0x5A, 0x6F, 0xD6, 0x9B, 0xCD, 0xC3, 0x26, 0xF9, 0xC8, 0x73, 0x59, 0xCE, + 0xE9, 0xEE, 0x61, 0xD5, 0xED, 0xF6, 0xF3, 0xB6, 0xD9, 0x6D, 0xF7, 0xDA, + 0x18, 0x00, 0xD8, 0x6E, 0x77, 0xAB, 0xD5, 0x7A, 0x75, 0xB8, 0x94, 0x67, + 0x6D, 0x0B, 0x00, 0x95, 0xB3, 0x2F, 0x5E, 0x5C, 0x9C, 0xB4, 0xEE, 0x1B, + 0x1F, 0xBC, 0xFF, 0xC9, 0x6F, 0x7E, 0x45, 0xA5, 0xFC, 0xE3, 0x7F, 0xFA, + 0x4F, 0x86, 0xC1, 0x0B, 0x00, 0xA9, 0x64, 0x4A, 0x29, 0xC6, 0xFC, 0xB0, + 0xDA, 0x6C, 0x77, 0x9D, 0x73, 0x8E, 0xBD, 0xC8, 0x38, 0xC1, 0x60, 0xB3, + 0xDE, 0xDD, 0x3D, 0xAC, 0x56, 0xDB, 0xFD, 0xE8, 0x43, 0x21, 0x91, 0x72, + 0x76, 0xC6, 0x20, 0x80, 0xF7, 0x61, 0xF0, 0x81, 0x49, 0x28, 0x29, 0xC5, + 0xDA, 0xD9, 0x94, 0x59, 0xF5, 0x9D, 0x8D, 0x92, 0xA3, 0x0F, 0xCE, 0x36, + 0x6C, 0x83, 0x63, 0xB4, 0x7A, 0xF1, 0xFC, 0xA2, 0xAE, 0xAA, 0x77, 0x37, + 0x77, 0x3F, 0xF8, 0xE8, 0xC3, 0x67, 0x17, 0x67, 0x44, 0x24, 0xA5, 0x0A, + 0x21, 0xA6, 0x92, 0xBF, 0x78, 0xF5, 0xE5, 0xCD, 0xDD, 0xC3, 0x30, 0xF8, + 0x03, 0x17, 0x89, 0xD8, 0x5E, 0x5C, 0x6B, 0xE5, 0x43, 0x36, 0x4A, 0x93, + 0x10, 0x29, 0xA5, 0x18, 0x23, 0x4A, 0xDC, 0x0D, 0x5E, 0xCB, 0x1C, 0x53, + 0x9C, 0x35, 0x95, 0x92, 0xE8, 0x43, 0x1C, 0x7D, 0xA8, 0xAC, 0x66, 0x96, + 0x90, 0xD6, 0x2A, 0x95, 0x52, 0x59, 0x23, 0x51, 0x76, 0xFD, 0x20, 0xB8, + 0xB2, 0x00, 0x18, 0x2D, 0xA5, 0xC4, 0x61, 0xCC, 0x56, 0x6B, 0x44, 0xC8, + 0x53, 0x64, 0x74, 0x40, 0xAB, 0x2A, 0x6B, 0x06, 0x9F, 0x4A, 0x21, 0x66, + 0x96, 0xE7, 0x52, 0x4E, 0x16, 0xF3, 0x59, 0x53, 0x1B, 0xA3, 0x25, 0x42, + 0x4C, 0xA9, 0x72, 0x26, 0xC6, 0x34, 0x9B, 0x35, 0xEC, 0xEC, 0x62, 0x8D, + 0xE6, 0xB9, 0x63, 0x42, 0x55, 0x1E, 0xF9, 0x04, 0xD3, 0xD5, 0x0A, 0x00, + 0x50, 0xA6, 0xBD, 0x9B, 0x36, 0x8A, 0x23, 0x9D, 0xA4, 0x04, 0x4C, 0x98, + 0x4B, 0xE2, 0x84, 0x4A, 0x3A, 0xAC, 0xB7, 0x10, 0x10, 0x14, 0x11, 0x89, + 0x10, 0xF3, 0x6A, 0xB3, 0x59, 0x6F, 0xF6, 0x44, 0xC4, 0xA8, 0xE2, 0x6E, + 0xDF, 0xA5, 0x98, 0x86, 0x61, 0xA8, 0x9C, 0x65, 0x4D, 0xD4, 0x69, 0xDB, + 0xEC, 0xF6, 0xDD, 0xC9, 0xC9, 0xFC, 0x87, 0x7F, 0xF8, 0xFD, 0x61, 0x18, + 0xFB, 0x7E, 0xB0, 0xD6, 0x18, 0xAD, 0xB7, 0xFB, 0x2E, 0xA7, 0x88, 0x92, + 0x13, 0xAD, 0xF2, 0x18, 0x82, 0xD3, 0x7A, 0xD6, 0x54, 0xCE, 0xB9, 0xAE, + 0x1F, 0x42, 0xCE, 0x0F, 0x9B, 0xED, 0xAB, 0x2F, 0xDF, 0x21, 0xC0, 0x1F, + 0xFF, 0xD1, 0xF7, 0x2F, 0x2F, 0xCF, 0xFE, 0xDD, 0x5F, 0xFE, 0x68, 0xB3, + 0xDD, 0x8D, 0x63, 0xB0, 0xCE, 0xDC, 0xDC, 0x3D, 0xFC, 0xE5, 0x5F, 0xFD, + 0xCD, 0x3F, 0xFD, 0x47, 0x7F, 0x2A, 0x88, 0x4E, 0x96, 0x8B, 0xFB, 0x87, + 0xD5, 0xCB, 0xE7, 0x97, 0x23, 0x0B, 0x33, 0x72, 0xC9, 0xA5, 0xD4, 0xB5, + 0x93, 0x12, 0x05, 0x09, 0xA9, 0xB0, 0xEF, 0x26, 0xC1, 0x06, 0x6F, 0x25, + 0xE4, 0xC4, 0x14, 0x11, 0x46, 0x2B, 0xDE, 0x03, 0x3E, 0xC1, 0x64, 0x48, + 0x10, 0x1B, 0xAB, 0x10, 0x6F, 0x75, 0x41, 0x4C, 0xB4, 0x55, 0x85, 0x00, + 0x00, 0xD2, 0xEA, 0xCA, 0x6A, 0xE6, 0x55, 0x12, 0x51, 0x8A, 0x25, 0xA4, + 0xC4, 0xEC, 0x04, 0x89, 0xC8, 0x86, 0x9A, 0x39, 0xE5, 0x94, 0xD2, 0xF9, + 0xF9, 0x89, 0xB1, 0xBA, 0xE4, 0x62, 0x34, 0xF3, 0xB4, 0x19, 0x54, 0xC9, + 0xEC, 0xFC, 0xF3, 0xEB, 0x8F, 0x3F, 0x8D, 0x31, 0xA6, 0xC2, 0xA2, 0x72, + 0x31, 0x8C, 0xBE, 0xAE, 0xDD, 0xEB, 0x2F, 0xDF, 0xEE, 0xBB, 0xBE, 0xAE, + 0x5D, 0x65, 0xED, 0xD9, 0xC9, 0xA2, 0xA9, 0x9D, 0x35, 0xFA, 0xE8, 0x40, + 0x73, 0xDC, 0xF4, 0x89, 0x47, 0x83, 0xB3, 0xC7, 0x71, 0xEA, 0x38, 0x90, + 0x1D, 0xFB, 0xA6, 0xA7, 0x44, 0xFC, 0xC3, 0xD7, 0x53, 0xF0, 0x89, 0x51, + 0xB1, 0xE9, 0x13, 0xE7, 0x4C, 0x6D, 0x22, 0x2A, 0x70, 0xE0, 0x77, 0x1D, + 0x1E, 0x8A, 0x41, 0x2D, 0x38, 0x08, 0x11, 0x88, 0x0E, 0x4A, 0x6E, 0x6E, + 0xA2, 0x00, 0x8E, 0x3A, 0xAA, 0xA7, 0x4F, 0x44, 0x47, 0x1A, 0x0A, 0x62, + 0x39, 0xC4, 0x33, 0x72, 0x7F, 0x87, 0xF8, 0x94, 0x68, 0x91, 0x79, 0x76, + 0x9E, 0x6C, 0x1B, 0xA5, 0x10, 0x85, 0x30, 0xE5, 0x2C, 0xE5, 0x54, 0xA1, + 0x57, 0xEB, 0xDD, 0x2F, 0x7F, 0xFB, 0x4A, 0xA1, 0x64, 0xFD, 0xE0, 0xE0, + 0xE3, 0xD5, 0xF5, 0xCA, 0x18, 0xA3, 0x4F, 0x66, 0x77, 0x0F, 0x3B, 0x63, + 0x14, 0xDB, 0x2B, 0x02, 0x4A, 0x22, 0xDE, 0x31, 0x01, 0x09, 0xB2, 0x46, + 0x6D, 0xB6, 0x7D, 0x3F, 0x78, 0x6B, 0x8D, 0x44, 0xBC, 0xBF, 0x5F, 0x3B, + 0x6B, 0xAC, 0x35, 0x7E, 0x1C, 0xAB, 0xCA, 0xFD, 0xE9, 0x1F, 0x7F, 0x34, + 0xFA, 0x50, 0xA8, 0xEC, 0x76, 0xBD, 0x10, 0xA2, 0x6D, 0xEA, 0x17, 0xCF, + 0xCF, 0x53, 0x4E, 0xEF, 0x6E, 0x1E, 0x3E, 0x7B, 0x75, 0xFD, 0xEB, 0x4F, + 0x5E, 0xAD, 0x37, 0x5D, 0xF0, 0xFE, 0xE5, 0xB3, 0x0B, 0x3E, 0x97, 0x88, + 0xA8, 0xAE, 0x5C, 0x88, 0xE9, 0xE1, 0x7E, 0xCD, 0xE7, 0x7C, 0x5D, 0x39, + 0xA5, 0x54, 0x5D, 0xDB, 0xFB, 0x2F, 0xEF, 0xFD, 0x38, 0x5E, 0x9C, 0x9F, + 0x56, 0x95, 0xAB, 0xAB, 0xAA, 0xA9, 0x2B, 0x1F, 0xC2, 0x30, 0x0C, 0xBB, + 0xED, 0xAE, 0x6D, 0xEA, 0x6F, 0xBE, 0xFF, 0x72, 0xD6, 0x36, 0xCB, 0xE5, + 0x4C, 0x08, 0x31, 0x9F, 0x55, 0x6D, 0xD3, 0x7C, 0xF1, 0xC5, 0x17, 0xBF, + 0xFD, 0xF9, 0x4F, 0xAA, 0xB6, 0xFE, 0xF1, 0x8F, 0x7E, 0xF2, 0x0F, 0xFF, + 0xFC, 0x2F, 0xB6, 0x63, 0x8F, 0x88, 0xDE, 0x07, 0x1F, 0xE2, 0xFD, 0xC3, + 0xA6, 0xEB, 0xC7, 0xD9, 0xAC, 0xA9, 0x9B, 0xBA, 0xEF, 0x06, 0x36, 0x08, + 0xCC, 0x39, 0xDF, 0xAF, 0x36, 0xD7, 0xB7, 0x0F, 0x25, 0x97, 0x61, 0x0C, + 0x8B, 0x79, 0x6B, 0x75, 0xE3, 0x43, 0x00, 0x9C, 0xDA, 0x28, 0x44, 0x92, + 0x08, 0xB5, 0xAB, 0x49, 0x88, 0x98, 0x92, 0x96, 0x32, 0xA5, 0x68, 0x94, + 0x14, 0x40, 0x21, 0x44, 0x67, 0x74, 0xD3, 0x34, 0x82, 0xE8, 0xF9, 0xC5, + 0xA9, 0x20, 0x11, 0x17, 0xB3, 0x45, 0x5B, 0xBF, 0x7B, 0x77, 0xF3, 0xEA, + 0xF5, 0xD5, 0xD9, 0xD9, 0xA9, 0x73, 0x56, 0x2A, 0x35, 0x9B, 0xB5, 0x75, + 0x5D, 0x33, 0xE0, 0xC5, 0x44, 0x9E, 0x61, 0x1C, 0x53, 0x9E, 0x3E, 0x18, + 0x51, 0x88, 0xDD, 0x7E, 0x78, 0xA9, 0x6A, 0x8C, 0x61, 0xBB, 0x47, 0xA3, + 0xD5, 0xBE, 0xEB, 0x11, 0xD1, 0x68, 0x1D, 0x62, 0xAA, 0x9C, 0x61, 0x04, + 0x23, 0xA5, 0x3C, 0x8A, 0x64, 0xB5, 0xD0, 0x46, 0x39, 0x63, 0xA4, 0x52, + 0x31, 0xA5, 0x83, 0xE3, 0x2B, 0x0A, 0x41, 0x2C, 0x7F, 0x01, 0x00, 0x2A, + 0x59, 0x49, 0x95, 0xA9, 0x78, 0x1F, 0xF8, 0xB0, 0x3D, 0x88, 0xC6, 0x4B, + 0x08, 0xC1, 0x39, 0xD3, 0xB4, 0x35, 0x51, 0x19, 0x87, 0x00, 0x08, 0xCB, + 0xC5, 0xAC, 0x76, 0x56, 0x1B, 0xC5, 0xA1, 0x33, 0xC7, 0x7B, 0xE0, 0x38, + 0x05, 0x3C, 0xAE, 0x99, 0x88, 0xB2, 0x98, 0xF2, 0x3D, 0x01, 0x84, 0x0E, + 0x29, 0xE7, 0xCC, 0x69, 0x0B, 0xC6, 0x18, 0x22, 0xD1, 0x75, 0x43, 0x3E, + 0x24, 0x01, 0x4A, 0x29, 0x73, 0x4E, 0x82, 0x28, 0xC5, 0x94, 0x0B, 0x21, + 0x42, 0xCE, 0x64, 0xAD, 0x45, 0x80, 0xD5, 0x6A, 0x53, 0xD7, 0x55, 0xD3, + 0xD4, 0xC3, 0x30, 0xCE, 0xDA, 0x06, 0x25, 0x32, 0x34, 0xFE, 0xB0, 0xDA, + 0xFE, 0xF8, 0x27, 0xBF, 0x5C, 0x2E, 0x67, 0xB3, 0xB6, 0x8E, 0x29, 0x85, + 0x98, 0xA4, 0x52, 0x5D, 0xBF, 0x13, 0x00, 0x54, 0x0A, 0x9B, 0xD2, 0x54, + 0xCE, 0x59, 0x63, 0x88, 0x28, 0xA6, 0xD4, 0x0D, 0xA3, 0x9A, 0xD0, 0x52, + 0xFC, 0xC9, 0xCF, 0x3F, 0x3E, 0x59, 0xCC, 0x25, 0xB2, 0xED, 0x4F, 0xE1, + 0x69, 0xF4, 0xE7, 0xBF, 0xFE, 0xE4, 0xF2, 0xE2, 0xE4, 0x9F, 0xFD, 0xE3, + 0x3F, 0x0B, 0x21, 0x29, 0x94, 0xEB, 0xD5, 0xE6, 0xE4, 0x64, 0xB1, 0xDF, + 0xF7, 0x88, 0xC0, 0x9B, 0xA0, 0xA6, 0xA9, 0x69, 0xE2, 0x82, 0x61, 0xDF, + 0x0D, 0x4A, 0xA1, 0xB3, 0x1A, 0x51, 0x72, 0xE7, 0x72, 0x9C, 0x92, 0x8E, + 0x37, 0x37, 0x22, 0xB2, 0xDF, 0x30, 0x63, 0x20, 0x93, 0x1F, 0x11, 0xC0, + 0xF1, 0x1D, 0x2B, 0x85, 0x24, 0x62, 0x37, 0x8C, 0x39, 0x97, 0xB6, 0xA9, + 0xEF, 0x1E, 0xD6, 0x8B, 0x59, 0x2B, 0x25, 0x90, 0x28, 0x29, 0x17, 0x5E, + 0x4D, 0x28, 0x89, 0xCA, 0x18, 0x51, 0x48, 0x22, 0xC6, 0x90, 0xBA, 0x7D, + 0x97, 0x4A, 0x71, 0xCE, 0x71, 0x50, 0x2E, 0x08, 0xA1, 0xA5, 0xFC, 0xF4, + 0xB3, 0x37, 0x21, 0x04, 0x6B, 0x4D, 0xEA, 0x7D, 0xCE, 0x87, 0x48, 0x53, + 0x94, 0x9B, 0xCD, 0x4E, 0x00, 0x94, 0x22, 0x94, 0x9C, 0x46, 0x7E, 0x6E, + 0x9C, 0x8F, 0xCE, 0x62, 0xC7, 0xE3, 0xE7, 0x29, 0x86, 0x75, 0x6C, 0xBE, + 0x9E, 0xCE, 0x6B, 0x5F, 0xED, 0x8F, 0x8E, 0x2F, 0x90, 0x4B, 0x8C, 0x20, + 0x22, 0x1E, 0x35, 0x27, 0xF0, 0x8B, 0x48, 0x4C, 0xF3, 0xF5, 0x41, 0x9E, + 0xC7, 0x3F, 0xF5, 0x24, 0x34, 0xE4, 0x29, 0xAA, 0x75, 0x68, 0xD9, 0x88, + 0xBE, 0x82, 0xC1, 0x3D, 0x3E, 0xDD, 0xD3, 0x21, 0x0F, 0x88, 0x00, 0xF0, + 0x68, 0xA8, 0xC1, 0xA8, 0x97, 0x04, 0x28, 0x24, 0x38, 0xE8, 0xE3, 0xD1, + 0x56, 0x88, 0x4B, 0xA1, 0x96, 0xAC, 0xBC, 0x81, 0x10, 0xD2, 0xC3, 0x6A, + 0xF7, 0xE6, 0xEA, 0x5E, 0x4B, 0x35, 0x9F, 0x35, 0xB8, 0xEF, 0x4F, 0x4F, + 0x66, 0x21, 0x24, 0xA2, 0x72, 0xF7, 0xB0, 0x4D, 0xB9, 0x48, 0x04, 0xE7, + 0xCC, 0xBC, 0xAD, 0x7D, 0x88, 0x0F, 0xEB, 0xBD, 0x56, 0x32, 0x6E, 0x7A, + 0x67, 0xB5, 0x31, 0x2A, 0x67, 0x0A, 0xB1, 0xD4, 0x95, 0x5B, 0xAD, 0x77, + 0xE3, 0xE0, 0x15, 0xE2, 0x66, 0xF7, 0x39, 0x9F, 0x5D, 0xEF, 0xBF, 0x77, + 0x79, 0x72, 0x32, 0xD7, 0x46, 0xD7, 0xC6, 0x35, 0x75, 0x35, 0x8E, 0xA1, + 0xAA, 0xEC, 0x6A, 0xBD, 0xFD, 0xE5, 0x6F, 0x3F, 0xFF, 0xCD, 0xA7, 0x5F, + 0x0E, 0x63, 0xD8, 0xEE, 0xFA, 0x10, 0x62, 0xCA, 0xE9, 0xED, 0xCD, 0x3D, + 0x9B, 0x99, 0xCC, 0x66, 0xCD, 0xD9, 0xE9, 0x62, 0xFB, 0xF6, 0x96, 0x88, + 0x04, 0x08, 0x6B, 0xB5, 0x52, 0xF2, 0x3B, 0xDF, 0xFA, 0x46, 0xF0, 0x51, + 0xC2, 0x94, 0x7E, 0x14, 0x62, 0x5C, 0xCC, 0xEA, 0xF7, 0x5E, 0x5C, 0x74, + 0xDD, 0x90, 0x4B, 0x39, 0x5D, 0x7E, 0x7F, 0x31, 0x6F, 0x49, 0x90, 0xD6, + 0xCA, 0x59, 0x5B, 0xA8, 0x04, 0x1F, 0x6F, 0x6F, 0x57, 0x9B, 0xDB, 0xEB, + 0x5F, 0xFF, 0xF4, 0x47, 0x19, 0xB0, 0x0B, 0xF9, 0xED, 0xD5, 0x5B, 0xD7, + 0x34, 0x39, 0xE6, 0x7E, 0x1C, 0xBB, 0x7E, 0x64, 0xFF, 0x75, 0xA9, 0xA4, + 0xF7, 0x9E, 0x1F, 0xB0, 0xEB, 0x06, 0x22, 0x41, 0x02, 0x18, 0xF1, 0x31, + 0x5A, 0x3A, 0xAB, 0x73, 0xCC, 0x07, 0x8C, 0x9B, 0xA9, 0xD2, 0x85, 0x08, + 0x74, 0xA1, 0x92, 0xA3, 0x20, 0x62, 0xB4, 0xDE, 0x1A, 0x59, 0xDB, 0x39, + 0x3B, 0x0E, 0xEF, 0xBB, 0xCE, 0x19, 0xF3, 0xCB, 0x5F, 0xFD, 0x2E, 0xA6, + 0x5C, 0x39, 0xFB, 0xFA, 0xCB, 0xB7, 0x00, 0xE0, 0xAC, 0xDB, 0xEF, 0xBB, + 0xDD, 0x6E, 0xE7, 0x63, 0xAA, 0x2A, 0x27, 0x95, 0x1A, 0xC7, 0x91, 0x0A, + 0x59, 0x67, 0xEB, 0xDA, 0x5A, 0xA3, 0x52, 0x8A, 0x4A, 0x4A, 0x33, 0xAA, + 0x18, 0x53, 0x8A, 0x19, 0x62, 0x04, 0x67, 0x95, 0x94, 0x42, 0x50, 0x4C, + 0x89, 0xD9, 0xAD, 0x12, 0x91, 0x33, 0x07, 0x72, 0xCE, 0x39, 0x17, 0x63, + 0x14, 0x9F, 0x7A, 0x87, 0x6F, 0x90, 0xB3, 0xB6, 0x7E, 0xEF, 0xC5, 0xE5, + 0xFD, 0x6A, 0x73, 0x73, 0xF7, 0x40, 0x44, 0xAC, 0xD3, 0x67, 0xFE, 0x0E, + 0x00, 0x68, 0xDE, 0xC1, 0x0D, 0xDE, 0x18, 0x33, 0x6B, 0x2A, 0x1E, 0x12, + 0x99, 0x8F, 0x00, 0x00, 0x20, 0x00, 0x49, 0x44, 0x41, 0x54, 0x67, 0xCD, + 0xAC, 0xAD, 0x9C, 0xB3, 0x6D, 0x5B, 0x3B, 0x67, 0xEB, 0xCA, 0x09, 0x12, + 0x46, 0x6B, 0xA5, 0x34, 0x0A, 0x51, 0x3B, 0x6B, 0x8C, 0x36, 0x66, 0x92, + 0x67, 0xB1, 0x65, 0x2E, 0x4B, 0xFE, 0x85, 0x60, 0xA4, 0xE8, 0x78, 0x3F, + 0x08, 0xA2, 0x22, 0x0E, 0xA8, 0xD9, 0xE4, 0x93, 0x2D, 0x0A, 0x22, 0xB2, + 0x5B, 0xE4, 0xD0, 0x7B, 0x29, 0xA7, 0x35, 0x99, 0x52, 0xAA, 0x14, 0x24, + 0x28, 0x4D, 0xEB, 0xB4, 0xD1, 0xBB, 0x7D, 0xBF, 0xDE, 0xEE, 0xBB, 0xBE, + 0x0F, 0x21, 0x34, 0x55, 0x85, 0x80, 0xE3, 0xE8, 0xEB, 0xBA, 0x66, 0x7F, + 0xCA, 0xDD, 0xBE, 0x4B, 0x29, 0x87, 0x1C, 0x77, 0xFB, 0xFE, 0xE6, 0xF6, + 0x9E, 0x84, 0x90, 0x88, 0xBB, 0x7E, 0x28, 0x42, 0x34, 0x75, 0x55, 0xA6, + 0xF6, 0x10, 0xAC, 0xD1, 0x39, 0xA5, 0x87, 0xA1, 0x17, 0x02, 0xA4, 0x92, + 0xB3, 0xB6, 0x96, 0x02, 0x73, 0x2E, 0x4C, 0x56, 0xBA, 0x5F, 0xAD, 0x9D, + 0xB5, 0x0A, 0x55, 0x4C, 0x51, 0x02, 0xB0, 0x7F, 0xF7, 0x5F, 0xFE, 0xD5, + 0xDF, 0x7C, 0xE3, 0xF9, 0xE5, 0x77, 0xBF, 0xF5, 0x5E, 0xD3, 0x54, 0x44, + 0xB4, 0xDF, 0xF7, 0x80, 0xC2, 0x58, 0xA5, 0xB5, 0x3D, 0xBA, 0x1B, 0x08, + 0x21, 0xDA, 0xB6, 0xE1, 0xD5, 0x10, 0xDB, 0x2B, 0x1E, 0x41, 0x6B, 0xFE, + 0xBF, 0x4F, 0x5D, 0x6E, 0x60, 0x62, 0xC9, 0x13, 0x15, 0x21, 0xCA, 0x94, + 0x29, 0xA7, 0x8D, 0x9A, 0xDA, 0x1C, 0xC2, 0x2C, 0xE8, 0xFE, 0x61, 0x2D, + 0x04, 0xE4, 0x5C, 0x6E, 0x6F, 0xEF, 0xE7, 0xB3, 0x1A, 0x40, 0x65, 0x22, + 0x44, 0xE1, 0x8C, 0x01, 0x01, 0x21, 0x46, 0x29, 0x51, 0x00, 0x6C, 0x76, + 0x7B, 0x26, 0x36, 0x9F, 0x2E, 0x17, 0x4A, 0x29, 0x7E, 0x02, 0x25, 0xE5, + 0xCD, 0xDD, 0xC3, 0x9B, 0x37, 0x57, 0x31, 0x17, 0x56, 0x2C, 0x8D, 0xA3, + 0x1F, 0x83, 0x3F, 0x3F, 0x3D, 0xC9, 0x25, 0x87, 0x98, 0x10, 0xA1, 0x94, + 0x34, 0x8E, 0x5E, 0x29, 0xD5, 0x54, 0x6E, 0x36, 0xAB, 0x59, 0x0C, 0x87, + 0x07, 0x1C, 0x9D, 0xE8, 0x91, 0x75, 0x70, 0xC4, 0xA1, 0x0E, 0xE6, 0xA6, + 0x47, 0xC2, 0xC4, 0x57, 0xBE, 0xB8, 0xBC, 0x1C, 0x3B, 0x26, 0x3A, 0x18, + 0x69, 0xB0, 0xA1, 0x10, 0xC5, 0x22, 0x40, 0x1C, 0x58, 0x17, 0xE2, 0xE8, + 0x28, 0x4D, 0x44, 0xEC, 0x1A, 0x78, 0xA4, 0xFD, 0xE7, 0x72, 0x5C, 0x68, + 0x1E, 0x9F, 0x62, 0x2A, 0x42, 0xF4, 0xE4, 0xEB, 0x88, 0x57, 0x88, 0xAF, + 0x7E, 0x13, 0xE2, 0x93, 0xA1, 0x52, 0x08, 0x71, 0x30, 0x24, 0x54, 0xC7, + 0xC2, 0x0C, 0x20, 0x94, 0x52, 0xC3, 0x18, 0xD7, 0x9B, 0xFD, 0xBE, 0x1B, + 0x47, 0x1F, 0xAF, 0xEF, 0xD6, 0xCB, 0x79, 0x7B, 0x7E, 0xBA, 0xE8, 0xFA, + 0x71, 0xD6, 0x36, 0x0F, 0xEB, 0xAD, 0x0F, 0xE1, 0x64, 0x31, 0x3B, 0x5D, + 0xCE, 0x99, 0xBB, 0xA4, 0x95, 0xBE, 0x5F, 0xED, 0x78, 0x94, 0xD5, 0x4A, + 0x96, 0x52, 0xA8, 0xD0, 0x6E, 0xDF, 0x6B, 0xA5, 0xCE, 0xCF, 0x16, 0x12, + 0xE5, 0xDB, 0xEB, 0x7B, 0x29, 0x91, 0x31, 0x66, 0x21, 0xE8, 0xF9, 0xB3, + 0xF3, 0x31, 0xA4, 0x42, 0xA4, 0xA4, 0xDC, 0x6C, 0xF6, 0xF3, 0x79, 0x53, + 0x57, 0xEE, 0xD3, 0xCF, 0xBF, 0xFC, 0xEB, 0xBF, 0xF9, 0xCD, 0xCD, 0xFD, + 0x26, 0xA5, 0xE4, 0x43, 0xCC, 0x99, 0xFA, 0xBE, 0x97, 0x52, 0x92, 0xC5, + 0xBA, 0xB1, 0x4A, 0xC9, 0xBE, 0xEF, 0xC7, 0x61, 0x4C, 0x29, 0xF9, 0x10, + 0x2E, 0xCE, 0x4F, 0xDB, 0x97, 0x97, 0x8B, 0x59, 0xA3, 0x50, 0xEA, 0x53, + 0x7D, 0x72, 0xB2, 0xD8, 0xEE, 0xF6, 0x0F, 0x0F, 0x9B, 0x8B, 0xD3, 0xC5, + 0x87, 0xEF, 0xBF, 0x18, 0xBC, 0x3F, 0x5D, 0xCE, 0x10, 0x31, 0xA6, 0x54, + 0xA8, 0xB0, 0xE5, 0x5E, 0x4C, 0x69, 0xB5, 0xDA, 0xEE, 0x7A, 0xFF, 0xC9, + 0x2F, 0x7E, 0xFC, 0x6F, 0xFF, 0xCD, 0xFF, 0xDE, 0x85, 0x78, 0x7A, 0x76, + 0xB1, 0x98, 0x2F, 0x7E, 0xFB, 0xAB, 0x9F, 0x7F, 0xF8, 0xFD, 0x1F, 0xA6, + 0x9C, 0xFB, 0x7E, 0x2C, 0xA5, 0x9C, 0x9E, 0x2C, 0xEA, 0xCA, 0xED, 0xBA, + 0xDE, 0x8F, 0x51, 0x08, 0x31, 0x8E, 0x61, 0xBD, 0xD9, 0x4B, 0x29, 0x7D, + 0x8C, 0x21, 0x44, 0x29, 0x65, 0x6B, 0x26, 0x97, 0x28, 0x14, 0x10, 0x43, + 0x64, 0xB2, 0x18, 0xAF, 0x75, 0x4A, 0xC9, 0x3C, 0x0B, 0xD4, 0x95, 0x9D, + 0x37, 0x93, 0xF3, 0x79, 0xCA, 0x79, 0x18, 0xBD, 0x35, 0x06, 0x40, 0xF8, + 0x98, 0xDA, 0xA6, 0x8E, 0x29, 0x4A, 0xA5, 0x98, 0xC1, 0x1F, 0x53, 0x42, + 0x04, 0x14, 0x62, 0x1C, 0x47, 0x01, 0xC0, 0x04, 0xA9, 0xD2, 0xE5, 0xA1, + 0x13, 0x88, 0x00, 0x02, 0x12, 0x26, 0x41, 0x84, 0x12, 0x34, 0x48, 0x29, + 0x31, 0x28, 0x99, 0x52, 0x42, 0x04, 0x25, 0x71, 0xD1, 0x36, 0x31, 0x45, + 0x12, 0xDC, 0x99, 0xCA, 0x10, 0xA6, 0x6E, 0xC5, 0x59, 0x33, 0x0C, 0x41, + 0x22, 0xD6, 0x75, 0x35, 0x0C, 0xBE, 0xAE, 0x2B, 0x29, 0x65, 0x53, 0x57, + 0xEF, 0x3D, 0xBB, 0xDC, 0xED, 0xF6, 0xFD, 0x38, 0x0A, 0x00, 0x56, 0x20, + 0x02, 0x08, 0x89, 0x32, 0x0B, 0x31, 0x9B, 0x35, 0x39, 0x95, 0x93, 0xC5, + 0x6C, 0x39, 0x6F, 0xAB, 0xCA, 0x9E, 0x9F, 0x2C, 0x66, 0x6D, 0xDD, 0x36, + 0x55, 0xE5, 0x0C, 0x07, 0x3B, 0x18, 0x29, 0x9D, 0x35, 0xDA, 0x48, 0x6D, + 0x14, 0x00, 0x1E, 0xC8, 0xB6, 0xC4, 0x3B, 0xB8, 0xA3, 0x19, 0xF1, 0xA3, + 0x9E, 0xFF, 0x00, 0x31, 0x1C, 0x44, 0xB5, 0x42, 0x22, 0x88, 0x0C, 0x12, + 0x84, 0x40, 0x90, 0x52, 0x56, 0xB5, 0xED, 0x87, 0x91, 0x2F, 0x3E, 0x22, + 0x2A, 0x25, 0x73, 0x37, 0x57, 0xD7, 0x96, 0xF7, 0x65, 0x42, 0x88, 0x87, + 0xD5, 0x4A, 0x20, 0x8C, 0xDE, 0xF3, 0x65, 0xBA, 0xD9, 0xED, 0x77, 0xFB, + 0xCE, 0x8F, 0xDE, 0x58, 0x63, 0x95, 0x06, 0x21, 0x4A, 0x29, 0x31, 0xC5, + 0x3E, 0x97, 0x54, 0x0A, 0x02, 0x1A, 0xA5, 0xCF, 0x2F, 0xCF, 0x89, 0x88, + 0x4D, 0xA8, 0x42, 0x48, 0xA9, 0x94, 0x90, 0xB2, 0x02, 0xAC, 0xAA, 0x4A, + 0x10, 0x6D, 0xF7, 0x7B, 0x26, 0xC1, 0x00, 0x22, 0x47, 0x16, 0x4C, 0x8B, + 0x3F, 0xA3, 0xB4, 0x92, 0xA2, 0xD0, 0x5F, 0xFF, 0xF8, 0xE7, 0x97, 0x67, + 0x8B, 0xE5, 0xC9, 0x02, 0x40, 0x0C, 0xC3, 0x00, 0x00, 0xCC, 0x9F, 0xE0, + 0xF1, 0xF9, 0x48, 0xA9, 0x53, 0x4A, 0x95, 0xC3, 0xD7, 0xD7, 0xEE, 0x73, + 0xC4, 0xAF, 0x88, 0xDE, 0x11, 0x91, 0xF7, 0x9B, 0xFB, 0x7E, 0x9F, 0x4B, + 0x69, 0xAA, 0x6A, 0x18, 0x7D, 0x5D, 0x5B, 0xA5, 0x14, 0x47, 0x10, 0x3A, + 0xA6, 0x04, 0x96, 0xFC, 0xDE, 0xCB, 0x67, 0xDC, 0x3F, 0xE6, 0x4C, 0x9C, + 0x59, 0x51, 0x57, 0xAE, 0xAA, 0x0C, 0xDF, 0x95, 0xCE, 0x59, 0xA3, 0xF5, + 0xF4, 0xC6, 0xC2, 0xA4, 0x7C, 0x40, 0x29, 0xB7, 0xBB, 0xDD, 0x6A, 0xB3, + 0x8B, 0x29, 0xFB, 0x10, 0x01, 0x71, 0xDE, 0x36, 0xE7, 0x66, 0x31, 0x78, + 0xDF, 0x34, 0x35, 0x22, 0x0E, 0xC3, 0x58, 0x3B, 0xAB, 0x94, 0x6C, 0x9B, + 0x4A, 0x2B, 0x95, 0x33, 0xA5, 0x18, 0x89, 0xAB, 0xED, 0x57, 0xB0, 0xEC, + 0xC7, 0x76, 0x2C, 0x67, 0xAE, 0x2F, 0xC4, 0xED, 0xE7, 0xC1, 0xB0, 0x48, + 0x1C, 0x7A, 0x28, 0xE0, 0x8F, 0xFB, 0xF8, 0x7A, 0xF9, 0x4D, 0x48, 0x93, + 0xE3, 0x92, 0x98, 0x22, 0x07, 0x91, 0x84, 0x10, 0x39, 0x65, 0x6E, 0xC9, + 0x88, 0x9D, 0x85, 0x04, 0x1D, 0x1D, 0x19, 0xC5, 0x34, 0x63, 0x4C, 0xDB, + 0x2D, 0xFE, 0x7A, 0xC2, 0xFB, 0x9A, 0x06, 0xDE, 0xE3, 0xA1, 0x28, 0x60, + 0x72, 0x9A, 0xA0, 0x03, 0xD3, 0x1E, 0x01, 0x8E, 0xCC, 0x8B, 0x89, 0x3E, + 0x0B, 0x04, 0x00, 0xEA, 0xF8, 0x8F, 0x4A, 0xE1, 0xEB, 0xAB, 0xBB, 0x57, + 0x5F, 0xDE, 0x31, 0xAF, 0xCF, 0x87, 0x88, 0x08, 0x9B, 0x5D, 0x87, 0x80, + 0x9B, 0x7D, 0x0F, 0x00, 0xCF, 0x2F, 0x4F, 0x37, 0xDB, 0xFD, 0x6E, 0xDF, + 0x03, 0x88, 0x93, 0xE5, 0x6C, 0x31, 0x6B, 0x0A, 0x91, 0x52, 0xD2, 0xFB, + 0x38, 0x6B, 0xDD, 0x30, 0x7A, 0x21, 0x08, 0x20, 0x22, 0x62, 0x21, 0x0A, + 0x21, 0x55, 0xCE, 0x2C, 0x16, 0xED, 0x76, 0xD7, 0x35, 0x4D, 0xB5, 0x98, + 0x35, 0x46, 0x2B, 0x1F, 0xD3, 0xF3, 0x67, 0x67, 0xDE, 0x87, 0xBE, 0x5B, + 0x2F, 0xE6, 0xCD, 0xCD, 0xDD, 0xEA, 0xFF, 0xFA, 0xF7, 0x3F, 0xBE, 0xBA, + 0x5E, 0x4B, 0xA5, 0xDE, 0xBD, 0xBD, 0x16, 0x00, 0x75, 0x55, 0x39, 0xEB, + 0xE6, 0x8B, 0x39, 0x08, 0x10, 0x85, 0xF6, 0x5D, 0x67, 0xAD, 0xF6, 0xDE, + 0x5B, 0x63, 0x4A, 0x29, 0x00, 0x78, 0x32, 0x6B, 0x3F, 0xF8, 0xC6, 0xB3, + 0x90, 0xD2, 0x97, 0x6F, 0x6F, 0x53, 0xCA, 0x37, 0x77, 0x0F, 0xFB, 0x7D, + 0x47, 0x44, 0x0C, 0xAE, 0x9F, 0x9C, 0xCC, 0x39, 0x74, 0x92, 0x84, 0xE0, + 0xB4, 0x60, 0x00, 0x08, 0x31, 0x6D, 0xF7, 0xFD, 0xFF, 0xFD, 0x6F, 0xFE, + 0x8F, 0x5F, 0xFE, 0xEC, 0x47, 0x84, 0x80, 0x28, 0xB7, 0xEB, 0x95, 0x73, + 0x6E, 0xBB, 0xBA, 0x4D, 0xFD, 0xBE, 0x2B, 0x18, 0x62, 0x7C, 0xEF, 0xF9, + 0xC5, 0x72, 0xD1, 0x8E, 0x63, 0x70, 0xCE, 0x02, 0xE0, 0x7E, 0xD7, 0xA5, + 0x9C, 0xAB, 0xDA, 0xE5, 0x5C, 0xF6, 0xEB, 0x35, 0xE7, 0x92, 0x71, 0x57, + 0x2B, 0xD5, 0xA4, 0xFC, 0x54, 0x49, 0x2A, 0x25, 0x79, 0x56, 0xAF, 0x9C, + 0x15, 0x20, 0x54, 0x65, 0x67, 0x4D, 0xCD, 0x06, 0xF9, 0x21, 0xC6, 0x31, + 0x84, 0x59, 0x5D, 0x23, 0x40, 0x48, 0x79, 0x8C, 0x49, 0xF4, 0x63, 0x4C, + 0x21, 0xE7, 0x22, 0x51, 0x69, 0x25, 0x53, 0x4E, 0x2C, 0x78, 0x00, 0xC0, + 0x71, 0x0C, 0x56, 0x2B, 0xAB, 0x4D, 0x29, 0xC5, 0xC7, 0x28, 0x09, 0x59, + 0x98, 0x12, 0x73, 0x3A, 0x1E, 0x95, 0x8C, 0x77, 0x3A, 0x6B, 0x38, 0xF3, + 0x7D, 0x31, 0x6B, 0x47, 0x1F, 0xFA, 0x61, 0x9C, 0xCD, 0x1A, 0x29, 0x65, + 0x4A, 0xB9, 0xB1, 0x36, 0xA6, 0x28, 0x84, 0xA8, 0xEB, 0x0A, 0x40, 0x38, + 0xA7, 0x11, 0x71, 0xBB, 0xEB, 0x95, 0xC2, 0xE5, 0x72, 0x86, 0x12, 0xE5, + 0x5E, 0x86, 0xC9, 0xC1, 0xB1, 0x68, 0xAD, 0xAD, 0x56, 0xF3, 0x59, 0xF3, + 0xFC, 0xD9, 0xF9, 0xED, 0xDD, 0x43, 0x53, 0x57, 0xCF, 0x2F, 0x4F, 0x4F, + 0x96, 0x73, 0x04, 0xB4, 0x4E, 0xD7, 0x95, 0xD5, 0x5A, 0xB3, 0xF2, 0x0E, + 0x40, 0x68, 0x23, 0xB5, 0xD6, 0x48, 0x90, 0x0E, 0x96, 0xD9, 0xF8, 0x04, + 0xC1, 0x3E, 0xDE, 0x0B, 0x42, 0x3C, 0x7A, 0x45, 0x1D, 0xBC, 0x37, 0x05, + 0x6B, 0x40, 0x29, 0x3D, 0xD2, 0xB3, 0xB9, 0x54, 0x95, 0x83, 0x19, 0x3F, + 0x4D, 0xAB, 0x12, 0x16, 0x0E, 0xE0, 0xE9, 0x72, 0x1E, 0x53, 0xDE, 0x77, + 0x5D, 0x08, 0x91, 0x84, 0x98, 0xB7, 0xB3, 0x98, 0xD2, 0xE0, 0xC3, 0x18, + 0x02, 0x95, 0x12, 0x7D, 0x80, 0x22, 0x62, 0x8A, 0xC0, 0x94, 0x73, 0x12, + 0x46, 0x4A, 0x2A, 0xA5, 0x6D, 0x6B, 0x21, 0x70, 0xB3, 0xDB, 0xB2, 0x8B, + 0x4B, 0x21, 0x92, 0x88, 0x46, 0x52, 0x0A, 0x71, 0x1B, 0x93, 0x36, 0x0A, + 0x51, 0xB6, 0xAD, 0x96, 0x28, 0xC7, 0x71, 0x04, 0x00, 0x25, 0x41, 0x6A, + 0x23, 0x6B, 0xDC, 0x6D, 0xBB, 0x93, 0xE5, 0x7C, 0x7E, 0x7E, 0xBA, 0xDD, + 0x75, 0xFF, 0xF1, 0x47, 0x3F, 0xFB, 0x67, 0x7F, 0xF1, 0x77, 0xB5, 0x56, + 0xCE, 0x39, 0xBE, 0x4B, 0x63, 0x4C, 0x13, 0x2D, 0xF9, 0xF1, 0xB0, 0x9F, + 0xFC, 0xD6, 0x8F, 0x4D, 0xC1, 0x53, 0xB6, 0x54, 0x79, 0x14, 0x66, 0x1F, + 0x5A, 0x09, 0x10, 0xAB, 0xF5, 0xF6, 0xF4, 0x74, 0x59, 0xA8, 0x80, 0x10, + 0xDE, 0xC7, 0x18, 0xB2, 0xD2, 0x52, 0x2B, 0xA5, 0x95, 0xAC, 0x2B, 0x57, + 0x57, 0x2E, 0x97, 0x42, 0xA5, 0xA4, 0x5C, 0x36, 0x9B, 0x9D, 0x20, 0xD1, + 0xF5, 0x43, 0x55, 0x39, 0x44, 0x2C, 0x85, 0x9C, 0x35, 0xA5, 0x08, 0xDE, + 0x2A, 0x1E, 0x66, 0xC3, 0x92, 0x4B, 0xB9, 0xBB, 0xBD, 0x7F, 0xFB, 0xF6, + 0x96, 0x39, 0xB7, 0xB5, 0xB3, 0x24, 0xC4, 0x62, 0xD1, 0xEE, 0x76, 0x5D, + 0x53, 0x57, 0xFF, 0xF5, 0x3F, 0xF9, 0xFB, 0x0F, 0x0F, 0x9B, 0xBF, 0xFA, + 0xEB, 0x9F, 0x1A, 0xA5, 0xA4, 0x92, 0xE3, 0x18, 0xF6, 0xBA, 0x17, 0x00, + 0x52, 0xB6, 0xDC, 0x6A, 0xB0, 0x1B, 0xCA, 0xB1, 0xCD, 0x3C, 0x36, 0x40, + 0xC7, 0x1E, 0x8B, 0x3B, 0x6E, 0x46, 0x00, 0x8F, 0xAF, 0xFA, 0x89, 0x06, + 0xA0, 0x3C, 0xE9, 0xE3, 0x26, 0x3C, 0x97, 0x2B, 0x22, 0x03, 0x41, 0x29, + 0x25, 0xD6, 0x9C, 0x20, 0x62, 0x7E, 0x7C, 0xC0, 0xA3, 0x8A, 0x40, 0x30, + 0x09, 0xAC, 0x10, 0x81, 0x28, 0x04, 0x64, 0xB4, 0x3A, 0xBE, 0x63, 0x93, + 0xAB, 0x0F, 0x9B, 0xB9, 0x02, 0xDB, 0xD2, 0x89, 0x63, 0x51, 0x05, 0x10, + 0x88, 0xA2, 0x1C, 0x94, 0xE1, 0x5F, 0xC5, 0xED, 0x88, 0xB3, 0x61, 0x40, + 0x29, 0xB9, 0xDD, 0xF5, 0xBF, 0xFA, 0xED, 0x6B, 0xE7, 0x2C, 0x1B, 0x1C, + 0xB3, 0xB6, 0xD9, 0x59, 0xB3, 0xEB, 0xFA, 0x59, 0x53, 0x9D, 0x9E, 0x2C, + 0xD6, 0x9B, 0x9D, 0xD1, 0xE6, 0x5D, 0xF7, 0xF0, 0xB0, 0xDE, 0x6D, 0x77, + 0xC3, 0xB3, 0x8B, 0xE5, 0xC5, 0xD9, 0x72, 0xD6, 0x36, 0xC6, 0xC4, 0x7E, + 0x18, 0x10, 0x90, 0x7B, 0x01, 0x8E, 0x0B, 0x02, 0x21, 0x50, 0xAB, 0xA6, + 0x76, 0x21, 0x44, 0x1F, 0x53, 0x3F, 0xF8, 0x5C, 0xCA, 0xE8, 0xC3, 0x9B, + 0xAB, 0x70, 0x71, 0xB6, 0x20, 0x41, 0x3F, 0xFA, 0xE9, 0x6F, 0xFE, 0xDD, + 0x7F, 0xFC, 0xE9, 0x6A, 0xBD, 0xBD, 0xBC, 0x38, 0xEB, 0xBA, 0xA1, 0xAE, + 0x6A, 0x94, 0xDC, 0x35, 0x92, 0x02, 0xF9, 0x70, 0x77, 0xEF, 0xBD, 0x77, + 0xCE, 0x4A, 0x39, 0xBF, 0x5F, 0x6D, 0x24, 0xC2, 0x7C, 0xD6, 0x1A, 0xAD, + 0x4E, 0x4E, 0x5A, 0x21, 0xC4, 0xAB, 0x2F, 0xAF, 0xC7, 0xD1, 0xEF, 0xBB, + 0x81, 0xD3, 0xA1, 0x01, 0xE0, 0xEA, 0xFA, 0x16, 0x11, 0x58, 0x1E, 0x3C, + 0x6B, 0x1A, 0x86, 0x00, 0xBB, 0x7E, 0x1C, 0x7D, 0x18, 0x7D, 0xFA, 0xF5, + 0xAF, 0x7E, 0xF1, 0x37, 0x3F, 0xF9, 0xEB, 0x67, 0xCF, 0x5F, 0xE6, 0x18, + 0x52, 0x8A, 0x31, 0x85, 0xD3, 0xD3, 0x8B, 0x9C, 0x13, 0xC4, 0xEE, 0xBD, + 0x6F, 0x7C, 0x47, 0x22, 0xCD, 0x9A, 0x26, 0xE5, 0x1C, 0x73, 0x12, 0x24, + 0x94, 0x92, 0x4A, 0xAB, 0x8B, 0xF3, 0xD3, 0x71, 0xF4, 0x5F, 0xBC, 0xFA, + 0x32, 0xE7, 0x89, 0x86, 0x93, 0x79, 0x89, 0x59, 0x48, 0x48, 0x64, 0xAB, + 0xE8, 0xD3, 0xF9, 0x2C, 0xC4, 0x88, 0x88, 0x0A, 0x71, 0xDE, 0xD4, 0x12, + 0x85, 0x95, 0x32, 0x1C, 0x3A, 0x14, 0x6B, 0x4C, 0x2E, 0x25, 0x11, 0xF5, + 0x3E, 0xA4, 0x94, 0xD0, 0xD9, 0x94, 0x0B, 0x95, 0x22, 0x25, 0x29, 0x25, + 0x01, 0x05, 0x5F, 0x67, 0xA9, 0xC4, 0x7E, 0xF0, 0xD9, 0x6A, 0x09, 0x50, + 0x40, 0x74, 0x83, 0x57, 0x12, 0xA5, 0xC4, 0x18, 0x12, 0xF3, 0xE6, 0x01, + 0x90, 0xC3, 0xC3, 0xF9, 0xB6, 0xE1, 0x55, 0xD4, 0x62, 0xD6, 0x9C, 0x2C, + 0x66, 0x1C, 0xC2, 0x69, 0x8C, 0x46, 0x80, 0x54, 0xB2, 0x0F, 0xD1, 0x59, + 0xCD, 0xAA, 0x72, 0x00, 0x08, 0x21, 0x0A, 0x2D, 0x00, 0x54, 0x8C, 0x49, + 0x6B, 0xD5, 0xB6, 0x4D, 0x4A, 0xB6, 0x4E, 0x29, 0xA6, 0xC4, 0x9E, 0x53, + 0x4D, 0xE5, 0x9C, 0x51, 0x1F, 0x7D, 0xFB, 0x7D, 0x25, 0x55, 0x5D, 0xBB, + 0xE5, 0xBC, 0x05, 0x04, 0xF6, 0x7A, 0xD5, 0x46, 0x4D, 0x94, 0x7D, 0x98, + 0x4A, 0x52, 0x11, 0xD3, 0x9E, 0xFE, 0xB8, 0x95, 0xE7, 0x03, 0xF4, 0x78, + 0x3F, 0x1C, 0xBA, 0xB1, 0x69, 0xDF, 0x24, 0x84, 0x90, 0x12, 0x65, 0xC1, + 0xC9, 0x27, 0x3A, 0x0A, 0x16, 0x75, 0x29, 0x25, 0x8D, 0xD6, 0x82, 0x44, + 0x08, 0x01, 0x40, 0x68, 0xAD, 0xB8, 0xDF, 0x11, 0x30, 0x89, 0x4F, 0x8D, + 0xD1, 0x75, 0xE5, 0x26, 0x0E, 0x11, 0x1B, 0x2A, 0x10, 0x19, 0xA5, 0xB3, + 0x80, 0x18, 0x63, 0x2E, 0x23, 0x22, 0x0A, 0xCA, 0x28, 0x10, 0x04, 0x31, + 0xAB, 0x66, 0xB7, 0xDB, 0x77, 0xD0, 0x97, 0x52, 0x0E, 0x9C, 0x74, 0xF6, + 0xA8, 0x17, 0x5A, 0x49, 0x22, 0x4E, 0xFE, 0x11, 0x54, 0x08, 0x51, 0xB4, + 0x4D, 0xAD, 0x95, 0x24, 0x22, 0x67, 0x6D, 0xCE, 0xB9, 0x76, 0xF6, 0xF2, + 0xFC, 0xF4, 0xE5, 0xF3, 0x33, 0xEF, 0xE3, 0x6E, 0xDF, 0xB3, 0x10, 0xD8, + 0x7B, 0x4F, 0x85, 0xA4, 0x92, 0x4C, 0x0A, 0xE5, 0xFB, 0x13, 0x00, 0xD4, + 0x24, 0x53, 0x7D, 0xC4, 0x7A, 0x9E, 0xC0, 0x5E, 0x07, 0xC6, 0xD3, 0xA1, + 0xC0, 0x1D, 0x09, 0xAB, 0xDF, 0xFD, 0xF6, 0xFB, 0x5C, 0x0D, 0x85, 0x10, + 0x31, 0xC6, 0xE0, 0x63, 0x4E, 0x74, 0xC0, 0x79, 0x31, 0xE5, 0x9C, 0x52, + 0x2E, 0x99, 0x10, 0xE1, 0x64, 0x3E, 0x2B, 0xB9, 0xB4, 0x6D, 0xBD, 0xD9, + 0xED, 0x72, 0xCC, 0xA7, 0x27, 0xCB, 0x31, 0xA6, 0x52, 0x4A, 0x55, 0x39, + 0x00, 0x01, 0x88, 0x3E, 0x84, 0xA6, 0x72, 0xFD, 0xAE, 0xBB, 0x7A, 0x7B, + 0x7B, 0x7B, 0xB7, 0x92, 0x38, 0x25, 0x24, 0x75, 0xFD, 0x70, 0x75, 0x75, + 0x0D, 0x02, 0xBE, 0xF5, 0xE1, 0x37, 0x16, 0xF3, 0xD9, 0xF5, 0xF5, 0x9D, + 0xB5, 0xBA, 0x69, 0x6B, 0x46, 0x45, 0x11, 0x38, 0x98, 0x4A, 0x4C, 0x15, + 0x87, 0x4B, 0xC6, 0xA1, 0x9B, 0x11, 0x07, 0x64, 0xEA, 0xD8, 0x63, 0x1E, + 0xF7, 0xE6, 0xE5, 0x20, 0x63, 0x7A, 0x3A, 0x81, 0x4E, 0xF4, 0x0B, 0x9A, + 0x1C, 0xE4, 0x98, 0x7A, 0x72, 0xF0, 0x58, 0xA6, 0x9C, 0x4B, 0xDF, 0x8F, + 0x29, 0x27, 0xD6, 0x4E, 0xB3, 0x3D, 0xAD, 0x94, 0x12, 0x51, 0x00, 0x16, + 0x44, 0x28, 0x99, 0xB1, 0xA0, 0x49, 0xE1, 0x04, 0x6C, 0x6C, 0xC5, 0x4C, + 0xFF, 0xC9, 0xFA, 0x45, 0xF0, 0xE3, 0xE7, 0x9C, 0xF8, 0x8A, 0xE2, 0xF3, + 0x1E, 0xA7, 0x7D, 0x28, 0x32, 0x63, 0x0D, 0x9F, 0xFC, 0xF2, 0xFC, 0xFB, + 0xCB, 0xFF, 0xF9, 0x5F, 0xFF, 0x6B, 0xFE, 0xF4, 0xFF, 0x9F, 0xFF, 0xF0, + 0x8B, 0xAE, 0xF7, 0xB3, 0xA6, 0x8E, 0xA9, 0x84, 0x98, 0xBA, 0x6E, 0x38, + 0x59, 0xCE, 0x18, 0xA4, 0x6C, 0xDB, 0x1A, 0x40, 0x48, 0xA9, 0xF6, 0xDD, + 0x30, 0x8E, 0xC1, 0x39, 0x27, 0x00, 0x42, 0x4C, 0x31, 0x66, 0x40, 0x31, + 0x6F, 0xEB, 0x9C, 0xCB, 0xBE, 0x1B, 0xB5, 0x56, 0xD6, 0x6A, 0xE7, 0x6C, + 0x53, 0x57, 0x28, 0xA5, 0x73, 0xB6, 0xAA, 0x2B, 0x22, 0xA1, 0x94, 0x0A, + 0x21, 0x19, 0xAD, 0xAB, 0xBA, 0xEA, 0xFB, 0xF1, 0xEA, 0xDD, 0xDD, 0x2F, + 0x3E, 0xFE, 0xEC, 0x27, 0xBF, 0xF8, 0x24, 0xC4, 0xAC, 0x94, 0xDC, 0xED, + 0x7A, 0x22, 0xAA, 0x2A, 0xE7, 0x7D, 0xE8, 0x87, 0x01, 0x41, 0xE4, 0x18, + 0xEA, 0xDA, 0xC5, 0x14, 0x87, 0xD1, 0x33, 0xF5, 0xA1, 0x94, 0xEC, 0x8C, + 0xF9, 0xFE, 0x77, 0xBE, 0x79, 0x7A, 0xBA, 0xB8, 0xB9, 0x5B, 0x5F, 0xBD, + 0xBB, 0x15, 0x08, 0x31, 0x04, 0x44, 0xE9, 0x9C, 0xD5, 0x5A, 0xB7, 0x4D, + 0xF5, 0xC1, 0xFB, 0x2F, 0x4E, 0x4E, 0xE6, 0xC3, 0x10, 0x86, 0x61, 0x0C, + 0x31, 0x75, 0xFD, 0xE0, 0x7D, 0xD8, 0x77, 0x23, 0x4A, 0x19, 0xC7, 0xDD, + 0xF5, 0xF5, 0xF5, 0xC5, 0xC5, 0xB3, 0x93, 0x93, 0x65, 0x55, 0xB9, 0xBA, + 0x69, 0x5E, 0x3C, 0x7F, 0x96, 0x87, 0xDD, 0xC2, 0xE8, 0xE6, 0xFC, 0x65, + 0x55, 0xD9, 0x61, 0xF4, 0xD7, 0xB7, 0x2B, 0xA5, 0x14, 0xFB, 0x5F, 0x0B, + 0x21, 0x46, 0x1F, 0x3E, 0xFF, 0xE2, 0xCD, 0xF5, 0xED, 0x3D, 0x02, 0x56, + 0xCE, 0xA6, 0x54, 0x68, 0xB2, 0xDF, 0x11, 0x4C, 0x95, 0x12, 0x4C, 0xCB, + 0xCE, 0xD9, 0x4C, 0xD6, 0x54, 0xD9, 0x19, 0x2B, 0x11, 0x0B, 0x51, 0x37, + 0x8C, 0x85, 0x0A, 0x09, 0x18, 0x43, 0x14, 0x08, 0xA3, 0x0F, 0xB3, 0xB6, + 0xD1, 0x0A, 0x95, 0x92, 0xCE, 0x5A, 0x89, 0x18, 0x52, 0x1A, 0x43, 0xCC, + 0xB9, 0x84, 0x94, 0x0F, 0x90, 0x13, 0x68, 0x2D, 0x63, 0x8C, 0xFD, 0x30, + 0x1A, 0xA3, 0x94, 0xC4, 0x52, 0x88, 0xD1, 0x59, 0x00, 0x28, 0x82, 0x98, + 0x59, 0x32, 0xFA, 0xC0, 0x40, 0xF5, 0x18, 0x22, 0x23, 0x47, 0x25, 0xE7, + 0x94, 0x92, 0x44, 0x3C, 0x5D, 0xCE, 0x3E, 0x78, 0xF9, 0x62, 0x3E, 0x6B, + 0x4A, 0x29, 0xD6, 0x18, 0x29, 0xD1, 0x28, 0x05, 0x62, 0x4A, 0xE1, 0x04, + 0x10, 0x9C, 0x0B, 0x55, 0xD7, 0x55, 0xE5, 0x6C, 0x29, 0xD9, 0x39, 0x7B, + 0x76, 0xB2, 0xA8, 0xAC, 0x6D, 0x6A, 0xD7, 0xD4, 0x95, 0xD1, 0xBA, 0x72, + 0xC6, 0x59, 0x63, 0x8C, 0x92, 0x6A, 0x52, 0xA5, 0xE0, 0x94, 0xB1, 0x0C, + 0xE2, 0xE0, 0x3E, 0x3A, 0x9D, 0x9C, 0x4F, 0x66, 0x28, 0x98, 0xEC, 0x9E, + 0xE0, 0x28, 0x62, 0x43, 0x96, 0x14, 0x1D, 0x28, 0xD3, 0xC8, 0x76, 0x63, + 0xD3, 0x86, 0xAE, 0x30, 0xD5, 0x52, 0x2A, 0x94, 0x52, 0xE2, 0xC1, 0x6B, + 0x57, 0x49, 0xA5, 0x95, 0x44, 0x40, 0x56, 0xE1, 0x30, 0x39, 0x5C, 0x6B, + 0x15, 0x53, 0x4E, 0x29, 0xC5, 0x98, 0x04, 0xD1, 0xC4, 0x2E, 0x9D, 0xEE, + 0x34, 0x92, 0x52, 0x09, 0x21, 0xB4, 0x52, 0xFC, 0xCE, 0x30, 0x57, 0xB2, + 0x94, 0x62, 0x8C, 0xAA, 0x6A, 0x27, 0x88, 0x72, 0xCE, 0x3C, 0x31, 0x38, + 0xE7, 0x9A, 0xCA, 0x6A, 0xA9, 0x08, 0xE0, 0xE0, 0xFC, 0xC1, 0xFD, 0x21, + 0x55, 0xCE, 0x5D, 0x9E, 0x9F, 0x28, 0x25, 0xDF, 0x7B, 0x7E, 0x51, 0x4A, + 0x79, 0xF5, 0xE6, 0xFA, 0xF2, 0xFC, 0x84, 0xEF, 0x28, 0x7E, 0x69, 0x13, + 0xC1, 0xE2, 0xC9, 0xDF, 0x8F, 0xB8, 0xF5, 0x93, 0xF2, 0xFD, 0x08, 0x1B, + 0x3D, 0xC5, 0x9E, 0x98, 0xCB, 0x2A, 0x04, 0xC4, 0x34, 0x65, 0x57, 0x23, + 0xE2, 0xC1, 0x6A, 0x01, 0xA5, 0x7C, 0x7C, 0xC7, 0xF8, 0x92, 0xE3, 0x08, + 0xD4, 0x59, 0x53, 0x0F, 0xC3, 0x18, 0x52, 0xAA, 0xAC, 0xDD, 0xED, 0xBB, + 0x31, 0x04, 0x21, 0x84, 0x54, 0x72, 0xB5, 0xDE, 0x0A, 0x01, 0xFD, 0x30, + 0x7E, 0xF1, 0xFA, 0x6A, 0xB5, 0xDA, 0xAE, 0x56, 0x9B, 0xA6, 0xA9, 0xA5, + 0xC4, 0x97, 0x2F, 0x2F, 0xE7, 0xB3, 0x76, 0x18, 0xBD, 0xB5, 0xA6, 0xEF, + 0xC7, 0xBB, 0xBB, 0x07, 0xEF, 0xBD, 0xAB, 0xEC, 0x72, 0x3E, 0x33, 0x5A, + 0x39, 0x6B, 0x9A, 0xA6, 0x52, 0x5A, 0x31, 0xAB, 0x99, 0x04, 0x70, 0x01, + 0xE1, 0x52, 0x5F, 0x0E, 0x66, 0x96, 0x4F, 0x60, 0xB2, 0xE3, 0xAB, 0x11, + 0x4F, 0x2B, 0x32, 0x11, 0x31, 0x52, 0x3C, 0xFA, 0xC8, 0xE9, 0xDD, 0x31, + 0x71, 0x86, 0x77, 0xE2, 0x7E, 0x29, 0xA5, 0x12, 0x42, 0x8A, 0x31, 0x8E, + 0x3E, 0x6C, 0x77, 0x5D, 0x3F, 0xFA, 0x18, 0xD3, 0x6E, 0xDF, 0xE7, 0x42, + 0xB9, 0x94, 0x54, 0x32, 0x91, 0x60, 0x0D, 0x53, 0xC8, 0xC9, 0xC7, 0x14, + 0xC2, 0x94, 0x7B, 0x92, 0x52, 0x49, 0x39, 0x33, 0xE6, 0x4F, 0x45, 0xE4, + 0x5C, 0x52, 0x2E, 0x39, 0xE7, 0x10, 0xF8, 0x03, 0x3F, 0x9E, 0x10, 0x8F, + 0x8D, 0xBF, 0x98, 0x04, 0x02, 0x30, 0x55, 0x3D, 0x4E, 0x83, 0x2D, 0x85, + 0x66, 0x8D, 0xFB, 0xF8, 0xD3, 0xAB, 0xCF, 0x5E, 0xDF, 0xBE, 0x7C, 0x76, + 0x76, 0xF5, 0xF6, 0x5E, 0x1B, 0xAD, 0xB5, 0x0C, 0x39, 0x0F, 0x63, 0x38, + 0x3F, 0x5B, 0x08, 0x21, 0x62, 0xCA, 0xEB, 0xCD, 0x7E, 0xD6, 0xD6, 0xC6, + 0x68, 0xE6, 0xE8, 0x97, 0x03, 0x83, 0x4E, 0x08, 0x08, 0x21, 0x29, 0xA9, + 0x4E, 0x16, 0xB3, 0x10, 0xE3, 0x7A, 0xB3, 0x37, 0x5A, 0xCD, 0xDA, 0x3C, + 0x9B, 0x35, 0x29, 0xE5, 0xD1, 0x07, 0x40, 0x88, 0x31, 0x2D, 0x17, 0x2D, + 0x22, 0xFE, 0xFE, 0xF3, 0x2F, 0x7F, 0xF7, 0xD9, 0x9B, 0xF5, 0x66, 0xA7, + 0x95, 0x9A, 0xB7, 0x4D, 0x7F, 0xFB, 0xC0, 0xDC, 0x2B, 0x25, 0xD5, 0x7E, + 0xBF, 0xDF, 0x6C, 0xF7, 0x08, 0xA0, 0x50, 0xBC, 0xF7, 0xFC, 0x72, 0xBD, + 0xDD, 0xD5, 0x95, 0x33, 0xDA, 0x74, 0x5D, 0xEF, 0x9C, 0xFD, 0xE3, 0x3F, + 0xF8, 0xDE, 0xE5, 0xF9, 0xC9, 0xD9, 0xE9, 0xD2, 0x39, 0x73, 0xFF, 0xB0, + 0x71, 0xD6, 0x94, 0x92, 0x4F, 0x4F, 0x96, 0xEF, 0xBD, 0xB8, 0xFC, 0xD9, + 0xAF, 0x7E, 0x2B, 0x01, 0xFE, 0xFE, 0xDF, 0xFD, 0x21, 0x77, 0xE9, 0xD6, + 0x9A, 0x9C, 0xCB, 0xED, 0xFD, 0xBA, 0x14, 0x5A, 0xCC, 0x5B, 0xA5, 0x94, + 0xD6, 0xFA, 0xF9, 0xE5, 0xDF, 0x9B, 0xCD, 0x17, 0x45, 0xC8, 0x90, 0x8A, + 0xC5, 0xF2, 0x70, 0xF5, 0xDB, 0xFB, 0xF5, 0xAE, 0xF8, 0xFE, 0xF6, 0xED, + 0x6B, 0xFB, 0xE2, 0xA3, 0x5D, 0x5F, 0x83, 0x60, 0xE5, 0xB6, 0x16, 0x00, + 0xFD, 0x30, 0xF6, 0xC3, 0xF8, 0xC5, 0xAB, 0x37, 0xF7, 0xF7, 0xAB, 0xCA, + 0x5A, 0xE4, 0xEC, 0xDB, 0x54, 0xB4, 0x96, 0xB9, 0xE4, 0x10, 0x32, 0x5B, + 0xA7, 0x12, 0x09, 0xAD, 0x65, 0x89, 0xB1, 0x1B, 0x06, 0x67, 0xCC, 0xAC, + 0xA9, 0x84, 0xA0, 0x10, 0xA3, 0x0F, 0x41, 0x08, 0x52, 0x52, 0xFB, 0x18, + 0x53, 0xCA, 0x80, 0xA0, 0x8D, 0x0E, 0x21, 0x00, 0x68, 0xDE, 0xE2, 0x03, + 0x88, 0x74, 0x50, 0x71, 0x3B, 0xAB, 0x63, 0x2A, 0x39, 0x8F, 0x46, 0x6B, + 0x29, 0x25, 0x20, 0x2A, 0xE5, 0xB5, 0x56, 0xE7, 0xCB, 0x79, 0x37, 0x8C, + 0xDB, 0x5D, 0x07, 0x12, 0x11, 0xC1, 0x80, 0x8A, 0x71, 0x4A, 0xB4, 0xE4, + 0xBF, 0xF4, 0x43, 0x30, 0xDA, 0xB4, 0x75, 0x15, 0x82, 0x4A, 0xA5, 0x84, + 0x10, 0x2A, 0x57, 0x19, 0xAD, 0x63, 0x4A, 0x95, 0xB3, 0xC3, 0x30, 0xB2, + 0x64, 0x8F, 0x2D, 0x59, 0x10, 0xB1, 0xA9, 0x1D, 0x22, 0x4A, 0xE9, 0x2A, + 0x67, 0x7C, 0x88, 0x4A, 0x49, 0x67, 0x8D, 0x33, 0x46, 0x4A, 0xA4, 0xC3, + 0xF5, 0x8A, 0x88, 0x4A, 0x4B, 0xD6, 0xE5, 0xE1, 0x63, 0xB0, 0xD5, 0x63, + 0xB0, 0xCD, 0xD3, 0x6B, 0xFC, 0x38, 0x6D, 0x3D, 0xFD, 0xF7, 0xE3, 0x21, + 0x7F, 0x2C, 0x76, 0xEC, 0x00, 0x23, 0x84, 0x00, 0x50, 0x5A, 0x49, 0xAD, + 0x25, 0xE7, 0x72, 0x01, 0xA2, 0xD1, 0x3A, 0x1F, 0xAD, 0xE2, 0xA5, 0x64, + 0x0D, 0x06, 0x11, 0x0D, 0x3E, 0x30, 0xEA, 0x7A, 0x58, 0x6E, 0x22, 0x00, + 0xF4, 0xE3, 0x20, 0x68, 0x02, 0xD4, 0xEB, 0xDA, 0xB6, 0x4D, 0x93, 0x72, + 0xD9, 0xEF, 0x7B, 0x67, 0x0D, 0x08, 0x31, 0x7A, 0x41, 0xA5, 0x48, 0x85, + 0x75, 0x55, 0xB5, 0x4D, 0xAD, 0x94, 0x4A, 0x75, 0xBD, 0xDB, 0xEF, 0xF7, + 0xDD, 0x40, 0x44, 0xDE, 0x7B, 0x89, 0xCE, 0x3A, 0xAD, 0x8B, 0x18, 0x47, + 0x8F, 0x38, 0x0D, 0x41, 0xF3, 0x59, 0x9B, 0x73, 0x7E, 0x73, 0x75, 0x23, + 0x25, 0x5A, 0x6B, 0xA4, 0x52, 0xC3, 0x6E, 0xFF, 0xF9, 0x17, 0x5F, 0x3E, + 0xBB, 0x38, 0x5D, 0x2C, 0xE7, 0xC6, 0x9A, 0x18, 0x53, 0x08, 0x81, 0x4D, + 0x99, 0xC4, 0x21, 0x07, 0x44, 0x7C, 0xD5, 0x1D, 0xF0, 0xD8, 0x6D, 0x1D, + 0x4B, 0x15, 0x1D, 0x82, 0x97, 0x88, 0xFB, 0x1A, 0x2A, 0xA5, 0x94, 0x31, + 0x66, 0xDE, 0x81, 0xF2, 0xD0, 0x44, 0xA5, 0x8C, 0x23, 0x07, 0xEC, 0x14, + 0xAE, 0x9A, 0x12, 0x51, 0x2B, 0x49, 0x54, 0xAE, 0xDE, 0xDE, 0x18, 0x6B, + 0xDA, 0xA6, 0xD9, 0x77, 0x3D, 0x02, 0x08, 0x94, 0xC3, 0xE8, 0x99, 0x12, + 0xD8, 0x54, 0xEE, 0xEA, 0xFA, 0x96, 0x2B, 0xCB, 0x3F, 0xFF, 0xAF, 0xFE, + 0xE1, 0xAC, 0x6D, 0xBA, 0x7E, 0xF8, 0xF2, 0xED, 0x8D, 0x00, 0x3C, 0x3B, + 0x5D, 0x72, 0xE4, 0xCA, 0xF5, 0xCD, 0xDD, 0xF7, 0x3F, 0xFA, 0x56, 0xD7, + 0x0D, 0xC4, 0xDC, 0x49, 0xAD, 0x00, 0xA5, 0xF7, 0x71, 0x24, 0x6F, 0x8D, + 0xD6, 0x5A, 0x23, 0x40, 0x06, 0xE2, 0x56, 0x52, 0x1C, 0xB6, 0x7C, 0xF4, + 0x95, 0x1A, 0x46, 0x44, 0x8F, 0x2F, 0x47, 0x1C, 0x46, 0x66, 0xA5, 0x54, + 0x8C, 0x31, 0xC6, 0xD4, 0x8F, 0xA3, 0x35, 0x5A, 0x29, 0xC5, 0xF6, 0xBC, + 0xBC, 0xFC, 0xE5, 0xC5, 0x85, 0x10, 0x94, 0x53, 0x29, 0x45, 0x74, 0xFD, + 0xC0, 0x03, 0x62, 0x95, 0x32, 0x4A, 0x34, 0x46, 0xB7, 0x75, 0x05, 0x62, + 0xC2, 0x7F, 0xF9, 0xF9, 0xF8, 0xAD, 0x1B, 0xC7, 0x51, 0x29, 0x05, 0x50, + 0xE5, 0x29, 0x06, 0x48, 0xF0, 0xEE, 0x3E, 0xE5, 0x5C, 0x0A, 0xA7, 0xCF, + 0x81, 0x25, 0xA3, 0x94, 0x3A, 0x6E, 0x59, 0x0F, 0xA0, 0x04, 0x4E, 0xEC, + 0xB3, 0x52, 0x4A, 0x21, 0xF9, 0xC3, 0xBF, 0xF3, 0xCF, 0xF7, 0xFD, 0xB8, + 0xDA, 0x0E, 0xAB, 0x4D, 0xF7, 0x8D, 0xF7, 0x2E, 0x9A, 0xDA, 0xED, 0xBA, + 0xF1, 0xE2, 0x6C, 0xF9, 0xFC, 0xE2, 0xF4, 0x37, 0xBF, 0x7F, 0xB3, 0x5A, + 0xEF, 0xAA, 0xCA, 0xED, 0xF6, 0x03, 0xFB, 0x26, 0x87, 0x18, 0x95, 0x92, + 0x24, 0x68, 0xDF, 0x0D, 0x39, 0xE5, 0x18, 0x53, 0x29, 0xB4, 0xDE, 0xED, + 0xDF, 0xDD, 0xAE, 0x4A, 0x29, 0x42, 0xC0, 0x18, 0x62, 0x8A, 0x39, 0x17, + 0xF2, 0xDE, 0xF7, 0x83, 0xF7, 0x21, 0x6A, 0xAD, 0x94, 0x94, 0x77, 0x0F, + 0x9B, 0xFF, 0xF4, 0xB3, 0x8F, 0x7F, 0xFA, 0x8B, 0xDF, 0x0D, 0x63, 0x48, + 0x29, 0x87, 0x98, 0x96, 0xF3, 0x79, 0xED, 0xEC, 0x6A, 0xB3, 0x33, 0x5A, + 0x0F, 0x7E, 0x14, 0x42, 0x20, 0x42, 0xCE, 0x09, 0x05, 0xC4, 0x98, 0xC6, + 0x71, 0x9C, 0xCF, 0x66, 0x28, 0x71, 0xBF, 0xEF, 0x2E, 0x2F, 0x4E, 0x3E, + 0xFA, 0xCE, 0x37, 0x67, 0x6D, 0xD5, 0xD4, 0xD5, 0xE8, 0xC3, 0xAB, 0xD7, + 0xEF, 0xAE, 0x6F, 0xEE, 0x4F, 0x4F, 0x16, 0x1F, 0x7D, 0xE7, 0x83, 0x8B, + 0xF3, 0xA5, 0x52, 0x6A, 0x3E, 0x6B, 0x9B, 0xA6, 0xEA, 0x87, 0x91, 0x0F, + 0x07, 0x29, 0x25, 0x1B, 0xDA, 0x58, 0x6B, 0x72, 0xCE, 0xD6, 0x9A, 0x94, + 0x4B, 0xDD, 0x2E, 0x8D, 0xAB, 0x62, 0x22, 0x92, 0xF6, 0xF9, 0xD2, 0xDE, + 0xDD, 0x5C, 0xE5, 0xB1, 0x93, 0x94, 0x3F, 0xF8, 0xC1, 0xDF, 0x2E, 0x52, + 0xF5, 0xFD, 0xB0, 0x5C, 0xCC, 0x2A, 0x67, 0x7D, 0x88, 0xDB, 0x5D, 0xFF, + 0xF6, 0xDD, 0xED, 0xFD, 0xFD, 0x4A, 0x29, 0x49, 0x02, 0xBA, 0x61, 0x2C, + 0x65, 0xDA, 0xBC, 0x48, 0x89, 0x85, 0x84, 0x8F, 0x01, 0x01, 0x99, 0x0C, + 0xE5, 0xAC, 0x71, 0xC6, 0x4A, 0x39, 0xF9, 0x19, 0xA4, 0xC9, 0x13, 0x00, + 0x38, 0xEA, 0x95, 0x7D, 0xF1, 0xFD, 0x18, 0xA4, 0x44, 0x12, 0x30, 0x0C, + 0x9E, 0xD1, 0xA0, 0x61, 0x0C, 0x0C, 0x4B, 0xF0, 0x2E, 0x29, 0x97, 0x52, + 0xD7, 0x56, 0x1E, 0xD0, 0x62, 0x22, 0xF0, 0x31, 0x72, 0xB0, 0x20, 0x90, + 0x68, 0xEA, 0x8A, 0x85, 0x01, 0xE5, 0x00, 0x00, 0xE5, 0x52, 0x88, 0x0A, + 0x20, 0xD6, 0x95, 0x6B, 0x6B, 0xC7, 0x8D, 0x89, 0x9A, 0xC2, 0xC6, 0x49, + 0x6B, 0xD9, 0x0D, 0x43, 0xD7, 0x0F, 0x4C, 0x59, 0xB2, 0xD6, 0x2C, 0xE6, + 0x8D, 0xB3, 0xB6, 0x72, 0xC6, 0x1A, 0xAD, 0x95, 0xAA, 0x2B, 0x5B, 0x57, + 0xD6, 0x5A, 0x6D, 0xAD, 0xD6, 0x46, 0x69, 0xA5, 0xB4, 0x56, 0xD6, 0x69, + 0xAB, 0x95, 0x54, 0x72, 0x92, 0xA0, 0x1E, 0xC4, 0x22, 0xB9, 0xE4, 0x94, + 0x12, 0xDF, 0x9C, 0x24, 0x1E, 0x17, 0xF6, 0xC7, 0xB2, 0xF5, 0xB4, 0x8A, + 0x3D, 0x8E, 0x99, 0x4F, 0xBF, 0x4F, 0x1C, 0x9A, 0x11, 0x98, 0x62, 0x9B, + 0x8F, 0xA8, 0x8C, 0x92, 0x88, 0x28, 0xC5, 0xC4, 0xC3, 0x28, 0xC4, 0x5B, + 0xA0, 0xED, 0x6E, 0xB3, 0xED, 0xC5, 0xC1, 0x56, 0x81, 0x61, 0x1D, 0x4E, + 0x30, 0x50, 0x52, 0x1A, 0xA3, 0x96, 0x8B, 0x45, 0x88, 0x71, 0xB3, 0xD9, + 0x49, 0x29, 0xAD, 0xD1, 0x4D, 0x5D, 0x3D, 0xBF, 0x38, 0x59, 0xCC, 0x6B, + 0x86, 0xFC, 0x4A, 0xA1, 0xAE, 0x1F, 0x01, 0x84, 0xD6, 0x5A, 0x29, 0xE9, + 0x9C, 0x45, 0x84, 0xB6, 0xAE, 0x9D, 0xB5, 0x4C, 0xEC, 0x08, 0x31, 0x30, + 0x4E, 0xA4, 0xB5, 0x32, 0xC6, 0x18, 0xA3, 0x2B, 0x6B, 0x87, 0x61, 0x5C, + 0x6D, 0x77, 0xC3, 0x18, 0x6E, 0xEE, 0x36, 0xEB, 0xED, 0x6E, 0xBD, 0xD9, + 0xED, 0x77, 0x9D, 0xB3, 0xDA, 0x1A, 0x7D, 0x8C, 0x05, 0x62, 0xD1, 0xCF, + 0xD7, 0xAA, 0x39, 0xCF, 0xDA, 0x4F, 0xFB, 0xD3, 0x23, 0xEA, 0xAF, 0xB5, + 0x36, 0xC6, 0x70, 0xCB, 0x49, 0x44, 0x89, 0xAD, 0x77, 0xD9, 0xC4, 0xC2, + 0x7B, 0x2A, 0x64, 0xB4, 0x9E, 0x7C, 0x0A, 0xA6, 0x9D, 0x09, 0xAC, 0x1E, + 0x36, 0x9F, 0x7D, 0xF1, 0xE6, 0xED, 0xBB, 0x9B, 0x9C, 0xF3, 0x7A, 0xBD, + 0xAD, 0x2A, 0x87, 0x08, 0x31, 0xE5, 0xFB, 0xBB, 0x87, 0xB3, 0xD3, 0x13, + 0x00, 0x68, 0xEB, 0xCA, 0x39, 0xFB, 0xAD, 0x6F, 0xBE, 0x77, 0x73, 0xBF, + 0x7A, 0xF5, 0xE6, 0xDD, 0x7E, 0xDF, 0xFF, 0xF2, 0xD7, 0x9F, 0xC6, 0x10, + 0x86, 0xDE, 0x6F, 0x36, 0x3B, 0x94, 0xF8, 0xE7, 0xFF, 0xE8, 0xCF, 0xBE, + 0xFD, 0xE1, 0xFB, 0x52, 0xCA, 0xDD, 0xAE, 0x9B, 0xCF, 0x5B, 0x44, 0xF4, + 0x21, 0x70, 0xE7, 0x11, 0x63, 0x46, 0x01, 0xE9, 0x20, 0x9F, 0xA4, 0x89, + 0xA9, 0xCF, 0x1C, 0xD7, 0x09, 0xB3, 0x3F, 0x94, 0x36, 0x12, 0x6C, 0x3A, + 0x26, 0x00, 0xE0, 0x2B, 0x44, 0xFC, 0x10, 0x13, 0xAF, 0xF5, 0x01, 0x60, + 0x1C, 0x7D, 0xD7, 0x8D, 0x5D, 0xD7, 0xF7, 0xDC, 0x80, 0xA5, 0x4C, 0x44, + 0x3E, 0x84, 0x5D, 0xD7, 0x97, 0x3C, 0x0D, 0x8F, 0x39, 0xE7, 0x47, 0x54, + 0xEE, 0x10, 0x0C, 0x56, 0x88, 0x38, 0x97, 0x68, 0xDA, 0x9B, 0xE4, 0x92, + 0x52, 0xE1, 0xFA, 0xC6, 0xC3, 0x4D, 0xC9, 0xC5, 0x47, 0xF6, 0xEF, 0x28, + 0x62, 0x02, 0x5B, 0xA7, 0xFE, 0xF1, 0x49, 0xFD, 0x7D, 0x7A, 0xBE, 0x82, + 0xFC, 0x07, 0x7F, 0xFE, 0xAF, 0xAE, 0xEF, 0x36, 0xEB, 0x6D, 0x27, 0x25, + 0x10, 0x89, 0xE7, 0x17, 0xA7, 0xCB, 0x45, 0xCB, 0xB5, 0xFC, 0xE5, 0xF3, + 0xB3, 0xAE, 0xF7, 0x5D, 0xEF, 0x97, 0xF3, 0x26, 0xB2, 0x7C, 0x41, 0xEB, + 0x87, 0xF5, 0x0E, 0x01, 0xDE, 0x7F, 0xEF, 0x72, 0xB9, 0x98, 0x35, 0x6D, + 0x9D, 0x4B, 0x9E, 0xB7, 0xCD, 0xAC, 0xAD, 0xF7, 0xFB, 0x01, 0x04, 0x1A, + 0xAD, 0x72, 0xA1, 0xF5, 0x7A, 0xBF, 0xEF, 0xC6, 0xAA, 0x72, 0x27, 0x8B, + 0x99, 0xB1, 0xE6, 0x6F, 0x7E, 0xF1, 0xBB, 0x57, 0xAF, 0xDE, 0x3E, 0xAC, + 0x76, 0x3C, 0xCF, 0xB3, 0xA5, 0x44, 0x37, 0x0C, 0xE7, 0x67, 0x8B, 0xF7, + 0x5F, 0x3E, 0xEF, 0xFA, 0xDE, 0x68, 0x45, 0xB9, 0x94, 0x94, 0xA5, 0x44, + 0x10, 0x02, 0x01, 0x6E, 0x57, 0xEB, 0x5D, 0xD7, 0xBF, 0xB8, 0x3C, 0x3F, + 0x59, 0x2E, 0x9E, 0x5D, 0x9C, 0x55, 0x95, 0xAD, 0x9C, 0x9D, 0xB5, 0xCD, + 0x76, 0xD7, 0x5D, 0x5D, 0xDF, 0xBE, 0x7C, 0x7E, 0xF1, 0x83, 0xEF, 0x7D, + 0x78, 0x76, 0x32, 0x57, 0x4A, 0x5D, 0x9E, 0x9F, 0x2E, 0x97, 0x73, 0x06, + 0x4A, 0x39, 0x16, 0x4C, 0x4A, 0x6C, 0x9B, 0xDA, 0x39, 0x47, 0x44, 0x21, + 0xA5, 0x9C, 0x4B, 0x4C, 0xB9, 0xEB, 0xFB, 0xD5, 0x7A, 0x6B, 0x8C, 0x7A, + 0xF9, 0xEC, 0x7C, 0xEE, 0xF0, 0xE1, 0xEE, 0xDA, 0x77, 0x3D, 0x66, 0xFF, + 0xAD, 0xEF, 0xFF, 0xD0, 0xB6, 0x0B, 0xA2, 0xC2, 0xFB, 0x84, 0xFD, 0xBE, + 0x7F, 0xFB, 0xF6, 0xFA, 0xF6, 0xEE, 0x21, 0xA5, 0x84, 0x00, 0x43, 0x88, + 0x4A, 0xCA, 0x79, 0x5B, 0x03, 0xE0, 0x18, 0x02, 0x91, 0xF0, 0x21, 0xF0, + 0x98, 0x24, 0x11, 0xB5, 0xD1, 0x46, 0x29, 0xB6, 0xA8, 0xE6, 0x74, 0x74, + 0x00, 0x88, 0x29, 0x73, 0xAD, 0x51, 0x4A, 0xF1, 0xFC, 0x28, 0xA5, 0xAC, + 0x9C, 0x65, 0x2D, 0xB1, 0x75, 0x9A, 0x4B, 0x9E, 0xD1, 0x86, 0xD7, 0xD5, + 0xFD, 0xE8, 0xAD, 0xD1, 0x25, 0xD3, 0xE8, 0x63, 0x3F, 0xF8, 0x18, 0x33, + 0x80, 0x88, 0x31, 0xF5, 0x3E, 0x5C, 0x9C, 0x9E, 0xB4, 0x4D, 0xBD, 0x98, + 0xB7, 0x3C, 0x77, 0xB0, 0x7D, 0x05, 0xD3, 0x3E, 0xA4, 0x54, 0x39, 0x25, + 0xA5, 0x25, 0x53, 0x54, 0x7B, 0xEF, 0x83, 0x8F, 0x4C, 0x64, 0x4F, 0x29, + 0x73, 0x6B, 0x16, 0x63, 0x74, 0xD6, 0x31, 0x6B, 0xB4, 0xAE, 0xDC, 0x62, + 0xD6, 0x54, 0x95, 0x35, 0x46, 0x59, 0xA3, 0x2B, 0x67, 0x2B, 0x6B, 0x50, + 0xA2, 0x00, 0xE0, 0x90, 0x04, 0x2E, 0x73, 0x88, 0x28, 0xF1, 0xC0, 0x4D, + 0x64, 0x5F, 0xA1, 0x3C, 0x5D, 0x61, 0x54, 0xE8, 0xB0, 0x63, 0x7A, 0xAC, + 0x4F, 0xF4, 0x48, 0xA4, 0x7A, 0x94, 0xA4, 0x4C, 0xE3, 0xD5, 0xD1, 0x7C, + 0xE0, 0x78, 0xCA, 0xF3, 0x4F, 0x89, 0x29, 0xBF, 0x0A, 0x01, 0x14, 0xA2, + 0x20, 0x0A, 0x29, 0x31, 0xAB, 0x2B, 0xA7, 0x22, 0x04, 0xE4, 0x94, 0xD8, + 0x0C, 0x2E, 0x84, 0xD8, 0x0F, 0x03, 0xD7, 0x0E, 0xAB, 0xCD, 0xAC, 0xAD, + 0x2E, 0x2F, 0xCE, 0xB4, 0xD6, 0x7C, 0x59, 0x37, 0x75, 0x55, 0x3B, 0x57, + 0x3B, 0x67, 0x8C, 0xAE, 0x9D, 0x5D, 0xCC, 0x6A, 0xA3, 0x14, 0x0A, 0xE1, + 0xAC, 0x96, 0x52, 0xF6, 0xC3, 0x18, 0x62, 0xE4, 0x8E, 0xC9, 0x1A, 0x63, + 0xAD, 0xE1, 0x7A, 0xC4, 0xC1, 0x9C, 0xC4, 0x49, 0x4E, 0x08, 0x55, 0xE5, + 0x9C, 0xB5, 0x21, 0xA6, 0xD1, 0x87, 0x94, 0x8A, 0x52, 0x8A, 0x0A, 0x6D, + 0x77, 0xDD, 0xFD, 0xC3, 0xE6, 0x93, 0xDF, 0xBF, 0xF9, 0xDD, 0xEF, 0x5F, + 0x6F, 0xF7, 0xFD, 0xE5, 0xF9, 0xA9, 0x56, 0x32, 0xC4, 0xF8, 0xB5, 0x11, + 0x32, 0xA6, 0x94, 0x62, 0x9C, 0xA4, 0x4B, 0x88, 0x47, 0xF3, 0x2D, 0x00, + 0x90, 0x07, 0x4B, 0xBD, 0xE3, 0x97, 0x94, 0x32, 0xC4, 0xB8, 0xEB, 0x7A, + 0xA5, 0x25, 0x00, 0x8C, 0xDE, 0xF3, 0xA6, 0xB2, 0x4C, 0xAD, 0xBD, 0xEA, + 0xFB, 0xA1, 0xEF, 0x87, 0xD1, 0x87, 0x94, 0xD2, 0x72, 0x3E, 0x23, 0x21, + 0x9C, 0xB3, 0x24, 0x40, 0x69, 0xE9, 0x47, 0x7F, 0x7E, 0x76, 0xD2, 0xD4, + 0x15, 0xCF, 0xAC, 0x28, 0xE5, 0x4F, 0x7E, 0xFA, 0xF1, 0xCF, 0x7E, 0xF1, + 0xBB, 0xFD, 0xBE, 0xBF, 0xBF, 0xDF, 0xB4, 0x6D, 0xDD, 0xD4, 0x15, 0x08, + 0x78, 0xF1, 0xFC, 0xFC, 0xF2, 0xD9, 0xF9, 0x1F, 0xFD, 0xAD, 0xEF, 0x79, + 0x1F, 0x7C, 0x08, 0x27, 0xCB, 0x45, 0xED, 0xEC, 0x76, 0xB7, 0x5F, 0xAD, + 0xB6, 0xCC, 0x3A, 0x4C, 0x29, 0xA5, 0x5C, 0x62, 0xCA, 0xD6, 0x68, 0x2E, + 0x64, 0xEC, 0xA6, 0x83, 0x00, 0xB9, 0x90, 0x98, 0x02, 0x5A, 0xC5, 0x91, + 0x23, 0xC6, 0xB7, 0xD2, 0x11, 0x20, 0xCB, 0xA5, 0xE4, 0x5C, 0xF0, 0xD8, + 0x14, 0x09, 0x31, 0x8C, 0xA1, 0x70, 0xDE, 0x28, 0x20, 0x6F, 0x30, 0x73, + 0x29, 0x29, 0x15, 0x00, 0xA1, 0x24, 0x5A, 0x63, 0xB8, 0xB4, 0x6B, 0xAD, + 0x39, 0xAA, 0x83, 0x4D, 0x0A, 0x52, 0x4A, 0x25, 0xA7, 0x9C, 0xA8, 0x64, + 0x62, 0xA7, 0xA5, 0x98, 0xCB, 0xBE, 0xEB, 0x52, 0xCA, 0x5A, 0xB1, 0xC6, + 0x9E, 0x65, 0xAA, 0x29, 0xC6, 0x49, 0xAD, 0x0A, 0x07, 0xE0, 0x9F, 0xAF, + 0xA3, 0x72, 0xE0, 0xD6, 0x1E, 0x64, 0x06, 0x42, 0x08, 0x21, 0xFF, 0xC5, + 0xBF, 0xFA, 0xEF, 0x77, 0xDD, 0xB8, 0xDA, 0x74, 0xF3, 0xB6, 0x66, 0xAA, + 0xA4, 0x75, 0x46, 0x29, 0xA9, 0xB5, 0xAA, 0x2B, 0xFB, 0xFD, 0xEF, 0xBE, + 0x6F, 0xB4, 0x8A, 0x29, 0xEF, 0xBB, 0xA1, 0x1F, 0x3C, 0x7B, 0x12, 0x9C, + 0x9D, 0x2E, 0xDE, 0x7B, 0x71, 0x3E, 0x9B, 0xD5, 0xF3, 0xB6, 0xAE, 0x6B, + 0x17, 0x63, 0x72, 0xC6, 0xF0, 0x2C, 0xB9, 0xDB, 0x75, 0x29, 0xE7, 0xB6, + 0xAD, 0xDF, 0x7F, 0xEF, 0xA2, 0x94, 0xF2, 0xF1, 0xA7, 0xAF, 0xFE, 0xD7, + 0xFF, 0xF3, 0xDF, 0xFF, 0xF2, 0x37, 0x9F, 0x5D, 0x5E, 0x9C, 0x36, 0xB5, + 0x8B, 0x29, 0x6D, 0xB6, 0x1D, 0x09, 0xF0, 0xC1, 0xBF, 0xB8, 0x3C, 0x3B, + 0x3F, 0x3B, 0xE1, 0xCB, 0xB4, 0xAA, 0x1C, 0x13, 0x05, 0x94, 0x52, 0x7F, + 0xF4, 0x83, 0x6F, 0xC7, 0x9C, 0x6F, 0xEF, 0xD7, 0xD6, 0x9A, 0xCA, 0x1A, + 0x44, 0x51, 0x0A, 0x59, 0x6B, 0x2B, 0x67, 0x94, 0x56, 0x95, 0x35, 0xE7, + 0x67, 0xCB, 0xE7, 0x97, 0xE7, 0x6D, 0x53, 0x21, 0x22, 0x23, 0xFD, 0x46, + 0x6B, 0x6B, 0x0D, 0x4C, 0x42, 0x1F, 0xA1, 0x94, 0xD2, 0x5A, 0x21, 0x62, + 0xCE, 0xC5, 0x68, 0x2D, 0x11, 0xC7, 0x10, 0x76, 0xBB, 0xBE, 0x94, 0xB2, + 0x9C, 0xB7, 0x55, 0xE5, 0x94, 0x88, 0xEB, 0xFB, 0xEB, 0xDD, 0x7A, 0x95, + 0xFA, 0xED, 0xCB, 0x6F, 0x7E, 0xB4, 0x7C, 0xF6, 0x9E, 0x92, 0x40, 0x82, + 0xEE, 0xD7, 0xBB, 0xDF, 0x7F, 0x7E, 0x75, 0x7B, 0xB7, 0xE2, 0xE8, 0x43, + 0x76, 0x50, 0x11, 0x42, 0x74, 0xC3, 0x38, 0x7A, 0x6F, 0xAD, 0x71, 0xCE, + 0xA6, 0x98, 0x84, 0x00, 0xAD, 0x95, 0x94, 0x2A, 0x1D, 0x42, 0x31, 0x2B, + 0x63, 0x53, 0xC9, 0x5A, 0x2A, 0x6B, 0xF5, 0x18, 0x42, 0xCA, 0x59, 0x6B, + 0x3D, 0x8C, 0xBE, 0xEB, 0x87, 0xC5, 0xAC, 0x71, 0xCE, 0x4A, 0x89, 0x39, + 0x65, 0x21, 0x84, 0xD1, 0xBA, 0x1B, 0x46, 0xBE, 0x76, 0x79, 0x97, 0xD2, + 0x0F, 0x9E, 0xD1, 0xEE, 0xC8, 0x58, 0x3A, 0x89, 0x10, 0x43, 0xDB, 0x34, + 0x70, 0x0C, 0xFA, 0x16, 0x30, 0xFA, 0x10, 0xD3, 0x24, 0x50, 0x67, 0xB2, + 0x3E, 0xAF, 0x87, 0x2A, 0x06, 0xC5, 0xCB, 0x14, 0x98, 0xA2, 0x95, 0x02, + 0x21, 0xBC, 0x0F, 0x7D, 0xDF, 0xC7, 0x94, 0x10, 0xA5, 0x44, 0x54, 0x52, + 0x5A, 0x67, 0xDB, 0xA6, 0xB2, 0x46, 0x29, 0x2D, 0x11, 0x59, 0x95, 0xC9, + 0x1E, 0x96, 0x28, 0x11, 0x95, 0x54, 0xD6, 0x1A, 0x0E, 0x4F, 0x61, 0xEF, + 0x02, 0x7E, 0x44, 0x1E, 0x4B, 0x27, 0xFF, 0x4F, 0x26, 0x76, 0x1E, 0x8A, + 0x17, 0x1C, 0xBE, 0xF8, 0x38, 0x84, 0xAF, 0xF9, 0x05, 0x4C, 0x86, 0x4E, + 0x53, 0x21, 0x3B, 0x36, 0x6D, 0xC7, 0xF1, 0x05, 0x18, 0x18, 0x3A, 0xD4, + 0x85, 0x34, 0xF9, 0xD8, 0x4C, 0xE7, 0x6D, 0xE5, 0x2C, 0xA0, 0xF0, 0x3E, + 0x8E, 0x3E, 0x70, 0xDD, 0x94, 0x52, 0xD6, 0x75, 0xA5, 0x95, 0x12, 0x42, + 0xF4, 0x5D, 0xEF, 0xBD, 0x37, 0xC6, 0x18, 0xAD, 0x8D, 0x36, 0x82, 0x28, + 0xE7, 0x32, 0xF8, 0xE0, 0x43, 0xFA, 0xEE, 0xB7, 0x5E, 0x90, 0x10, 0xEF, + 0x6E, 0x1E, 0x4A, 0x29, 0x56, 0x6B, 0x3C, 0x38, 0x6A, 0xF1, 0x88, 0x1D, + 0x42, 0x64, 0xCE, 0x9D, 0x10, 0x64, 0xB4, 0xB1, 0xC6, 0xB0, 0x98, 0xD1, + 0x87, 0xD0, 0x0F, 0x43, 0x29, 0x13, 0x55, 0x38, 0xA6, 0xC4, 0x4C, 0x1A, + 0xAD, 0x75, 0xCC, 0xF9, 0xEA, 0xDD, 0xDD, 0xC3, 0xC3, 0xE6, 0x64, 0xDE, + 0x3A, 0x67, 0x00, 0x21, 0x86, 0xC8, 0x23, 0x63, 0x8C, 0x31, 0x8E, 0x3E, + 0xA7, 0xC4, 0xDD, 0x22, 0x4D, 0x9E, 0x0D, 0x13, 0x13, 0x2A, 0xE7, 0xC4, + 0xD3, 0x16, 0x3D, 0x71, 0xF1, 0xE7, 0x23, 0x85, 0xA9, 0x09, 0x29, 0x66, + 0x6B, 0x0D, 0x11, 0x31, 0xFD, 0x8D, 0x07, 0xA9, 0x61, 0xF4, 0x4A, 0x2B, + 0x67, 0x4D, 0x08, 0x51, 0x4A, 0x7C, 0xB8, 0x5F, 0xAF, 0x56, 0xAB, 0x94, + 0x72, 0x8C, 0x71, 0xB9, 0x98, 0x2B, 0xAD, 0xEE, 0xEE, 0x57, 0x9F, 0x7D, + 0x71, 0xF5, 0xEE, 0xDD, 0xDD, 0xE7, 0x5F, 0x5C, 0xA5, 0x9C, 0x7D, 0x88, + 0x97, 0xCF, 0xCE, 0xFE, 0xDE, 0xDF, 0xF9, 0xC3, 0xEF, 0x7E, 0xFB, 0xFD, + 0xEF, 0x7E, 0xEF, 0x9B, 0x21, 0x25, 0x67, 0x4C, 0xD7, 0x0F, 0xBB, 0x7D, + 0xF7, 0xF2, 0xC5, 0x65, 0x4E, 0xF9, 0xEE, 0x7E, 0xBD, 0xD9, 0xEE, 0xF7, + 0x5D, 0xF7, 0xEE, 0xE6, 0x21, 0xE7, 0x92, 0x73, 0x11, 0x20, 0xDA, 0xA6, + 0xE1, 0xE4, 0x24, 0xC1, 0x50, 0x3A, 0x00, 0x20, 0x16, 0xA2, 0xE3, 0x86, + 0x71, 0xB2, 0x01, 0xE0, 0x0C, 0xC7, 0x27, 0x52, 0x05, 0x66, 0x5B, 0x70, + 0xE3, 0x0C, 0x00, 0x39, 0x97, 0x94, 0x12, 0x4A, 0x34, 0xC6, 0xB0, 0xF1, + 0xA9, 0x94, 0xB2, 0x10, 0xA1, 0x44, 0xAD, 0xB5, 0x35, 0xAE, 0x4C, 0xE2, + 0x08, 0xE2, 0xF6, 0xA2, 0x94, 0xA2, 0xB5, 0xCA, 0x39, 0xB3, 0xC9, 0x33, + 0xEB, 0x55, 0x52, 0xC9, 0x2C, 0x9B, 0x8F, 0x31, 0xE5, 0x5C, 0x80, 0x83, + 0x07, 0x73, 0xE9, 0x87, 0x61, 0xB3, 0xDD, 0x87, 0x10, 0x43, 0x88, 0x87, + 0xEB, 0x6A, 0x3A, 0x1A, 0x99, 0x63, 0x73, 0x28, 0xAF, 0x4C, 0xD7, 0x20, + 0x22, 0x52, 0x21, 0x66, 0x67, 0x0C, 0x00, 0x2C, 0x17, 0xED, 0x7C, 0x56, + 0xB3, 0xF8, 0x86, 0xD7, 0x1C, 0x0F, 0xAB, 0x7D, 0xCE, 0xD4, 0xD6, 0x15, + 0x77, 0x67, 0x77, 0xF7, 0x9B, 0xAE, 0x1F, 0x3F, 0x78, 0xEF, 0xD2, 0x5A, + 0x1D, 0x53, 0x9A, 0x35, 0x95, 0xF7, 0xD1, 0x68, 0xE5, 0xAC, 0x1E, 0xC7, + 0x60, 0x8D, 0xAE, 0x2F, 0xAC, 0x7C, 0x7E, 0x66, 0xAD, 0xDE, 0xED, 0xFB, + 0x1F, 0xFD, 0xF4, 0xE3, 0x9F, 0xFE, 0xF2, 0x93, 0x9B, 0xFB, 0x8D, 0x44, + 0xA9, 0x24, 0x0C, 0x63, 0x98, 0xB7, 0xCD, 0xAC, 0x6D, 0x66, 0xB3, 0x41, + 0x10, 0x10, 0x10, 0x00, 0xFE, 0xE6, 0x93, 0xCF, 0xFA, 0x7E, 0x64, 0x73, + 0xA8, 0x6E, 0xE8, 0x9D, 0x73, 0x6D, 0x53, 0x01, 0x80, 0x44, 0xF8, 0xC3, + 0xEF, 0x7F, 0x5B, 0x2A, 0x95, 0x53, 0x92, 0x07, 0xFF, 0x7B, 0xC1, 0xEA, + 0xDC, 0x5C, 0x8C, 0x9E, 0xD4, 0xF9, 0x5A, 0xAB, 0xC7, 0x76, 0x80, 0x63, + 0x7D, 0x53, 0xE6, 0x60, 0xCA, 0x94, 0xF2, 0x38, 0x7A, 0x6E, 0x3A, 0x95, + 0x52, 0xCE, 0x18, 0xAD, 0x15, 0x6F, 0x63, 0x73, 0x2E, 0x98, 0xC1, 0x59, + 0xC7, 0x63, 0xDA, 0xEA, 0xEA, 0x8B, 0xF6, 0xFD, 0xEF, 0xED, 0xF7, 0x7D, + 0x1F, 0xE8, 0xFE, 0xEA, 0x9D, 0xDB, 0xBF, 0xBB, 0x30, 0xEA, 0x0E, 0xDC, + 0x76, 0x18, 0x53, 0xCC, 0x65, 0x1C, 0x43, 0x0C, 0x5A, 0x22, 0x00, 0x96, + 0x42, 0x31, 0x26, 0x94, 0xB2, 0x1B, 0x47, 0xA9, 0x54, 0x4E, 0xD1, 0xFB, + 0x88, 0x12, 0x2A, 0x6B, 0x00, 0x48, 0xA1, 0xD4, 0x12, 0xA9, 0x50, 0xE5, + 0x1C, 0x33, 0xD4, 0xFB, 0xC1, 0x73, 0xFE, 0x1B, 0x5F, 0xA9, 0x3E, 0x04, + 0x63, 0x4C, 0xCA, 0x65, 0xF0, 0xC1, 0x1A, 0xC3, 0x37, 0xF3, 0xCD, 0xC3, + 0x3A, 0xE7, 0xD2, 0x6A, 0xA9, 0x24, 0xF8, 0x10, 0x81, 0x6D, 0x02, 0xF9, + 0x30, 0x44, 0x60, 0xFE, 0x9D, 0xD6, 0x8A, 0x9F, 0x5D, 0x22, 0x94, 0x02, + 0x4A, 0x61, 0x8C, 0x29, 0xC6, 0xA8, 0x94, 0x1A, 0xC7, 0x11, 0x27, 0x89, + 0x9C, 0x44, 0x94, 0x31, 0x65, 0x1E, 0x0C, 0xAD, 0x35, 0x0E, 0xAD, 0x92, + 0x0A, 0x11, 0x2D, 0x33, 0x5D, 0xA7, 0x45, 0x7E, 0x41, 0x14, 0xA5, 0x94, + 0x43, 0x5A, 0x32, 0x1B, 0x5E, 0x4A, 0x12, 0x22, 0x44, 0x96, 0xBE, 0xAB, + 0x63, 0x09, 0xA2, 0xC2, 0x51, 0x6C, 0x53, 0x43, 0xF1, 0x9F, 0x4F, 0x52, + 0xFC, 0x75, 0xA4, 0x35, 0x4E, 0x03, 0xE3, 0xA1, 0xA2, 0xD1, 0x61, 0x05, + 0x30, 0xAD, 0x01, 0xE8, 0x71, 0xC0, 0x14, 0x07, 0x59, 0xCF, 0xE8, 0x43, + 0x08, 0x59, 0x49, 0x4C, 0x4A, 0xE6, 0x58, 0xD8, 0x8B, 0x01, 0x01, 0x9C, + 0xB5, 0x75, 0xE3, 0x46, 0x1F, 0x86, 0x61, 0x04, 0xA9, 0x52, 0x4E, 0xFD, + 0x30, 0xB0, 0x89, 0x2E, 0x6F, 0xDD, 0x95, 0x94, 0x95, 0x75, 0x28, 0xA5, + 0xA0, 0xB2, 0xDB, 0x77, 0x42, 0x08, 0x1F, 0xC4, 0x5F, 0xFD, 0xF8, 0x63, + 0x29, 0x55, 0x8C, 0x91, 0xA8, 0x70, 0x07, 0x04, 0x80, 0xDA, 0xE8, 0x43, + 0xFD, 0x2D, 0x21, 0xE4, 0x94, 0x8B, 0x94, 0xC8, 0x8C, 0x35, 0x21, 0xC4, + 0x38, 0xFA, 0x42, 0x24, 0xA8, 0x14, 0x28, 0x29, 0xE7, 0xDD, 0xBE, 0xE3, + 0xDD, 0xF4, 0xA1, 0x00, 0x09, 0xAD, 0xD5, 0xEB, 0xAB, 0x9B, 0xBB, 0x87, + 0xF5, 0x3F, 0xF8, 0xD3, 0x3F, 0xF8, 0xE0, 0x83, 0x17, 0x39, 0x97, 0x14, + 0x91, 0x89, 0x29, 0x82, 0x4A, 0x66, 0x2F, 0xA6, 0x0C, 0x42, 0x08, 0xA5, + 0x9E, 0x26, 0x3F, 0x0A, 0x56, 0x95, 0x12, 0x51, 0x29, 0x93, 0x4B, 0x38, + 0xD7, 0x32, 0x89, 0x90, 0x62, 0x56, 0x52, 0x95, 0x52, 0xBC, 0x0F, 0x85, + 0x4A, 0x9C, 0x60, 0xEF, 0xD2, 0xF7, 0x3D, 0x00, 0xDE, 0xDC, 0xDE, 0x9D, + 0x9D, 0x9E, 0xEE, 0xB6, 0xBB, 0x87, 0x87, 0xB5, 0xB6, 0xBA, 0x4D, 0xF9, + 0xE5, 0xFB, 0xCF, 0xD6, 0xDB, 0xFD, 0x2F, 0x3E, 0xFE, 0xF4, 0xFE, 0x7E, + 0xCD, 0x89, 0xCF, 0xDD, 0x30, 0x22, 0xE2, 0x9F, 0xFC, 0xF1, 0x47, 0x7F, + 0xF6, 0x27, 0x7F, 0xC0, 0x4B, 0x83, 0x9F, 0xFD, 0xFC, 0xB7, 0x5F, 0x5E, + 0xDD, 0xBC, 0x78, 0x7E, 0x79, 0x73, 0xF3, 0x30, 0x9F, 0xB7, 0xB7, 0xB7, + 0xAB, 0xCF, 0x5F, 0x5D, 0x29, 0x2D, 0x67, 0xB3, 0xE6, 0xED, 0xF5, 0x9D, + 0x10, 0x14, 0x42, 0xB4, 0x56, 0x37, 0x4D, 0x9D, 0x4B, 0x29, 0xE2, 0xE8, + 0x2A, 0x5E, 0xCA, 0x94, 0xC3, 0x36, 0x69, 0x0F, 0x88, 0x0A, 0x4D, 0xB6, + 0xF5, 0x82, 0xFD, 0xC8, 0x58, 0xC1, 0xC2, 0x6B, 0xCA, 0x10, 0xE2, 0xE8, + 0x7D, 0x9E, 0xCC, 0x4B, 0x26, 0x13, 0x2A, 0xDE, 0x89, 0x3B, 0x65, 0x4B, + 0x2E, 0x79, 0x2C, 0x1C, 0xCA, 0xA7, 0x95, 0x1A, 0x86, 0xF1, 0xF8, 0x53, + 0xDC, 0x1A, 0x0F, 0xBD, 0x67, 0x1E, 0x35, 0x3F, 0x8F, 0x0F, 0x81, 0x59, + 0xCA, 0xCE, 0x5A, 0x46, 0x81, 0x78, 0x2F, 0x95, 0x72, 0x09, 0x21, 0x86, + 0x10, 0xD8, 0x7D, 0x23, 0xA5, 0xAC, 0x35, 0x81, 0x60, 0xFC, 0x81, 0x18, + 0xE1, 0xCD, 0x85, 0x84, 0x00, 0x25, 0x81, 0x2B, 0x03, 0x11, 0x29, 0x6B, + 0x75, 0x4E, 0x45, 0x08, 0x71, 0x71, 0xB6, 0xAC, 0x2B, 0x23, 0xA5, 0x6C, + 0x6A, 0x6B, 0xB5, 0x56, 0x5A, 0xBE, 0xFE, 0xF2, 0x76, 0xBD, 0xDD, 0x33, + 0xB0, 0x57, 0x39, 0x33, 0x6B, 0xEB, 0xB3, 0xD3, 0x39, 0x00, 0xDC, 0x3D, + 0x6C, 0x52, 0x2A, 0xEF, 0xAE, 0x1F, 0x8C, 0xD1, 0x46, 0x29, 0xAD, 0xA5, + 0x94, 0x72, 0xD7, 0x0D, 0xCE, 0xEA, 0xB6, 0xAE, 0x7E, 0xF9, 0x9B, 0xCF, + 0xFE, 0xDF, 0x1F, 0xFD, 0xFC, 0xDD, 0xF5, 0x83, 0x52, 0xBA, 0x72, 0x95, + 0x96, 0x32, 0xE5, 0xE4, 0x63, 0xE4, 0x24, 0x7A, 0x3F, 0xFA, 0x22, 0x68, + 0xD6, 0x34, 0x5D, 0x37, 0x0C, 0x63, 0x60, 0x4B, 0x30, 0x63, 0xB5, 0x73, + 0x96, 0x0A, 0xBD, 0xF7, 0xFC, 0xFC, 0xFF, 0xE7, 0xEA, 0xCD, 0x7E, 0x2D, + 0x3B, 0xB3, 0x3C, 0xA1, 0xF5, 0xCD, 0x7B, 0x3A, 0xC3, 0x1D, 0xE2, 0xC6, + 0xE0, 0x08, 0xDB, 0x69, 0x3B, 0xD3, 0x95, 0x43, 0x65, 0x0D, 0x74, 0x4B, + 0x8D, 0xD4, 0xA8, 0xA5, 0x16, 0x4F, 0x88, 0x46, 0xA8, 0x79, 0x42, 0xC0, + 0x13, 0xAF, 0xFC, 0x47, 0xFC, 0x07, 0x3C, 0x80, 0x90, 0x90, 0x90, 0x0A, + 0x10, 0x54, 0x95, 0xD4, 0x54, 0xD6, 0x9C, 0xE5, 0x1C, 0x9C, 0x4E, 0xCF, + 0x8E, 0xE9, 0xCE, 0x67, 0xD8, 0x7B, 0x7F, 0xF3, 0x5A, 0x3C, 0xAC, 0x73, + 0x6E, 0x66, 0x11, 0x4F, 0x96, 0xC3, 0x11, 0xBE, 0xF7, 0x9E, 0xBD, 0xBF, + 0x6F, 0xAD, 0xDF, 0xF8, 0xEC, 0xC9, 0xB9, 0x92, 0x2A, 0xE5, 0x7C, 0xB7, + 0xDD, 0xB9, 0xC6, 0xAD, 0x56, 0x8B, 0xFB, 0xCD, 0xAE, 0xE4, 0xE2, 0x7D, + 0xDA, 0xEF, 0xE7, 0xFB, 0xED, 0xEE, 0x7B, 0xEF, 0x3E, 0x6D, 0x9C, 0xE3, + 0xEB, 0xFC, 0x20, 0xE0, 0x43, 0x42, 0xA4, 0xB6, 0x75, 0x5C, 0x0A, 0x6D, + 0x8C, 0x4E, 0x29, 0x03, 0x88, 0x94, 0xB2, 0x10, 0x52, 0x18, 0x29, 0x85, + 0x38, 0x5B, 0x2F, 0xA4, 0x94, 0x5D, 0xDB, 0xC4, 0x5C, 0x4B, 0x40, 0xFE, + 0xA6, 0x84, 0x71, 0x97, 0xDF, 0x7C, 0x7A, 0xF1, 0x07, 0xFF, 0x22, 0x91, + 0x49, 0xDF, 0xFD, 0x72, 0x75, 0xF3, 0xB9, 0x08, 0x77, 0xC2, 0x74, 0xDF, + 0x7B, 0xFC, 0x7E, 0x32, 0x5D, 0xBB, 0x5C, 0x5F, 0xEF, 0xE3, 0xDB, 0xBB, + 0xE9, 0xE5, 0xED, 0x4C, 0x80, 0x5A, 0x49, 0xAC, 0x07, 0x6F, 0xF7, 0x38, + 0x7B, 0xAD, 0x54, 0x48, 0x51, 0x2A, 0x45, 0x48, 0xD6, 0x58, 0x00, 0x28, + 0x48, 0x39, 0x67, 0x6D, 0x14, 0x10, 0xCC, 0x21, 0x2C, 0x17, 0xBD, 0xE1, + 0x52, 0x71, 0xA8, 0xD3, 0x1C, 0x22, 0x6B, 0x20, 0x3A, 0xC7, 0x32, 0x94, + 0x5A, 0xAB, 0xB1, 0x87, 0x0C, 0x6F, 0x42, 0xE4, 0x14, 0x90, 0x9C, 0xB3, + 0x73, 0x8E, 0xE1, 0x4B, 0xD7, 0xD8, 0xB6, 0x71, 0xA5, 0x54, 0x20, 0x42, + 0x24, 0xAD, 0x55, 0xCA, 0x75, 0xB5, 0xE8, 0xFB, 0xB6, 0x99, 0x42, 0xF4, + 0x3E, 0xA6, 0x9C, 0xE8, 0xE0, 0x2D, 0xC7, 0x18, 0x53, 0xD3, 0x34, 0x48, + 0x18, 0xD3, 0x31, 0xB2, 0xCA, 0x5A, 0x21, 0x44, 0xDB, 0x36, 0x43, 0xDF, + 0x5A, 0xAB, 0x73, 0xAD, 0x4A, 0xC8, 0x12, 0x51, 0xB1, 0xC6, 0x85, 0x48, + 0x6A, 0xAD, 0x0E, 0x95, 0x19, 0x04, 0x00, 0xA4, 0x80, 0x29, 0x6E, 0xA6, + 0xD5, 0xE1, 0x61, 0x68, 0x22, 0xE0, 0xB1, 0xF4, 0x81, 0x31, 0xFC, 0xFD, + 0x73, 0xEA, 0x77, 0xF7, 0xF5, 0x11, 0xE3, 0x87, 0x63, 0x7F, 0xEA, 0x3F, + 0xFB, 0xDD, 0x63, 0x0A, 0x3B, 0x1F, 0x73, 0x07, 0xF0, 0x98, 0x87, 0x40, + 0x38, 0xFC, 0x19, 0x22, 0x92, 0xC7, 0x23, 0xD2, 0x19, 0xB3, 0xE8, 0xBA, + 0x1C, 0x4B, 0x29, 0xBC, 0xF4, 0x15, 0xB6, 0x1F, 0x29, 0xA5, 0x32, 0x65, + 0x67, 0x1C, 0xC7, 0x46, 0x96, 0x18, 0x01, 0x80, 0x0E, 0xEF, 0x9B, 0x6C, + 0x9A, 0xA6, 0x71, 0xB6, 0x54, 0xE4, 0xAD, 0x44, 0x11, 0x71, 0x1D, 0x72, + 0x29, 0xC5, 0x18, 0xF3, 0xC0, 0x1E, 0x10, 0xA2, 0xB3, 0xB6, 0xD4, 0x92, + 0x52, 0xCE, 0xF9, 0x10, 0xC7, 0x85, 0x88, 0xCC, 0x59, 0xC7, 0x90, 0x58, + 0xEE, 0x1F, 0x53, 0x2A, 0xB5, 0x3A, 0x63, 0x01, 0xE8, 0xFA, 0xE6, 0x0E, + 0x88, 0x80, 0xC0, 0x59, 0xB3, 0x5C, 0xF6, 0x5D, 0xD7, 0x1C, 0xE0, 0x7C, + 0x04, 0x44, 0xA4, 0x4A, 0x52, 0x48, 0x3F, 0x7B, 0x22, 0x72, 0xCE, 0x29, + 0xA5, 0x38, 0x99, 0xE7, 0xB8, 0x86, 0xE3, 0x66, 0xBB, 0xDF, 0x4F, 0x33, + 0x21, 0x9D, 0x9E, 0xAC, 0x8C, 0x56, 0xDA, 0x18, 0x6D, 0x20, 0x86, 0xA4, + 0x94, 0x8A, 0x3E, 0xDD, 0x6F, 0x76, 0x58, 0x51, 0x69, 0xB5, 0x58, 0x2C, + 0x62, 0xCC, 0xFD, 0x30, 0x90, 0x10, 0x4A, 0x9B, 0x1F, 0xFF, 0xE4, 0x63, + 0x6D, 0xF4, 0xF3, 0x67, 0x17, 0x9F, 0x7F, 0xF9, 0xDD, 0xCF, 0xFE, 0xF6, + 0x17, 0xE7, 0x67, 0x27, 0xEB, 0xF5, 0x72, 0xB7, 0x9B, 0xBE, 0xF8, 0xEA, + 0xBB, 0x77, 0x9E, 0x5D, 0xFC, 0xEB, 0x7F, 0xF5, 0xC7, 0xEF, 0xBD, 0xF7, + 0x14, 0x2B, 0x0A, 0x10, 0x57, 0xD7, 0xF7, 0x9F, 0xFC, 0xF2, 0xB7, 0x9B, + 0xED, 0xBE, 0x22, 0x3E, 0x7B, 0xF2, 0x68, 0x9E, 0xFD, 0xD5, 0xD5, 0x8D, + 0x0F, 0x71, 0xBD, 0x5E, 0x7D, 0xFB, 0xF6, 0x75, 0x2D, 0x55, 0x4A, 0x79, + 0x7E, 0xB6, 0x5E, 0xAD, 0x16, 0x9C, 0x49, 0xC7, 0x80, 0x9D, 0x16, 0x92, + 0x40, 0x54, 0x24, 0x96, 0xB9, 0x0A, 0x80, 0xC3, 0xBE, 0x59, 0x0A, 0xD3, + 0xE8, 0x42, 0x80, 0x52, 0x4A, 0x2B, 0x25, 0x80, 0x52, 0xAE, 0xA5, 0xD6, + 0x5A, 0x6A, 0x2E, 0x78, 0x30, 0x2A, 0x1C, 0x32, 0xCD, 0x0F, 0x46, 0x11, + 0xAD, 0x75, 0x81, 0x2A, 0x84, 0xC8, 0xB9, 0xA4, 0x9C, 0xB7, 0x39, 0xB5, + 0x6D, 0x6B, 0xAD, 0x8D, 0x21, 0xCD, 0x73, 0x30, 0x46, 0x39, 0xE7, 0x90, + 0x10, 0x10, 0x98, 0x07, 0x46, 0x44, 0xE7, 0x6C, 0xA9, 0x25, 0xE7, 0x42, + 0x00, 0xC6, 0x18, 0x63, 0x0C, 0x00, 0xB7, 0xFF, 0x11, 0xCF, 0xE0, 0x6D, + 0xD3, 0x20, 0x52, 0xF0, 0x91, 0x17, 0x0B, 0x01, 0x54, 0x6B, 0xE1, 0x27, + 0x36, 0xE7, 0xE2, 0x9C, 0x23, 0xA5, 0x98, 0x31, 0x21, 0x02, 0x9D, 0x72, + 0x55, 0x52, 0x71, 0x40, 0xCD, 0xB3, 0x27, 0x67, 0x2C, 0x28, 0x03, 0x01, + 0xD6, 0xE8, 0x1F, 0x7D, 0xFC, 0xFE, 0x97, 0xDF, 0xBC, 0xBE, 0xBC, 0xDA, + 0xCC, 0x3E, 0x5E, 0x5E, 0xC9, 0xA1, 0x6F, 0x99, 0x4E, 0x8F, 0x29, 0x6B, + 0xA5, 0x42, 0x48, 0x52, 0x29, 0x80, 0xEA, 0x43, 0xDA, 0x6C, 0xC7, 0xB6, + 0xB1, 0xE3, 0x38, 0xFF, 0xD9, 0x9F, 0xFF, 0xCD, 0xD7, 0xDF, 0x5D, 0x82, + 0x94, 0xCB, 0xE5, 0x82, 0x37, 0x5B, 0x29, 0xC5, 0xC9, 0x62, 0xB1, 0x1C, + 0x06, 0x25, 0x65, 0x8C, 0xF9, 0x9D, 0xA7, 0x8F, 0xEF, 0xB7, 0x3B, 0x00, + 0x98, 0x3D, 0xD7, 0xA0, 0xF6, 0x37, 0x77, 0x9B, 0xB6, 0x6B, 0x72, 0xAE, + 0xC1, 0x07, 0xDE, 0xA7, 0xD6, 0xAB, 0x85, 0x31, 0xBA, 0x22, 0x0E, 0x43, + 0xEF, 0xAC, 0x09, 0x31, 0x4D, 0x3E, 0x5C, 0xDF, 0xDE, 0x97, 0x9C, 0x67, + 0x1F, 0x4E, 0xD6, 0x8B, 0xE5, 0x62, 0xB0, 0xD6, 0x08, 0x25, 0xB5, 0x14, + 0x4A, 0x2A, 0x24, 0x72, 0x00, 0xFC, 0x28, 0x0B, 0x29, 0xF8, 0x93, 0x13, + 0x42, 0xB0, 0x0E, 0x88, 0x10, 0x62, 0x4A, 0x5A, 0x2B, 0xA5, 0x75, 0x25, + 0xCA, 0xA5, 0x3A, 0xE7, 0xFA, 0xBE, 0x17, 0x52, 0x48, 0xAD, 0xEF, 0x37, + 0x37, 0x6F, 0xFE, 0xEE, 0xCF, 0x5E, 0x3C, 0x7F, 0x71, 0xFF, 0xE5, 0x5F, + 0xDD, 0xCF, 0x71, 0x58, 0xAD, 0x3B, 0xC0, 0xB3, 0x7A, 0xBB, 0x12, 0xDB, + 0x15, 0x84, 0x17, 0xE7, 0x6D, 0x3D, 0xD3, 0x9F, 0x2C, 0x97, 0x7F, 0xF7, + 0xCD, 0x1E, 0x11, 0xB0, 0x56, 0x21, 0xA5, 0x20, 0x28, 0xB5, 0x1E, 0xFB, + 0xE1, 0x14, 0x83, 0x17, 0x4A, 0x29, 0x1F, 0x23, 0x11, 0x36, 0xDA, 0xC5, + 0x98, 0x8C, 0xD6, 0x0F, 0x49, 0x5D, 0x0F, 0xB4, 0xA0, 0x73, 0x6E, 0x0E, + 0x39, 0xE7, 0xDA, 0x77, 0x5D, 0x29, 0x79, 0xB3, 0x9B, 0xAC, 0x31, 0x48, + 0x90, 0x73, 0x75, 0xCE, 0x68, 0xAD, 0x77, 0x39, 0xA7, 0x94, 0x38, 0x3D, + 0x91, 0x88, 0xAC, 0x31, 0xAB, 0xA1, 0xDB, 0xEE, 0x46, 0x63, 0x8C, 0xB1, + 0x83, 0x0F, 0x51, 0x6B, 0x95, 0x6B, 0x6D, 0x9C, 0x23, 0xA0, 0x90, 0x78, + 0x9A, 0x20, 0xA5, 0x35, 0x2F, 0x77, 0x29, 0xA6, 0xAA, 0x44, 0xDF, 0x34, + 0x52, 0x08, 0x86, 0x99, 0xDB, 0xC6, 0x4A, 0x21, 0x6A, 0xA5, 0x9C, 0x53, + 0x45, 0x54, 0x52, 0x28, 0x29, 0x6B, 0xC5, 0xAE, 0x71, 0xD6, 0xE8, 0x87, + 0x03, 0xE8, 0x30, 0x4B, 0x01, 0x3C, 0x74, 0x59, 0x1E, 0xE8, 0xAA, 0x82, + 0x0F, 0x11, 0xF2, 0xF4, 0xCF, 0xB5, 0x17, 0xC7, 0xB7, 0xF4, 0xF0, 0xEF, + 0xFF, 0xD9, 0x99, 0x46, 0x0F, 0x75, 0x39, 0x87, 0x8D, 0xE0, 0x88, 0xC8, + 0x1E, 0x36, 0x53, 0x79, 0x88, 0xA8, 0xCE, 0xB5, 0x60, 0xCC, 0xB9, 0x56, + 0x4C, 0x91, 0x85, 0x72, 0xF4, 0x70, 0x02, 0x76, 0xAD, 0x2B, 0xB5, 0x23, + 0xA0, 0xED, 0x6E, 0xAC, 0xB5, 0x96, 0x9C, 0x8F, 0x03, 0x0E, 0x0A, 0x21, + 0x52, 0xCE, 0xCE, 0xDA, 0xD9, 0x7B, 0xA6, 0x14, 0x8D, 0x55, 0x4A, 0x69, + 0x6B, 0xB4, 0x10, 0x44, 0x80, 0x42, 0x88, 0xB6, 0x6D, 0x17, 0x4A, 0x11, + 0x00, 0x01, 0x95, 0x5C, 0x52, 0x29, 0x5A, 0xEB, 0x94, 0x92, 0xAA, 0x85, + 0x08, 0x72, 0xCE, 0x40, 0x90, 0x4B, 0xE1, 0x78, 0x4B, 0x1E, 0xF9, 0x2B, + 0x56, 0x40, 0xC1, 0xC5, 0x28, 0x88, 0x75, 0x0E, 0x51, 0x08, 0x30, 0x4A, + 0x09, 0x29, 0x87, 0xBE, 0xF7, 0x31, 0xFF, 0xC5, 0x5F, 0xFF, 0xD3, 0xE9, + 0x72, 0xF8, 0xE9, 0x8F, 0x3E, 0x1C, 0xFA, 0xB6, 0x02, 0xE4, 0x5C, 0x0A, + 0x22, 0xF7, 0x2D, 0xC4, 0x90, 0xF0, 0x30, 0xDA, 0x21, 0x03, 0x05, 0xF4, + 0x70, 0x38, 0x0A, 0xD1, 0x75, 0x6D, 0xAD, 0xF5, 0xE6, 0x6E, 0xF3, 0x9B, + 0xCF, 0x37, 0x5D, 0xDB, 0x18, 0x63, 0x80, 0xA8, 0x6D, 0xDD, 0xD0, 0x75, + 0x75, 0xF2, 0x5D, 0xD7, 0xF7, 0x5D, 0x63, 0x8C, 0xA9, 0xB5, 0x2E, 0x17, + 0xC3, 0xD9, 0xF9, 0xC9, 0x6E, 0x3F, 0x12, 0x80, 0x73, 0xEE, 0xC9, 0xC5, + 0x59, 0xD7, 0xB5, 0xEF, 0xBC, 0x73, 0xF1, 0x5F, 0x3E, 0xFD, 0xB7, 0x27, + 0xAB, 0x85, 0x35, 0xDA, 0x87, 0xF8, 0xFA, 0xCD, 0x55, 0x29, 0xF5, 0xE6, + 0x6E, 0xCB, 0xFF, 0xA3, 0x5F, 0xFD, 0xE6, 0xCB, 0x71, 0x9C, 0x9E, 0xBF, + 0xF3, 0xE4, 0x9D, 0xA7, 0x17, 0x25, 0xA7, 0xEB, 0x9B, 0x5B, 0x56, 0x2C, + 0x19, 0xAD, 0xEF, 0xEE, 0xEE, 0x85, 0x94, 0x7D, 0xDF, 0xAE, 0x56, 0x0B, + 0x02, 0x78, 0xF9, 0xEA, 0xED, 0xFA, 0x64, 0xD9, 0xC9, 0x96, 0xD5, 0xE6, + 0x45, 0x1E, 0x2A, 0x11, 0x8E, 0xBE, 0xEF, 0x07, 0x0F, 0x90, 0x7C, 0xF8, + 0xA4, 0x78, 0x4A, 0x62, 0xE0, 0x9F, 0x6F, 0x29, 0xE6, 0x81, 0xB4, 0xD6, + 0x3C, 0x09, 0x92, 0x10, 0x31, 0x24, 0x22, 0x62, 0x13, 0xD8, 0x61, 0x4C, + 0xAB, 0xC8, 0x28, 0x46, 0xF0, 0x11, 0x00, 0x4A, 0x2E, 0xDC, 0xBC, 0x71, + 0x4C, 0x64, 0xE1, 0x24, 0x6D, 0x51, 0x91, 0xAC, 0xB5, 0xD3, 0x1C, 0x72, + 0x19, 0xF9, 0xD2, 0xE5, 0x88, 0xA1, 0x94, 0x32, 0xB3, 0x10, 0xB9, 0x94, + 0xD3, 0x93, 0x75, 0xC9, 0x15, 0x91, 0x2A, 0x61, 0x8D, 0x87, 0x43, 0x8B, + 0xBF, 0x30, 0x22, 0x92, 0xB2, 0x93, 0x52, 0xE6, 0x9C, 0x63, 0x8C, 0xEA, + 0x3F, 0xFE, 0x37, 0xFF, 0x05, 0x10, 0x49, 0xA9, 0x2E, 0x6F, 0x36, 0x5D, + 0xEB, 0xBA, 0xAE, 0x49, 0xB9, 0xE4, 0x8C, 0xEC, 0x24, 0x70, 0x8D, 0xE1, + 0x6E, 0x08, 0xE7, 0x4C, 0xE3, 0xEC, 0xD7, 0x2F, 0x2F, 0xA7, 0x29, 0x9C, + 0xAC, 0x16, 0x27, 0xAB, 0xC5, 0x30, 0x74, 0xF7, 0xDB, 0x91, 0xEB, 0xC2, + 0x94, 0x14, 0xDF, 0xBE, 0xBE, 0xFC, 0xF9, 0xAF, 0xBF, 0xBC, 0xDF, 0x8E, + 0xD6, 0x3A, 0xA6, 0x99, 0x09, 0xA8, 0x14, 0x14, 0x40, 0xCF, 0x2F, 0xCE, + 0x5B, 0x67, 0x8C, 0xD1, 0xEF, 0x3C, 0x7B, 0x84, 0x48, 0x31, 0x95, 0x71, + 0x9E, 0xA7, 0x79, 0x8E, 0x29, 0x23, 0x41, 0x4A, 0x79, 0x1C, 0xE7, 0xED, + 0x66, 0x9B, 0x72, 0xE9, 0x9A, 0xA6, 0xB1, 0x01, 0x15, 0x09, 0x00, 0x00, + 0x20, 0x00, 0x49, 0x44, 0x41, 0x54, 0xEF, 0xDA, 0x93, 0xD3, 0xE5, 0xC9, + 0xC9, 0xA2, 0xEF, 0x5A, 0x6B, 0xF4, 0xED, 0xFD, 0xF6, 0xEA, 0xFA, 0xEE, + 0xFA, 0xE6, 0xEE, 0xEA, 0xE6, 0xB6, 0x6D, 0x9A, 0xF3, 0xB3, 0x93, 0xF3, + 0xB3, 0x93, 0xE5, 0xB2, 0x67, 0x16, 0xD5, 0x71, 0x81, 0xA8, 0x10, 0x42, + 0x81, 0x10, 0x52, 0x29, 0x29, 0x95, 0x22, 0xE4, 0x0C, 0x0F, 0x41, 0x04, + 0xB3, 0x0F, 0xE3, 0xE4, 0xF7, 0xE3, 0x3C, 0xCE, 0xDE, 0x58, 0xC3, 0xDD, + 0x68, 0xFD, 0xD0, 0x53, 0x09, 0xB7, 0x9B, 0xAD, 0x94, 0xD2, 0x58, 0x7B, + 0xF7, 0xE6, 0xEB, 0xDB, 0xCB, 0x6F, 0xAF, 0x27, 0x1F, 0x51, 0x54, 0x82, + 0x39, 0x15, 0x61, 0xDC, 0xFD, 0xE8, 0xBF, 0xBB, 0xBC, 0x7D, 0x73, 0x79, + 0xB3, 0xDB, 0xEF, 0x9E, 0x2F, 0xE5, 0xB3, 0xC1, 0x8C, 0xC5, 0x14, 0xA9, + 0x4B, 0xAD, 0x5A, 0x33, 0x90, 0x51, 0xDA, 0xAE, 0x6D, 0xAC, 0xE9, 0x5A, + 0x87, 0x88, 0x52, 0x82, 0xD6, 0x6A, 0xE8, 0x3B, 0x2C, 0x95, 0x00, 0xA4, + 0x92, 0x15, 0x8F, 0x1A, 0x31, 0x29, 0x62, 0x2A, 0xCE, 0xDA, 0xA6, 0x71, + 0xA5, 0xA2, 0x10, 0x42, 0x2B, 0x99, 0x6B, 0xF5, 0x21, 0xF1, 0x4B, 0xCB, + 0xC7, 0x56, 0x45, 0x8C, 0xA9, 0x70, 0x9B, 0x89, 0xB5, 0x5A, 0x6B, 0x3D, + 0xCF, 0x33, 0x56, 0x4A, 0x39, 0x37, 0xCE, 0x71, 0x1C, 0x2E, 0xD3, 0xD2, + 0xC4, 0x05, 0x54, 0x42, 0xB6, 0xAD, 0x6B, 0xDB, 0x86, 0x9B, 0xED, 0x94, + 0x80, 0xC6, 0x9A, 0xAE, 0x6D, 0x86, 0xBE, 0x73, 0xAE, 0xB1, 0xD6, 0x34, + 0x8D, 0x95, 0x12, 0x72, 0xA9, 0xB5, 0x20, 0x63, 0x6A, 0x3C, 0x58, 0xB1, + 0xA6, 0x8C, 0x00, 0x58, 0xC3, 0xAC, 0xB5, 0x96, 0x4A, 0x28, 0x25, 0x8D, + 0x56, 0x52, 0x88, 0x7A, 0xAC, 0x6B, 0x64, 0x2E, 0xEB, 0x98, 0xEA, 0xF5, + 0x3B, 0x79, 0x24, 0x1C, 0xE1, 0xFC, 0x87, 0xA5, 0xF2, 0x61, 0x46, 0x7B, + 0xD0, 0x5C, 0xE3, 0x51, 0xE4, 0xFF, 0x70, 0x84, 0xFD, 0xFE, 0xD6, 0xC9, + 0xBF, 0x6A, 0x29, 0xB9, 0x54, 0x06, 0xDA, 0x19, 0x66, 0x3A, 0x80, 0x20, + 0x48, 0xB9, 0xE6, 0x94, 0x72, 0x88, 0xB9, 0x1C, 0x91, 0xC1, 0x18, 0x23, + 0x01, 0xA4, 0x52, 0xD8, 0x2E, 0x86, 0x88, 0x7C, 0x3D, 0x94, 0x5A, 0x39, + 0x8F, 0x64, 0xD1, 0x37, 0xAD, 0xD3, 0x43, 0xD7, 0x0C, 0x7D, 0xAB, 0x94, + 0xAC, 0x44, 0xA5, 0x54, 0x44, 0xE4, 0xC8, 0x07, 0x36, 0xB9, 0xF0, 0x6B, + 0x50, 0x72, 0x49, 0xA9, 0x64, 0x8E, 0x60, 0x42, 0x4C, 0x29, 0xF1, 0xDB, + 0x1B, 0x53, 0xE6, 0xEF, 0x81, 0x53, 0x6A, 0x2B, 0x91, 0x56, 0x1A, 0x09, + 0x4A, 0x2D, 0x7D, 0xD7, 0x78, 0x1F, 0x2F, 0x6F, 0xEF, 0x2F, 0x6F, 0xEE, + 0x5E, 0xBD, 0xBE, 0x26, 0xA2, 0xF3, 0xD3, 0x15, 0x21, 0x85, 0x39, 0xC6, + 0x94, 0x4B, 0x41, 0x8E, 0xA2, 0x07, 0x80, 0x87, 0x9A, 0x30, 0x3A, 0xC6, + 0x3D, 0x23, 0x62, 0xD7, 0x36, 0x7C, 0xBC, 0xEF, 0x76, 0xD3, 0x3C, 0xFB, + 0xED, 0x6E, 0x3F, 0x4E, 0x9E, 0x39, 0x3E, 0xAD, 0x75, 0xD3, 0xB8, 0x71, + 0x0E, 0x21, 0x44, 0xBE, 0x18, 0x63, 0x4A, 0x6D, 0xEB, 0x4E, 0xD6, 0xAB, + 0x93, 0xF5, 0xB2, 0x6D, 0x5D, 0xAD, 0xB5, 0xEF, 0x9A, 0xD5, 0x62, 0x40, + 0xA2, 0x6F, 0x5F, 0xBE, 0xBD, 0xBC, 0xBA, 0x4D, 0x29, 0xEF, 0xF7, 0xB3, + 0xB5, 0x36, 0xA5, 0xBC, 0xD9, 0xED, 0x39, 0x8D, 0xFA, 0x64, 0xBD, 0xB8, + 0xBE, 0xBE, 0xB9, 0xBA, 0xD9, 0xEC, 0xA7, 0x20, 0x40, 0x74, 0x5D, 0xA3, + 0x94, 0xAA, 0x48, 0x52, 0xC9, 0x77, 0x9E, 0x3D, 0xDE, 0x6C, 0xF6, 0x97, + 0x57, 0xB7, 0xC3, 0xD0, 0xAF, 0x16, 0x0B, 0xAD, 0x15, 0x07, 0xF7, 0x23, + 0x1D, 0xB8, 0x1A, 0x3E, 0x1C, 0x1E, 0x24, 0xBD, 0x47, 0xE1, 0x21, 0x83, + 0x1F, 0xA2, 0x1E, 0x57, 0x3E, 0x2E, 0xDC, 0xE0, 0x90, 0x15, 0xAD, 0x8F, + 0xCC, 0x06, 0x08, 0xCE, 0x8F, 0x4C, 0x29, 0xFB, 0x90, 0xC6, 0xE9, 0x10, + 0x81, 0x29, 0xA4, 0xC8, 0xA9, 0xE4, 0x52, 0xB8, 0x6B, 0x8E, 0xAB, 0x13, + 0x8D, 0xD6, 0x47, 0x4B, 0xA7, 0x90, 0x52, 0xA6, 0xE3, 0xF6, 0x2D, 0x95, + 0x5C, 0x0C, 0xC3, 0x41, 0x9B, 0x72, 0x78, 0x90, 0x04, 0x67, 0x37, 0x01, + 0x08, 0x1E, 0x4D, 0xDA, 0xCE, 0x11, 0xB0, 0x85, 0x13, 0x52, 0xCA, 0x5C, + 0x28, 0xC3, 0xD7, 0x26, 0xCF, 0xD9, 0x9A, 0x29, 0xD6, 0x4A, 0x18, 0x53, + 0xF9, 0xD9, 0x3F, 0xFE, 0xF6, 0xF2, 0x66, 0xEB, 0x9C, 0x79, 0xFB, 0xF6, + 0x0E, 0x80, 0x2E, 0xCE, 0xD7, 0xD6, 0xE8, 0xE5, 0xB2, 0x7B, 0xF1, 0xCE, + 0x23, 0x29, 0x44, 0x4A, 0xE5, 0x8F, 0x7E, 0xFC, 0xA1, 0x0F, 0xE9, 0x64, + 0x35, 0x28, 0x25, 0xEE, 0xEE, 0xF7, 0x9C, 0x18, 0xE1, 0x63, 0xBC, 0xBA, + 0xBE, 0xDB, 0x4F, 0x9E, 0x5D, 0x84, 0x44, 0x85, 0x21, 0x83, 0x79, 0xF6, + 0x5D, 0xE3, 0x9E, 0x9C, 0x9F, 0xA6, 0x9C, 0x17, 0x43, 0x7B, 0x7E, 0xB6, + 0xF6, 0x3E, 0x8C, 0xF3, 0x7C, 0xBF, 0xD9, 0xBE, 0xBD, 0xBE, 0xED, 0xDB, + 0x46, 0x09, 0x79, 0x7B, 0x7B, 0xA7, 0x95, 0xAA, 0xB5, 0x56, 0xA2, 0x5A, + 0xEA, 0xEB, 0xCB, 0x1B, 0xE7, 0xEC, 0xC5, 0xC5, 0xD9, 0x6A, 0x31, 0x48, + 0x29, 0x37, 0xDB, 0x11, 0x11, 0x9F, 0x3F, 0x7D, 0xAC, 0xB5, 0xCA, 0xA5, + 0x9C, 0xAC, 0x96, 0x4D, 0x6B, 0x4F, 0x4F, 0x96, 0xC6, 0x1A, 0xEE, 0x31, + 0x53, 0x5A, 0x09, 0x21, 0x2A, 0x91, 0x40, 0xA1, 0xA4, 0x44, 0xA4, 0x9A, + 0x0B, 0x1E, 0x4C, 0xCB, 0x62, 0xF2, 0xFE, 0xF2, 0xFA, 0x4E, 0x29, 0xE5, + 0x43, 0x88, 0x29, 0x77, 0x7D, 0x77, 0xB6, 0x5E, 0x5A, 0xA3, 0x49, 0x8A, + 0xF5, 0xF9, 0xC5, 0xEA, 0xF4, 0x7C, 0xDF, 0xF4, 0xE0, 0x77, 0x79, 0xDA, + 0xDD, 0xFB, 0x9C, 0x62, 0x50, 0x5A, 0xF7, 0xFD, 0x20, 0xA5, 0x7A, 0xF5, + 0xF6, 0x6A, 0x31, 0x74, 0xC6, 0x98, 0x90, 0x52, 0x49, 0x09, 0x94, 0x6B, + 0x14, 0x7D, 0xD4, 0xF6, 0x9F, 0xEA, 0x47, 0xA3, 0x0F, 0x46, 0x49, 0x29, + 0x85, 0x52, 0x52, 0x00, 0xAD, 0x86, 0x1E, 0x09, 0x41, 0x90, 0x14, 0x72, + 0xD1, 0x77, 0x07, 0x89, 0x20, 0x70, 0x35, 0xB7, 0xE6, 0xD6, 0x8C, 0x5C, + 0x6A, 0x41, 0x6C, 0xB4, 0xD2, 0x4A, 0x12, 0x62, 0xA9, 0x34, 0xCE, 0xA1, + 0x94, 0xC2, 0xD0, 0x09, 0x11, 0xE9, 0x43, 0x4F, 0x17, 0xB4, 0x8D, 0xB3, + 0x56, 0xDB, 0xA3, 0x51, 0x19, 0x89, 0x50, 0x90, 0x36, 0x76, 0xB3, 0x1F, + 0xC5, 0x31, 0x3E, 0x61, 0x39, 0xF4, 0x20, 0xA0, 0x54, 0xEC, 0xBA, 0xC6, + 0x6A, 0xD5, 0xB7, 0x6D, 0x2E, 0x05, 0x88, 0x58, 0xC2, 0xCA, 0x8F, 0x1A, + 0x6B, 0x7C, 0x4A, 0xA9, 0x4A, 0x89, 0x5C, 0x0A, 0x21, 0xD9, 0x03, 0xF6, + 0xCC, 0x69, 0x3F, 0xE6, 0xE1, 0xC5, 0x63, 0x98, 0x44, 0x48, 0x90, 0x52, + 0xB2, 0x7A, 0xB6, 0x20, 0xE7, 0x3C, 0x02, 0x07, 0x5D, 0xC8, 0xCA, 0xC5, + 0x39, 0x15, 0x8E, 0x03, 0xD8, 0xC3, 0x75, 0x8D, 0xBF, 0xF3, 0xEE, 0x1C, + 0x07, 0x29, 0x22, 0xE4, 0xD2, 0x72, 0x02, 0x01, 0x02, 0x7E, 0xCF, 0x9A, + 0xF7, 0x70, 0xD8, 0x3D, 0x9C, 0x65, 0x5A, 0x6B, 0x29, 0x92, 0x20, 0x90, + 0x42, 0x60, 0x45, 0x21, 0x65, 0x15, 0x07, 0x93, 0x5D, 0xA9, 0xC8, 0xCD, + 0x23, 0x5C, 0x4A, 0x06, 0x40, 0xA5, 0x22, 0x15, 0xAC, 0x58, 0x95, 0x94, + 0x39, 0xE7, 0x0C, 0x82, 0xC7, 0x28, 0x01, 0xD0, 0x1A, 0x33, 0xB4, 0xEE, + 0x74, 0xD9, 0x85, 0x94, 0xAE, 0xEF, 0xB6, 0xA5, 0xA0, 0x54, 0x42, 0x2B, + 0x4D, 0x44, 0x58, 0x2B, 0x11, 0x31, 0x6B, 0x39, 0xCF, 0x5E, 0x2B, 0x45, + 0x88, 0xC6, 0x1A, 0x21, 0x44, 0xCE, 0x35, 0xE5, 0x2C, 0x85, 0xC8, 0x15, + 0x79, 0xAB, 0x92, 0x42, 0xB2, 0xDB, 0x11, 0x00, 0x48, 0x4A, 0x29, 0x24, + 0xDF, 0x19, 0x25, 0x17, 0x2C, 0xC8, 0xA1, 0x1A, 0xA5, 0xD6, 0x31, 0xC4, + 0xFF, 0xF7, 0x6F, 0x7F, 0x19, 0x53, 0xFE, 0x93, 0x1F, 0x7F, 0x5F, 0x6B, + 0x75, 0x73, 0xB7, 0x2D, 0x88, 0x4F, 0x9E, 0x5C, 0x74, 0x43, 0x57, 0x2B, + 0xC6, 0x90, 0x4B, 0xA9, 0xC6, 0x28, 0x4E, 0xD2, 0x15, 0x42, 0x5A, 0x6B, + 0x73, 0x29, 0x46, 0xEB, 0x45, 0xDF, 0xAD, 0x96, 0x03, 0x03, 0xF9, 0xBC, + 0x6C, 0x22, 0x91, 0xB5, 0xE6, 0x64, 0xB5, 0x54, 0x52, 0x12, 0xD0, 0x7E, + 0x9A, 0x41, 0xC0, 0xC5, 0xF9, 0x69, 0xD3, 0x58, 0x29, 0x25, 0xA7, 0x0A, + 0x4A, 0x29, 0x85, 0x90, 0x9F, 0x7E, 0xF6, 0xD5, 0x57, 0x5F, 0xBF, 0xDA, + 0xED, 0xE7, 0xB6, 0x6D, 0xDE, 0xBC, 0xB9, 0x52, 0x5A, 0xF6, 0x5D, 0x7B, + 0xB2, 0x5E, 0x22, 0x62, 0xCA, 0xA5, 0xEF, 0x1A, 0x1F, 0xE2, 0xB3, 0x67, + 0x8F, 0x87, 0xC5, 0xC2, 0xCF, 0xA1, 0x20, 0xEE, 0x47, 0x8F, 0x84, 0xCE, + 0x9A, 0xA7, 0x8F, 0x1F, 0xBD, 0x7E, 0x73, 0x1D, 0x43, 0x32, 0x5A, 0x87, + 0x90, 0x76, 0xE3, 0x64, 0x82, 0xEE, 0xBB, 0xA6, 0x69, 0xDC, 0x03, 0x3B, + 0xC1, 0x37, 0xD7, 0xC3, 0xC7, 0x44, 0x74, 0x50, 0x45, 0xB0, 0xAA, 0x9F, + 0xE5, 0xE8, 0x29, 0x15, 0x0E, 0x26, 0xD0, 0x5A, 0xB3, 0xC8, 0x9E, 0xFF, + 0x88, 0x31, 0xCA, 0x5A, 0xB3, 0xDB, 0x4F, 0xB9, 0x54, 0x56, 0x99, 0xB1, + 0x2C, 0x56, 0x2A, 0x55, 0x72, 0xE1, 0x93, 0x4E, 0x69, 0xD5, 0x36, 0xCE, + 0x1C, 0x2A, 0x5C, 0x8B, 0x10, 0x50, 0x11, 0x9D, 0xB5, 0x87, 0x9E, 0x0A, + 0xE7, 0x34, 0x7F, 0x25, 0x48, 0x24, 0xA8, 0x56, 0x94, 0x52, 0x75, 0xAD, + 0xF6, 0x73, 0xE0, 0x93, 0x91, 0x88, 0x8C, 0x56, 0xDC, 0x8B, 0x28, 0xA5, + 0x2A, 0xC7, 0x53, 0x0C, 0x35, 0x98, 0x43, 0x74, 0xA0, 0xB0, 0xD6, 0x6A, + 0x21, 0xE4, 0x30, 0x74, 0x9B, 0xFD, 0x44, 0x00, 0x42, 0xC8, 0xE5, 0xA2, + 0x97, 0x52, 0x74, 0x9D, 0xBB, 0xB9, 0xDD, 0xFD, 0xF6, 0xCB, 0xD7, 0xEF, + 0xBF, 0xFB, 0xF8, 0xE4, 0x64, 0xD1, 0xB6, 0x4E, 0x09, 0xB9, 0x5A, 0xAA, + 0xD5, 0x72, 0x48, 0x29, 0xBD, 0xB9, 0xBC, 0xFD, 0xF4, 0xF3, 0xD7, 0xDF, + 0xBD, 0xBE, 0xDE, 0x6C, 0x76, 0xDB, 0xDD, 0x18, 0x73, 0x26, 0xF8, 0x9D, + 0x9F, 0x16, 0xE8, 0x10, 0x5F, 0xFB, 0xE4, 0xD1, 0xE9, 0x6A, 0xE8, 0x1E, + 0x9D, 0xAE, 0x4E, 0xD7, 0xAB, 0x4A, 0xF5, 0x9B, 0x97, 0x6F, 0xEF, 0xEE, + 0xB6, 0xAF, 0xAF, 0x6E, 0xEF, 0x37, 0x3B, 0x6B, 0xCD, 0xD9, 0xE9, 0x89, + 0x56, 0xEA, 0xA5, 0x0F, 0xBB, 0x71, 0x3A, 0x59, 0x2D, 0xCE, 0xCE, 0x4E, + 0x90, 0xC8, 0xFB, 0xB0, 0x9F, 0x7C, 0x88, 0x91, 0xDF, 0x58, 0xAD, 0xF4, + 0x34, 0x7B, 0xAD, 0x54, 0x63, 0xAD, 0x0F, 0xF1, 0xFC, 0x6C, 0xAD, 0xB4, + 0x8A, 0x29, 0xD7, 0x5A, 0x59, 0x29, 0xC7, 0x0F, 0x3D, 0x1D, 0xC9, 0x8B, + 0x5A, 0x2B, 0x87, 0xD0, 0xB3, 0xA8, 0xD5, 0x87, 0x68, 0xB4, 0x46, 0xA4, + 0xC5, 0x30, 0xE8, 0x18, 0xF5, 0x31, 0xB7, 0x57, 0x49, 0xB5, 0x5C, 0x9F, + 0xAD, 0x96, 0xC3, 0xE8, 0xA3, 0xEC, 0xD7, 0x76, 0x75, 0x0E, 0xDB, 0x1B, + 0x42, 0x8A, 0x25, 0xED, 0xC7, 0xE9, 0xEC, 0xF4, 0x44, 0x62, 0x8D, 0x29, + 0x97, 0xCA, 0x3A, 0x40, 0xB9, 0x78, 0xFA, 0xDE, 0xAB, 0xAF, 0xBF, 0x94, + 0xFB, 0xAF, 0xCE, 0x9F, 0x9C, 0xBD, 0x2C, 0xE8, 0x8C, 0x6E, 0x9D, 0x33, + 0xDA, 0xB4, 0xCE, 0x38, 0x6B, 0x46, 0x1F, 0x2C, 0x63, 0x3A, 0xB5, 0xE6, + 0x52, 0x9B, 0xC6, 0xED, 0xA7, 0x59, 0x6B, 0xCE, 0x5F, 0xD7, 0x4A, 0x69, + 0x96, 0xBF, 0x32, 0x2A, 0xCF, 0x34, 0xBF, 0xE1, 0xF3, 0x17, 0xB1, 0x94, + 0xC2, 0xAA, 0x77, 0x6B, 0x5D, 0xAD, 0x88, 0x94, 0xF8, 0x99, 0xE6, 0x9F, + 0x64, 0x4C, 0x45, 0xE9, 0x6C, 0xB4, 0xE1, 0x28, 0x6D, 0xAE, 0x10, 0x2E, + 0xB5, 0x36, 0xAD, 0x03, 0x51, 0x6B, 0xA9, 0xCE, 0x1A, 0x21, 0x45, 0x2E, + 0xA5, 0xB1, 0xA6, 0xEB, 0x1A, 0x36, 0x48, 0x72, 0x95, 0x5C, 0xCE, 0x95, + 0x9B, 0xDF, 0x84, 0xD0, 0x0C, 0x90, 0x5B, 0xA7, 0xAD, 0xD6, 0x46, 0x69, + 0x63, 0x94, 0xD2, 0x8A, 0x19, 0x71, 0x21, 0x04, 0x00, 0xB2, 0x56, 0xA0, + 0x14, 0xAC, 0x5C, 0xE9, 0xC9, 0xF4, 0x68, 0x95, 0x04, 0xA0, 0x0F, 0xF1, + 0xF3, 0xC7, 0x35, 0x92, 0xE8, 0xF7, 0x4E, 0xA5, 0x07, 0xBD, 0x35, 0xFC, + 0x4E, 0xA9, 0x88, 0xF4, 0x80, 0x82, 0x01, 0xC0, 0x43, 0xD7, 0x21, 0x1D, + 0xF9, 0xBB, 0x87, 0xBF, 0x44, 0x4A, 0xA1, 0x8D, 0x16, 0x52, 0x10, 0x81, + 0x14, 0x92, 0x04, 0x70, 0x6B, 0xC6, 0xC3, 0xBE, 0x23, 0x38, 0x67, 0x95, + 0x08, 0x11, 0xDB, 0xC6, 0xA5, 0x94, 0x1B, 0x67, 0x80, 0x7B, 0x3D, 0xA4, + 0x44, 0xC4, 0x92, 0xCB, 0xC9, 0x62, 0x78, 0xFA, 0xF8, 0xB4, 0x6D, 0xDD, + 0xD7, 0xAF, 0xAE, 0x36, 0xBB, 0xF1, 0x80, 0x4F, 0x2B, 0x69, 0x94, 0x92, + 0x52, 0x21, 0x56, 0x04, 0x9A, 0x43, 0x80, 0xDF, 0x0B, 0x90, 0x61, 0x48, + 0xDE, 0x18, 0x20, 0x80, 0x10, 0x03, 0x3B, 0xB1, 0xEA, 0x41, 0x7E, 0xC9, + 0x9A, 0x55, 0x2C, 0xB5, 0x6A, 0xA3, 0x01, 0xD4, 0x7E, 0x9C, 0x38, 0x10, + 0x38, 0x97, 0xAA, 0x94, 0x02, 0x29, 0x8D, 0xD6, 0x43, 0xDB, 0xFC, 0xFC, + 0x57, 0x5F, 0xDC, 0xDE, 0xEF, 0xFF, 0xF8, 0xC7, 0x1F, 0x6A, 0xAD, 0xC7, + 0xFD, 0xF4, 0xF2, 0xD5, 0xDB, 0xA6, 0x69, 0x14, 0x97, 0x27, 0x24, 0xC4, + 0x8A, 0x81, 0x92, 0x89, 0x09, 0x09, 0xB8, 0x5C, 0xB2, 0xEF, 0x1B, 0x6B, + 0x8D, 0xB3, 0xA6, 0xD4, 0xCA, 0xC4, 0x87, 0xD1, 0xAA, 0xE4, 0x12, 0x42, + 0x48, 0x31, 0x3D, 0x7F, 0xF6, 0x18, 0x00, 0xC6, 0xC9, 0xF7, 0x5D, 0x37, + 0xF9, 0xB0, 0x9B, 0x66, 0x76, 0xF5, 0x9F, 0x9F, 0xAE, 0x6B, 0xAD, 0x6F, + 0xDE, 0xDE, 0x5C, 0xDF, 0xDC, 0x8F, 0xE3, 0xD4, 0x38, 0xFB, 0xE6, 0xCD, + 0xDB, 0xFB, 0xED, 0xEE, 0xD9, 0xE3, 0x8B, 0xC6, 0x9A, 0x52, 0xF2, 0x34, + 0x87, 0xE5, 0x30, 0x0C, 0x7D, 0xCF, 0x3F, 0xFC, 0x18, 0xF3, 0x7E, 0x9A, + 0x63, 0x2E, 0x52, 0xC8, 0xA1, 0x6F, 0x97, 0x43, 0xFF, 0xE6, 0xF2, 0xE6, + 0xE6, 0x6E, 0x1B, 0x62, 0x9C, 0xE7, 0x28, 0x04, 0x58, 0x6B, 0x1E, 0x3F, + 0x3A, 0x7D, 0xF6, 0xE4, 0x1C, 0x04, 0x58, 0x63, 0x1F, 0xAC, 0x45, 0x70, + 0xF4, 0x4E, 0x1E, 0xFD, 0xBF, 0x82, 0xC5, 0x9E, 0x3C, 0xEE, 0x1D, 0x15, + 0x82, 0x22, 0xE7, 0x5A, 0x0B, 0xAA, 0xA3, 0x5B, 0x16, 0x00, 0x22, 0xB7, + 0xCE, 0x95, 0x32, 0x4E, 0x73, 0xCE, 0x25, 0xA5, 0x5C, 0x0A, 0x02, 0x88, + 0x52, 0xEA, 0x31, 0x1C, 0x05, 0x08, 0xA1, 0x94, 0x6A, 0xB4, 0x29, 0x95, + 0x85, 0x78, 0x20, 0x65, 0x25, 0x00, 0x63, 0x74, 0xD3, 0x68, 0xA3, 0xF8, + 0x70, 0x94, 0x44, 0x94, 0x6B, 0x79, 0xB8, 0xF0, 0x1E, 0x3D, 0x3A, 0x7B, + 0xF5, 0xFA, 0xED, 0x6E, 0x3F, 0x12, 0xD1, 0xF9, 0xE9, 0x1A, 0x11, 0x53, + 0xCA, 0x31, 0xCE, 0xC3, 0xA2, 0x1F, 0xC7, 0x02, 0x00, 0xD6, 0x1A, 0xDE, + 0x1D, 0x84, 0x94, 0x15, 0x49, 0xFF, 0xCB, 0x3F, 0xFD, 0x41, 0x2E, 0xF5, + 0x97, 0xBF, 0xF9, 0x16, 0x11, 0x8C, 0xD1, 0x9F, 0x7F, 0xF5, 0x76, 0xBD, + 0xEC, 0x5E, 0xBC, 0x73, 0xF1, 0xC3, 0x1F, 0xBC, 0xFB, 0xF2, 0xF5, 0x8D, + 0x94, 0xA2, 0x56, 0xFC, 0xE6, 0xBB, 0xAB, 0x17, 0xCF, 0xCE, 0x95, 0x91, + 0x9F, 0xFC, 0xFA, 0x8B, 0x7F, 0xFC, 0xC5, 0x17, 0x93, 0x8F, 0x4D, 0xE3, + 0x5E, 0xBE, 0xB9, 0x9E, 0xC6, 0xC9, 0x59, 0xDD, 0x38, 0x17, 0x62, 0x9A, + 0xE6, 0x59, 0x80, 0xD0, 0x4A, 0x55, 0x44, 0x09, 0xA2, 0x12, 0x68, 0x29, + 0x19, 0xEA, 0xB2, 0x56, 0x6F, 0xF7, 0xF1, 0xBB, 0x57, 0x57, 0xFB, 0x71, + 0xF6, 0x31, 0x2F, 0x97, 0x4B, 0x29, 0x61, 0xB7, 0xDF, 0x9F, 0xAC, 0x96, + 0xEB, 0xD5, 0x42, 0x4A, 0xF1, 0xBD, 0xF7, 0x9F, 0x3F, 0x79, 0x74, 0x26, + 0x95, 0x9C, 0x66, 0x6F, 0x8C, 0x5E, 0x2F, 0x17, 0x29, 0x15, 0xA5, 0xA5, + 0xB1, 0xA6, 0xEF, 0xDA, 0xCD, 0xFD, 0x5E, 0x4A, 0xB9, 0x5A, 0x0D, 0xAE, + 0x71, 0x6D, 0xD7, 0x2C, 0x08, 0x9D, 0x31, 0xC6, 0x18, 0x66, 0x94, 0x63, + 0xC9, 0x8C, 0x4D, 0x02, 0x50, 0x4C, 0xF9, 0x7E, 0xB3, 0xBB, 0xDF, 0xEC, + 0x7D, 0x4C, 0x40, 0xD4, 0x75, 0xEE, 0xF4, 0x64, 0xC9, 0x13, 0x7B, 0x4A, + 0xB9, 0xED, 0x9A, 0x52, 0x2B, 0x12, 0x18, 0xAB, 0x87, 0xD5, 0xF2, 0xE3, + 0x1F, 0xFC, 0xE0, 0x7E, 0xF7, 0x0F, 0x85, 0xC4, 0xFA, 0xDD, 0x8F, 0xF7, + 0xAF, 0x54, 0xB9, 0x79, 0x0B, 0xB5, 0xC6, 0x14, 0x77, 0xE3, 0xA8, 0x04, + 0x74, 0x8B, 0xB3, 0x5C, 0x6B, 0x0A, 0x21, 0xFA, 0xF4, 0x0E, 0x10, 0x82, + 0xBC, 0xBA, 0xBA, 0x3C, 0x5D, 0x5D, 0x37, 0xCD, 0xD0, 0x36, 0x06, 0x88, + 0x9C, 0xD3, 0xC6, 0x9A, 0xFD, 0xEC, 0xB1, 0x22, 0x4A, 0x41, 0x02, 0xA4, + 0x52, 0xC3, 0x62, 0x88, 0x21, 0xB6, 0x4D, 0x23, 0x04, 0x88, 0xD6, 0x49, + 0x21, 0x43, 0x4C, 0x29, 0x07, 0x02, 0xA8, 0xA5, 0x70, 0xB7, 0x2B, 0x41, + 0xE6, 0x57, 0xFB, 0x70, 0xDF, 0x4A, 0x51, 0x10, 0x15, 0xA9, 0x74, 0x4C, + 0xF6, 0xAD, 0x95, 0x78, 0xF5, 0xCB, 0xA5, 0x60, 0x35, 0xA1, 0xC4, 0x52, + 0xAA, 0x94, 0xB2, 0x62, 0x76, 0xF6, 0xC0, 0x97, 0x4B, 0x29, 0x58, 0x0B, + 0x5A, 0x4A, 0x35, 0xFA, 0x50, 0x8F, 0x24, 0xA5, 0x54, 0xD2, 0x48, 0x29, + 0x6B, 0x41, 0x00, 0x72, 0xCE, 0x32, 0xC2, 0xC5, 0xCF, 0xA8, 0xD6, 0xCA, + 0x28, 0x69, 0xAD, 0x31, 0x6C, 0x58, 0x21, 0x62, 0xE1, 0xAB, 0x50, 0x82, + 0x61, 0x23, 0x02, 0xC2, 0x4A, 0x07, 0x7E, 0xBB, 0xA2, 0x94, 0xC2, 0x3A, + 0xC3, 0x85, 0x52, 0x52, 0x02, 0x5F, 0x1B, 0xF8, 0x7B, 0xEE, 0xC2, 0x87, + 0xE3, 0xEC, 0xFF, 0x27, 0x7E, 0x7D, 0xD8, 0x25, 0x01, 0x0E, 0xCD, 0xB5, + 0x0F, 0x53, 0x18, 0x1D, 0x75, 0x67, 0xFC, 0x07, 0x95, 0x92, 0xD6, 0xEA, + 0x69, 0x06, 0x29, 0x45, 0xAE, 0x05, 0x91, 0x78, 0x9B, 0xE0, 0x69, 0x2F, + 0xE6, 0x1C, 0x63, 0xE6, 0x93, 0xB1, 0x69, 0x1A, 0x06, 0xD1, 0xB5, 0xD6, + 0x5A, 0x69, 0xEE, 0x2D, 0x3F, 0x59, 0x2D, 0xCE, 0xCF, 0xD7, 0xF7, 0xA3, + 0xFF, 0xF6, 0xF2, 0x8E, 0x63, 0x5D, 0x85, 0x10, 0x08, 0x58, 0x62, 0xE5, + 0xB1, 0x34, 0xA5, 0x54, 0x11, 0x8F, 0xC1, 0x62, 0x42, 0xB0, 0x60, 0x0A, + 0xC8, 0x68, 0xCD, 0x84, 0xA3, 0x35, 0x56, 0x2B, 0xC5, 0x71, 0x8F, 0x87, + 0x9D, 0x86, 0x20, 0x95, 0x6C, 0x94, 0x16, 0x20, 0x0A, 0x56, 0x6B, 0x0D, + 0x17, 0x1A, 0x18, 0xA3, 0x4B, 0x45, 0x86, 0xFB, 0x62, 0x4C, 0x42, 0xC8, + 0x2F, 0xBE, 0x79, 0xBD, 0x9F, 0xFC, 0x07, 0xEF, 0x3E, 0x7D, 0xFE, 0xEC, + 0x62, 0xB7, 0x1F, 0xDF, 0x5E, 0x5E, 0x9D, 0x9E, 0xAC, 0xD9, 0xC4, 0x66, + 0xD9, 0xCA, 0x56, 0xB0, 0x62, 0xDD, 0xEE, 0x47, 0x96, 0xF5, 0x31, 0x62, + 0x2A, 0x85, 0xC8, 0xB9, 0x8C, 0xD3, 0xA8, 0xB5, 0x31, 0x5A, 0x0B, 0x21, + 0xBC, 0x8F, 0xBF, 0xFD, 0xE2, 0x1B, 0x00, 0xB1, 0x5A, 0x2F, 0xCC, 0xA4, + 0x39, 0x96, 0x2A, 0x84, 0x78, 0x7E, 0xB6, 0xF6, 0x21, 0xBE, 0x79, 0x7B, + 0x13, 0x63, 0x2A, 0xA5, 0x70, 0x54, 0xD1, 0x6A, 0xB9, 0x78, 0xF1, 0xFC, + 0xE9, 0x38, 0xCE, 0x4A, 0x6B, 0x24, 0x91, 0x2B, 0x7D, 0xFD, 0xF2, 0x8D, + 0xBB, 0xBA, 0x6D, 0x5B, 0xB7, 0xDD, 0xEE, 0xF9, 0xEA, 0xED, 0xDA, 0x86, + 0x08, 0xFB, 0xBE, 0xFD, 0xEA, 0xDB, 0x37, 0x57, 0x37, 0x9B, 0xDD, 0x3C, + 0x59, 0x7D, 0xA8, 0xE6, 0x70, 0xCE, 0x01, 0x88, 0x9C, 0x6A, 0xD2, 0x1C, + 0x41, 0x2E, 0x95, 0x3C, 0xA6, 0xAA, 0x12, 0x4B, 0xEA, 0x91, 0x5B, 0x1D, + 0x88, 0x8F, 0xAD, 0x1A, 0x85, 0x10, 0x4A, 0xE9, 0xE3, 0x27, 0x48, 0x52, + 0x4A, 0x55, 0x2B, 0x22, 0x56, 0xA4, 0x9C, 0x4B, 0x08, 0x71, 0xF2, 0x71, + 0x3F, 0x4E, 0x21, 0x26, 0x10, 0x30, 0x8E, 0x33, 0x00, 0x34, 0x6D, 0x23, + 0x08, 0xDA, 0xD6, 0xB1, 0xF2, 0x09, 0x80, 0x85, 0x44, 0x64, 0x8C, 0x22, + 0x02, 0xAC, 0x3C, 0x2B, 0x17, 0xCD, 0x50, 0x06, 0xA2, 0x38, 0x3E, 0x54, + 0x02, 0x44, 0x2E, 0x45, 0x29, 0xC9, 0xF5, 0x86, 0xD6, 0xDA, 0xED, 0x38, + 0x75, 0x4D, 0xE3, 0x43, 0x42, 0x02, 0xA6, 0x4A, 0x9B, 0xA6, 0x71, 0x2E, + 0xB0, 0x0D, 0x00, 0x00, 0x4A, 0x45, 0xCC, 0xD5, 0x18, 0x52, 0xFF, 0xF5, + 0x7F, 0xF3, 0xDF, 0x7F, 0xF7, 0xF6, 0x76, 0xF6, 0xC9, 0x59, 0xC3, 0xF1, + 0x81, 0xF3, 0x1C, 0x6F, 0xEE, 0xC6, 0xC9, 0x87, 0x93, 0xD5, 0x82, 0xE9, + 0xB6, 0x47, 0x67, 0x2B, 0x1F, 0xC2, 0xCF, 0xFE, 0xFE, 0xD3, 0xBF, 0xFF, + 0xE4, 0x8B, 0xC9, 0xC7, 0xD9, 0x87, 0xCB, 0xAB, 0xDB, 0x9C, 0xB3, 0x92, + 0x0A, 0x40, 0x20, 0x51, 0xCA, 0x65, 0xB7, 0x1B, 0xAD, 0x35, 0x5C, 0x0F, + 0x6E, 0xB5, 0xEE, 0x1B, 0x17, 0x53, 0x9E, 0x7D, 0x78, 0x74, 0xB6, 0xB6, + 0xC6, 0x5C, 0xDF, 0x6E, 0xBE, 0x7B, 0x7D, 0xC9, 0xE2, 0xCF, 0xAE, 0x69, + 0xC6, 0x69, 0x46, 0xA4, 0x8B, 0x47, 0xA7, 0x17, 0xE7, 0x27, 0x27, 0x27, + 0xAB, 0x67, 0x4F, 0x1E, 0x59, 0xA3, 0xAD, 0x36, 0x43, 0xDF, 0xAD, 0x57, + 0x0B, 0x29, 0xE5, 0xEC, 0x43, 0x29, 0x95, 0xED, 0x63, 0x5F, 0x7E, 0xFD, + 0xAA, 0x69, 0x9B, 0xF5, 0x6A, 0xC1, 0x5B, 0x7A, 0xDF, 0x3A, 0xAD, 0x15, + 0x02, 0xC5, 0x94, 0x73, 0xAD, 0x2C, 0xA4, 0x44, 0xA4, 0x52, 0x71, 0x3F, + 0x4D, 0xAC, 0x11, 0x29, 0xB5, 0xB4, 0xCE, 0x3D, 0xBE, 0x38, 0xED, 0xFB, + 0xA6, 0x6D, 0xDD, 0x6A, 0x35, 0x70, 0x11, 0x96, 0xD5, 0x46, 0x2A, 0xE1, + 0xAC, 0xD6, 0xD6, 0x0C, 0x9D, 0xDB, 0x6C, 0xEE, 0xA7, 0x90, 0x6C, 0xDB, + 0x4B, 0x29, 0xD2, 0xBC, 0x1F, 0xF7, 0x7B, 0xFE, 0x69, 0x12, 0xE1, 0xD9, + 0x93, 0xE7, 0xCE, 0x59, 0x2D, 0x85, 0xD2, 0xFA, 0xDD, 0x1F, 0xFD, 0xD1, + 0xF5, 0xE5, 0xDB, 0xEB, 0x6F, 0xBF, 0x6A, 0x17, 0xA7, 0xA5, 0xBF, 0xD0, + 0x52, 0xD0, 0xD1, 0xEB, 0x9F, 0x52, 0x21, 0x80, 0xB6, 0x69, 0xC6, 0xD9, + 0xF3, 0x4D, 0x5B, 0x91, 0x9C, 0xB5, 0xAC, 0xB0, 0x6D, 0x1A, 0xDB, 0x75, + 0x6D, 0x8C, 0x1C, 0x7A, 0x21, 0x6B, 0x45, 0x66, 0xEE, 0x0F, 0x7E, 0x42, + 0x00, 0x00, 0xEA, 0x9A, 0x46, 0x48, 0xC9, 0x17, 0xA0, 0x10, 0x02, 0x10, + 0x10, 0xA8, 0x6D, 0x1C, 0x10, 0xB0, 0xB8, 0x29, 0x97, 0x92, 0x73, 0xE1, + 0x21, 0xEA, 0xE0, 0x8F, 0x61, 0x6C, 0xC5, 0xB9, 0xAE, 0x75, 0x8D, 0xB3, + 0xBC, 0x26, 0x38, 0x6B, 0xD8, 0x5D, 0xAC, 0xB5, 0xD4, 0x4A, 0x02, 0x09, + 0x63, 0x7E, 0x77, 0x73, 0x2A, 0x25, 0x78, 0x0A, 0x38, 0xEA, 0xCE, 0x19, + 0xBA, 0xE5, 0x10, 0x02, 0xC1, 0xFB, 0x24, 0x96, 0xC3, 0x4F, 0x12, 0x2B, + 0x32, 0xB4, 0xE7, 0x9C, 0x91, 0x52, 0xE0, 0x61, 0x4F, 0x7C, 0x28, 0x63, + 0x3D, 0x1C, 0x4C, 0x5C, 0x0A, 0x06, 0xBF, 0x1B, 0xD7, 0xE0, 0x01, 0xFB, + 0xFF, 0xBD, 0x03, 0x4B, 0x3C, 0xFC, 0x7A, 0x98, 0xE9, 0xE8, 0x08, 0x86, + 0x57, 0xC4, 0x5A, 0xAA, 0x10, 0xC2, 0xC7, 0x74, 0x14, 0x13, 0x55, 0xA6, + 0x17, 0x6B, 0xA9, 0x3E, 0xC4, 0x18, 0x33, 0x22, 0xE6, 0x94, 0xE6, 0x69, + 0x0E, 0x21, 0x54, 0xAC, 0xAD, 0x73, 0x15, 0xB1, 0x20, 0x1A, 0xA3, 0xFE, + 0xE0, 0xA3, 0x17, 0x9B, 0xFD, 0x7C, 0x75, 0xBB, 0xA9, 0x47, 0x1B, 0xA6, + 0x10, 0x82, 0xF5, 0x04, 0x7C, 0x82, 0x2B, 0xA5, 0x94, 0xD2, 0x47, 0x29, + 0x19, 0xF2, 0xCD, 0x27, 0x84, 0xA8, 0x07, 0xF6, 0x99, 0xB4, 0xD6, 0xB9, + 0x94, 0x98, 0xB2, 0x96, 0xCA, 0x5A, 0xCD, 0xC5, 0x31, 0xAC, 0xF3, 0x20, + 0x80, 0x9C, 0x93, 0xB5, 0x96, 0xBF, 0xEC, 0xC5, 0x62, 0x60, 0x34, 0x8D, + 0x8E, 0x7C, 0x2E, 0x73, 0xAC, 0x57, 0x37, 0x77, 0x7F, 0xF5, 0xF7, 0xBF, + 0x54, 0x4A, 0x3F, 0x3A, 0x5F, 0x6F, 0x36, 0x5B, 0x21, 0xE5, 0x93, 0x27, + 0xE7, 0xD6, 0x6A, 0x3F, 0x87, 0x52, 0x6A, 0xCC, 0x99, 0xD9, 0x80, 0xD9, + 0x87, 0xC9, 0x87, 0xBB, 0xBB, 0x0D, 0x00, 0xA4, 0x9C, 0x57, 0x8B, 0x05, + 0x1D, 0x12, 0xE2, 0xD4, 0x6E, 0x9C, 0xE7, 0x39, 0xD4, 0x8A, 0x3E, 0x86, + 0xED, 0x6E, 0x04, 0x22, 0xCD, 0xEC, 0x0D, 0x88, 0xBB, 0xFB, 0xED, 0xCB, + 0xD7, 0x97, 0xBB, 0xFD, 0xC4, 0x2D, 0xD1, 0x5D, 0xD7, 0x36, 0x8D, 0xC5, + 0x4A, 0x42, 0xC8, 0xEB, 0xDB, 0xFB, 0xCF, 0xBE, 0xFC, 0xE6, 0xDB, 0x97, + 0x6F, 0x2F, 0xAF, 0xEF, 0x27, 0x1F, 0xA6, 0x69, 0xE6, 0x84, 0x9F, 0x8A, + 0x78, 0x7D, 0xB3, 0xD9, 0x4D, 0xF3, 0x76, 0x37, 0x7D, 0xFE, 0xF5, 0xCB, + 0x39, 0x44, 0x25, 0x35, 0x1F, 0xDC, 0xA5, 0x20, 0x2B, 0x2E, 0x41, 0xF0, + 0x21, 0x85, 0x52, 0xC8, 0x5C, 0x6B, 0xCE, 0x35, 0xA5, 0x92, 0x2B, 0x0A, + 0x01, 0x0C, 0xC5, 0x1E, 0x04, 0x8C, 0x44, 0x39, 0xD7, 0x18, 0x33, 0x1D, + 0x8D, 0xAE, 0x5C, 0x2D, 0x4A, 0x04, 0x05, 0x31, 0x97, 0xB2, 0x1B, 0xA7, + 0xD9, 0xC7, 0xD9, 0x87, 0x10, 0x12, 0xBF, 0x89, 0xC4, 0xA9, 0xBF, 0x42, + 0x5A, 0x6B, 0xB8, 0x81, 0xD8, 0x87, 0xC4, 0x18, 0x1B, 0x03, 0xFF, 0x4A, + 0x6A, 0x36, 0xA5, 0x39, 0xE7, 0xA4, 0x14, 0x74, 0xBC, 0xDB, 0x90, 0x28, + 0xA6, 0x14, 0x63, 0x3C, 0x0A, 0x8F, 0x29, 0xA5, 0xBC, 0x58, 0x2E, 0x80, + 0x80, 0x01, 0x38, 0x56, 0x1D, 0x6D, 0xB7, 0xD3, 0xED, 0xCD, 0x7D, 0x29, + 0x75, 0x18, 0x3A, 0x66, 0x45, 0x39, 0x71, 0x13, 0x40, 0xA8, 0x7F, 0xF9, + 0x9F, 0xFC, 0xBB, 0xED, 0x6E, 0x86, 0xA3, 0x32, 0x3B, 0xA6, 0x3C, 0xF4, + 0xED, 0xF9, 0xE9, 0xAA, 0x94, 0x3A, 0xF9, 0x78, 0xB2, 0xEE, 0x67, 0xEF, + 0x7F, 0xF3, 0xF9, 0x77, 0xFF, 0xF0, 0x8B, 0x2F, 0x6E, 0x37, 0xA3, 0x35, + 0x6A, 0xBB, 0xDB, 0x85, 0x94, 0x8C, 0x52, 0x5D, 0xDB, 0x00, 0x88, 0x9C, + 0x33, 0xBF, 0x48, 0x6D, 0xD7, 0x48, 0x21, 0xB9, 0x2C, 0x03, 0x4B, 0xE9, + 0xBB, 0x76, 0xBD, 0x5A, 0xAC, 0x97, 0x8B, 0x8F, 0x3F, 0x7A, 0x77, 0xF2, + 0xFE, 0x6E, 0xB3, 0x6F, 0x1B, 0x6B, 0xAD, 0x56, 0x52, 0x9E, 0xAC, 0x17, + 0x43, 0xDF, 0x9E, 0xAC, 0x96, 0x5D, 0xDB, 0x9C, 0x9D, 0x2C, 0xD7, 0xAB, + 0x05, 0x6B, 0xCA, 0x9B, 0xE6, 0x90, 0xCA, 0x94, 0x72, 0x9E, 0xA6, 0x59, + 0x0A, 0xD9, 0x75, 0x6D, 0xD7, 0x36, 0x04, 0xA4, 0x94, 0x5A, 0x2E, 0x07, + 0xA3, 0xB5, 0x31, 0x0A, 0x24, 0x43, 0xBC, 0x98, 0x33, 0xE6, 0xC4, 0xBD, + 0x2D, 0xC4, 0x23, 0xC9, 0x7E, 0xF2, 0x04, 0xA4, 0xA4, 0x34, 0xC6, 0x3A, + 0xA3, 0xCF, 0x4E, 0x57, 0xEB, 0xD5, 0x82, 0x21, 0x5B, 0x6B, 0x4D, 0xDB, + 0x38, 0xE7, 0x0C, 0x2B, 0x51, 0x41, 0x48, 0x4D, 0xD9, 0x48, 0x9A, 0x52, + 0xAD, 0xB9, 0x4A, 0xEB, 0xA8, 0x96, 0x38, 0x6E, 0x4B, 0xCE, 0x02, 0xC0, + 0x6A, 0xD3, 0xAF, 0xD6, 0x5D, 0xD7, 0xD5, 0x30, 0x3D, 0x79, 0xFF, 0xA3, + 0xE1, 0xD9, 0x87, 0x5F, 0xFD, 0xEA, 0x93, 0xE9, 0xEE, 0xED, 0xF0, 0xE8, + 0x5D, 0xAF, 0x4F, 0x08, 0x4B, 0xD7, 0x75, 0xC6, 0x9A, 0x43, 0xD4, 0xCC, + 0xA2, 0x67, 0xCC, 0x85, 0xAD, 0x3D, 0x48, 0x22, 0xA5, 0x2C, 0x79, 0x43, + 0xAC, 0xE8, 0x9C, 0xEB, 0xDB, 0xA6, 0x69, 0x9C, 0xB5, 0xA6, 0x69, 0x5C, + 0xAD, 0x58, 0x4B, 0x65, 0xE9, 0x16, 0x00, 0x58, 0x63, 0xDA, 0xD6, 0x09, + 0x21, 0x0E, 0x0D, 0xF5, 0xB5, 0x1A, 0xA3, 0xBB, 0xB6, 0xB1, 0xD6, 0xF2, + 0x13, 0xF3, 0x60, 0xF4, 0xEB, 0xDA, 0xA6, 0x69, 0x1B, 0xAD, 0x65, 0x66, + 0x97, 0xB8, 0xD6, 0x42, 0x4A, 0xAC, 0xB8, 0x5C, 0x74, 0x5A, 0xA9, 0xC6, + 0xD9, 0xB6, 0x75, 0x1C, 0x12, 0x77, 0x08, 0x1E, 0x20, 0x2C, 0xA5, 0x7A, + 0xCF, 0x7D, 0xAE, 0x07, 0x34, 0x84, 0xA5, 0x1E, 0x15, 0x2B, 0x63, 0x1F, + 0x4C, 0x75, 0x1F, 0x3A, 0xC9, 0x49, 0x70, 0x25, 0x22, 0x17, 0x2F, 0x0A, + 0x21, 0x8C, 0x35, 0x4A, 0xB1, 0x42, 0x4D, 0x1C, 0x36, 0xC4, 0x63, 0x31, + 0x21, 0x1C, 0x3D, 0x6E, 0x6C, 0x80, 0x3E, 0xAE, 0x99, 0xF8, 0xE0, 0x3B, + 0x7E, 0x38, 0xD8, 0xE0, 0x9F, 0x47, 0xF4, 0xB1, 0xB4, 0x8C, 0x41, 0x7D, + 0xD6, 0xDC, 0xA6, 0x98, 0x2A, 0x51, 0x4C, 0x39, 0xA5, 0xC2, 0x24, 0x86, + 0x51, 0x06, 0x0F, 0x90, 0x7C, 0x4E, 0xA5, 0x28, 0x2D, 0x79, 0x24, 0x61, + 0x7F, 0xA8, 0x10, 0x22, 0xE6, 0x74, 0x73, 0xBB, 0x79, 0xF7, 0x9D, 0x0B, + 0xAB, 0xCD, 0xEB, 0xAB, 0xDB, 0x10, 0x23, 0x11, 0xF1, 0xD0, 0xC5, 0xC2, + 0x5B, 0xAE, 0xD1, 0x06, 0x00, 0xA5, 0x24, 0xD1, 0xA1, 0x28, 0xB7, 0xD4, + 0xC2, 0x94, 0xA2, 0x31, 0x86, 0x43, 0xD5, 0xB4, 0x52, 0x87, 0xBC, 0xE4, + 0xE3, 0xEB, 0xC4, 0x5F, 0xA9, 0xD1, 0x5A, 0x08, 0x2A, 0x15, 0x73, 0x2D, + 0x2C, 0xD9, 0x47, 0xA2, 0x10, 0x52, 0xDF, 0xBB, 0xC5, 0xA2, 0x9B, 0xE6, + 0xC0, 0xC3, 0x32, 0x13, 0x9D, 0x43, 0xDB, 0xE6, 0x52, 0x7E, 0xFD, 0xDB, + 0xAF, 0x77, 0xBB, 0xF9, 0xFC, 0x6C, 0x3D, 0x74, 0xED, 0x38, 0xCD, 0x31, + 0xA4, 0xED, 0x6E, 0x3A, 0x3D, 0x5B, 0x2F, 0x86, 0x5E, 0x1C, 0xBC, 0x4A, + 0x86, 0x49, 0x46, 0x6E, 0xCF, 0x7D, 0xF6, 0xE4, 0xA2, 0xED, 0x5A, 0xA3, + 0x8D, 0xD2, 0xEA, 0xEC, 0x74, 0xB5, 0x5E, 0x2F, 0x27, 0xEF, 0x9D, 0xB5, + 0x5A, 0x69, 0x24, 0xE4, 0x86, 0x6F, 0x56, 0xAE, 0xDF, 0x6F, 0xF7, 0x57, + 0x57, 0xB7, 0x4A, 0xF2, 0x07, 0x77, 0xD8, 0xFE, 0x62, 0x2A, 0x5F, 0x7F, + 0xF7, 0x7A, 0x9C, 0x3D, 0xFF, 0x18, 0x87, 0xBE, 0x5D, 0x2E, 0x7A, 0x25, + 0xD5, 0xE5, 0xCD, 0xBD, 0xF7, 0x29, 0xA6, 0xCC, 0x95, 0xEC, 0x00, 0x10, + 0x52, 0x8E, 0x29, 0x31, 0x5E, 0xC0, 0xD1, 0x47, 0xA5, 0xD4, 0x94, 0xF3, + 0xEC, 0x03, 0x00, 0xD4, 0x8A, 0x5C, 0xAC, 0xE9, 0x43, 0xF4, 0x3E, 0xB2, + 0x21, 0x3C, 0xC4, 0xB8, 0x1F, 0x67, 0x1F, 0x92, 0x0F, 0x31, 0xE7, 0x5A, + 0x10, 0x73, 0x2E, 0x0C, 0xEA, 0x8F, 0x5C, 0xBA, 0x55, 0x2B, 0x08, 0x8E, + 0xDB, 0x0B, 0xFB, 0xFD, 0x54, 0x8E, 0x56, 0x16, 0x71, 0xCC, 0x6B, 0xE3, + 0xC0, 0xD1, 0x5C, 0x6A, 0x88, 0x89, 0xE9, 0x66, 0xA9, 0xA4, 0xD2, 0x2C, + 0x20, 0xC7, 0x07, 0x50, 0x85, 0x85, 0x99, 0x31, 0xA5, 0x8A, 0x35, 0x84, + 0xB8, 0xD9, 0x8D, 0xD7, 0xB7, 0x1B, 0xD6, 0xF7, 0xB1, 0xA8, 0xA2, 0x96, + 0xF2, 0xED, 0x77, 0x6F, 0x6E, 0x6F, 0x37, 0x84, 0x87, 0xBC, 0xB3, 0x8B, + 0x8B, 0xF3, 0x6E, 0x68, 0x95, 0x92, 0x42, 0xCA, 0x69, 0xF2, 0x44, 0x04, + 0x48, 0x15, 0x49, 0x80, 0xD0, 0x15, 0x69, 0xBD, 0x1A, 0xE6, 0x39, 0x0A, + 0x09, 0xA1, 0x64, 0x6B, 0xCD, 0x1C, 0xD2, 0xF8, 0xE6, 0x2A, 0xA5, 0x98, + 0x52, 0xFA, 0xE5, 0x6F, 0x8A, 0x52, 0xD2, 0x6A, 0x53, 0x4A, 0x8D, 0x29, + 0xD6, 0x2C, 0x1B, 0x6B, 0xA4, 0x52, 0x8D, 0xB3, 0x39, 0x97, 0xED, 0x76, + 0x8F, 0x88, 0x8D, 0xB3, 0x55, 0xD7, 0xCD, 0x76, 0x24, 0xAC, 0x5A, 0x9B, + 0x39, 0x84, 0xC6, 0x18, 0x29, 0xE4, 0x6A, 0xD1, 0xFF, 0xE8, 0x07, 0xEF, + 0x0D, 0x43, 0x77, 0x7D, 0xB3, 0xE9, 0xDA, 0x86, 0x3D, 0x46, 0x39, 0x97, + 0xE7, 0xCF, 0x2E, 0x38, 0x31, 0xAA, 0x6D, 0x5C, 0xD7, 0xB9, 0x71, 0xF2, + 0xAC, 0xE7, 0x00, 0x10, 0xB5, 0xE0, 0x6E, 0x9C, 0x42, 0x8C, 0x4A, 0xCA, + 0xAE, 0x6D, 0x52, 0xCA, 0x6D, 0xEB, 0xDE, 0x7F, 0xF7, 0x69, 0xCE, 0xA5, + 0x22, 0x95, 0x52, 0x41, 0x30, 0xF7, 0xC4, 0xBD, 0x9B, 0x50, 0x89, 0x0E, + 0x9E, 0x87, 0x8A, 0xD3, 0xEC, 0x95, 0x90, 0xAC, 0x36, 0xF2, 0x3E, 0x59, + 0x67, 0x59, 0xBA, 0xDE, 0xBB, 0x36, 0x84, 0x2C, 0xA5, 0xD0, 0x5A, 0xD6, + 0x82, 0x42, 0x8A, 0x8A, 0x68, 0xAC, 0xC6, 0x29, 0x5B, 0x81, 0xEB, 0xD5, + 0x52, 0x0A, 0x19, 0x53, 0x76, 0xEF, 0xFF, 0x50, 0x2A, 0x7D, 0xF7, 0xEA, + 0xAB, 0x71, 0x7B, 0x5F, 0xAB, 0x56, 0xB6, 0x3D, 0x79, 0xF1, 0xBD, 0xE5, + 0xF9, 0xF9, 0x70, 0xF1, 0xC2, 0x87, 0xB4, 0xB9, 0xBB, 0x2B, 0xA5, 0x4E, + 0xB1, 0x56, 0x83, 0x8F, 0xCE, 0xD6, 0x20, 0x84, 0xF7, 0xA1, 0x56, 0x6C, + 0x1B, 0xD7, 0x34, 0x2E, 0xE7, 0x32, 0x0C, 0x1D, 0x11, 0x29, 0xAD, 0x9C, + 0x52, 0xB9, 0x68, 0x22, 0x1A, 0xBA, 0xA6, 0x22, 0x35, 0xD6, 0x38, 0xDB, + 0xCD, 0x5C, 0x10, 0x2D, 0xE5, 0x1C, 0x52, 0x88, 0x51, 0x4A, 0xB1, 0x1F, + 0xFD, 0x6E, 0x9C, 0x91, 0x78, 0x62, 0xE2, 0x83, 0x8C, 0x8C, 0xD1, 0x4A, + 0x4A, 0x26, 0x31, 0x85, 0x14, 0x7C, 0xF8, 0x2A, 0xA5, 0x52, 0x4A, 0x6C, + 0x02, 0x67, 0xBC, 0x26, 0xA5, 0x24, 0x85, 0x40, 0x22, 0x21, 0x45, 0x88, + 0xC9, 0x18, 0x0D, 0x44, 0x88, 0xA2, 0x69, 0x1C, 0xEF, 0x53, 0x4C, 0x96, + 0x13, 0x1D, 0x72, 0x05, 0x4A, 0xAE, 0x20, 0x0E, 0xF6, 0x34, 0x56, 0x13, + 0x3F, 0xC8, 0xBC, 0xF2, 0xC1, 0x55, 0x2E, 0xB4, 0x52, 0x24, 0x80, 0x08, + 0x2A, 0x47, 0x7E, 0x1E, 0xA5, 0xDB, 0x87, 0xE3, 0x40, 0x82, 0x10, 0xA0, + 0x04, 0x48, 0x90, 0x4A, 0x02, 0x16, 0xAE, 0x14, 0x11, 0x5A, 0x4A, 0x62, + 0x74, 0xFC, 0xD8, 0x4B, 0xC1, 0x6B, 0x2F, 0xA3, 0x6F, 0x42, 0x82, 0x14, + 0x12, 0x25, 0x7B, 0x34, 0x05, 0x48, 0xF1, 0x3B, 0x50, 0x8D, 0xA0, 0x22, + 0xA6, 0x58, 0x4A, 0x45, 0x1F, 0x02, 0xAB, 0xD5, 0x8C, 0x56, 0x4A, 0xAA, + 0x98, 0x12, 0xD6, 0xCA, 0xA1, 0x98, 0xC6, 0x98, 0xDD, 0x38, 0x12, 0x80, + 0xB6, 0xA6, 0xD6, 0x5A, 0x6A, 0xE5, 0xFE, 0xE3, 0x17, 0xCF, 0x2E, 0xDE, + 0xB9, 0x38, 0xFB, 0xE5, 0x6F, 0xBF, 0x8E, 0xC7, 0xF2, 0x3A, 0x42, 0x3A, + 0x54, 0x5F, 0x48, 0x89, 0x88, 0x6C, 0xB5, 0xAA, 0x1C, 0x1A, 0x43, 0x58, + 0x2B, 0x2A, 0x21, 0x39, 0xFC, 0x38, 0xA5, 0xE4, 0x53, 0x56, 0x42, 0x94, + 0x52, 0x1A, 0xE7, 0x80, 0xFB, 0xF4, 0xC4, 0x01, 0x0D, 0xC4, 0x43, 0x58, + 0x20, 0x69, 0x7D, 0xE8, 0xE2, 0x54, 0x4A, 0x19, 0x63, 0x66, 0xEF, 0xC7, + 0x09, 0x4E, 0x4F, 0x56, 0x8D, 0xF3, 0xA9, 0x20, 0x07, 0x75, 0x08, 0x29, + 0x7C, 0xCC, 0x2F, 0x9E, 0x3D, 0xCE, 0xA5, 0x7E, 0xF3, 0xF2, 0xCD, 0xE5, + 0xCD, 0xED, 0x9F, 0xFE, 0xE4, 0xE3, 0x9F, 0xFE, 0xE8, 0xA3, 0xFB, 0xFB, + 0x5D, 0xD3, 0xB8, 0xA1, 0xEF, 0x57, 0xAB, 0x21, 0x84, 0x28, 0x84, 0x98, + 0x26, 0x7F, 0x73, 0x7B, 0xFF, 0xEC, 0xC9, 0x23, 0x76, 0xD7, 0x5E, 0xDF, + 0xDC, 0x31, 0xC9, 0x8E, 0x88, 0x4F, 0x2E, 0xCE, 0xE7, 0xD9, 0x0F, 0x43, + 0x77, 0x7B, 0xB7, 0xFD, 0xF4, 0xB7, 0x5F, 0x7D, 0xFC, 0xE1, 0x7B, 0x52, + 0x88, 0xDB, 0xBB, 0xCD, 0xF9, 0xD9, 0xDA, 0x18, 0xFD, 0x83, 0x8F, 0xDE, + 0x7B, 0xF1, 0xEC, 0xF1, 0xE5, 0xD5, 0xED, 0x7E, 0x9C, 0x52, 0xA9, 0x0C, + 0x5A, 0x95, 0x52, 0x3E, 0xFE, 0xE8, 0x83, 0xCF, 0xBF, 0xFE, 0xF6, 0xF2, + 0xFA, 0x6E, 0xD1, 0xB7, 0xAB, 0x45, 0x0F, 0x24, 0x5E, 0xBE, 0xB9, 0x1E, + 0x67, 0xCF, 0xE1, 0x51, 0x52, 0x48, 0x1F, 0x63, 0xAD, 0x14, 0x62, 0x44, + 0x24, 0x76, 0x41, 0x18, 0xAD, 0xD9, 0xD3, 0xD1, 0x75, 0x1D, 0xEB, 0x1B, + 0x58, 0xFF, 0x8A, 0x88, 0xB9, 0x62, 0x8C, 0x39, 0xE5, 0xC4, 0x38, 0x17, + 0x9F, 0x71, 0x0C, 0x3F, 0x59, 0x63, 0xAC, 0x35, 0x6D, 0xEB, 0x10, 0x71, + 0x9A, 0x3D, 0x22, 0xA9, 0xC9, 0x73, 0x61, 0x58, 0x88, 0x2C, 0xA3, 0x7E, + 0x10, 0x55, 0x88, 0x87, 0xA2, 0x7B, 0x21, 0x44, 0xF0, 0x41, 0x1B, 0x2D, + 0x95, 0x4C, 0xA9, 0xCC, 0x21, 0x1A, 0x63, 0x40, 0x88, 0x5A, 0x8B, 0x14, + 0xA2, 0x69, 0x9A, 0x14, 0x53, 0xD3, 0x98, 0xAE, 0x6D, 0x7D, 0x88, 0x4A, + 0x6B, 0x00, 0xC8, 0xB9, 0xDC, 0x6D, 0x76, 0xB3, 0x8F, 0x7D, 0xDF, 0xF6, + 0x7D, 0x7B, 0xB2, 0x5A, 0xCD, 0x3E, 0x2C, 0x97, 0xC3, 0xB7, 0x2F, 0xDF, + 0xA4, 0x52, 0x97, 0xD0, 0xB3, 0x50, 0xB4, 0x54, 0x02, 0x80, 0x6F, 0x5F, + 0xBE, 0x41, 0x44, 0xE7, 0xDC, 0xD9, 0xC9, 0xCA, 0x1A, 0x5D, 0x6A, 0xD5, + 0xE5, 0x58, 0x2F, 0xAC, 0xB4, 0x52, 0x19, 0xB1, 0x62, 0xCE, 0x69, 0xBF, + 0xDF, 0x13, 0x90, 0x73, 0x76, 0x31, 0x74, 0x02, 0x60, 0xB3, 0xDD, 0x69, + 0x25, 0x4F, 0x96, 0x03, 0x22, 0x2E, 0x86, 0xAE, 0xE4, 0x62, 0xAD, 0x56, + 0x52, 0x79, 0x1F, 0x84, 0x10, 0x8B, 0xAE, 0x6D, 0x5B, 0x27, 0x41, 0xEC, + 0xA7, 0xB9, 0x94, 0x62, 0xB5, 0x06, 0x21, 0xF6, 0xE3, 0xF4, 0x9E, 0x79, + 0xDC, 0x77, 0x2D, 0x12, 0x2D, 0x16, 0x1D, 0xD7, 0x64, 0x20, 0x51, 0xD7, + 0x35, 0x6C, 0x52, 0xD1, 0x5A, 0x29, 0x2D, 0xBB, 0xAE, 0x61, 0xC3, 0x54, + 0xCE, 0x39, 0xC4, 0xE8, 0x43, 0x34, 0x5A, 0x39, 0x37, 0x20, 0xA2, 0x8F, + 0x29, 0xE7, 0x8C, 0x88, 0xFC, 0x40, 0x63, 0x4A, 0x52, 0x4A, 0x20, 0x91, + 0x13, 0xC3, 0x0D, 0x12, 0x09, 0x8F, 0x58, 0x63, 0x4D, 0xB9, 0xC4, 0x9C, + 0x97, 0x43, 0x9F, 0x4B, 0x29, 0xB9, 0xF4, 0x5D, 0xB3, 0x5A, 0x76, 0x3C, + 0x86, 0x28, 0x25, 0x9D, 0xD5, 0x88, 0x98, 0x73, 0xE5, 0xAB, 0x40, 0x08, + 0x81, 0x95, 0x94, 0xD4, 0x25, 0xC7, 0x9C, 0xB3, 0x36, 0x7A, 0x9E, 0xBD, + 0xEB, 0xDA, 0xF6, 0xD1, 0xD3, 0xC7, 0x5D, 0x17, 0x7E, 0xFE, 0x33, 0xA9, + 0x94, 0x70, 0x5D, 0x31, 0x43, 0xBF, 0xBE, 0x40, 0x82, 0x52, 0x72, 0x4E, + 0x29, 0xC6, 0xB0, 0x3E, 0x39, 0x11, 0xED, 0xD0, 0x3A, 0xB7, 0x9F, 0x66, + 0xEF, 0xE3, 0xA3, 0xB3, 0x75, 0xDB, 0x34, 0xBB, 0x69, 0x56, 0x4A, 0xAD, + 0x16, 0x3D, 0x27, 0x79, 0x49, 0x29, 0x7D, 0x88, 0x1C, 0xB1, 0x1D, 0x63, + 0x0C, 0x81, 0xA1, 0x2B, 0x99, 0x4B, 0xA9, 0x48, 0xEC, 0x76, 0x64, 0x33, + 0x73, 0x45, 0x64, 0x60, 0xAB, 0x94, 0x62, 0xB4, 0x33, 0x5A, 0x19, 0xA3, + 0x89, 0x30, 0xA4, 0xC8, 0xC6, 0x03, 0x63, 0x14, 0x22, 0x1A, 0xA3, 0xFB, + 0xBE, 0x3D, 0x0C, 0x2C, 0xCE, 0xB2, 0xAF, 0xDB, 0x5A, 0xCB, 0xFE, 0xC4, + 0xD9, 0x47, 0x9C, 0x66, 0x96, 0x01, 0x1B, 0xA3, 0xF1, 0x08, 0x1E, 0x68, + 0xAD, 0x38, 0xD9, 0x82, 0x6F, 0x60, 0x63, 0x74, 0xAD, 0x74, 0x0C, 0x45, + 0x31, 0x6C, 0x97, 0x00, 0x20, 0xFE, 0x69, 0xD4, 0x5A, 0xF9, 0xCC, 0x02, + 0x00, 0xA6, 0xDE, 0xE5, 0xA1, 0xB7, 0x9C, 0x79, 0x49, 0x0B, 0x47, 0x39, + 0x05, 0xB3, 0x59, 0xFC, 0x5F, 0xB2, 0x81, 0x41, 0x1E, 0x8A, 0x9C, 0x95, + 0xD4, 0x56, 0x4A, 0xE0, 0xB6, 0x44, 0x66, 0x04, 0x40, 0xC8, 0x4A, 0x28, + 0xB8, 0x88, 0xA2, 0x16, 0x26, 0xE0, 0x8E, 0x7C, 0x39, 0x32, 0x39, 0x13, + 0x52, 0x46, 0xA4, 0x5C, 0x8A, 0x94, 0x52, 0x09, 0x23, 0xA5, 0xAC, 0x58, + 0xC7, 0xA9, 0x74, 0x6D, 0xDB, 0x38, 0x77, 0xB7, 0xD9, 0x01, 0x41, 0xAD, + 0x18, 0x42, 0xE4, 0x63, 0x45, 0x4A, 0x39, 0xF4, 0xDD, 0xD9, 0xC9, 0xF2, + 0xE5, 0xE5, 0x2D, 0x09, 0x69, 0x8D, 0x14, 0x42, 0xE4, 0x9C, 0xD9, 0xEC, + 0x2E, 0x85, 0xCC, 0xB5, 0x00, 0x1C, 0x2A, 0xDA, 0x78, 0x79, 0xAC, 0x48, + 0x42, 0x08, 0x6B, 0x4C, 0xA9, 0x95, 0xC3, 0xF2, 0x7A, 0x29, 0xB5, 0x56, + 0x7C, 0x32, 0x2A, 0x21, 0x39, 0x92, 0x04, 0x0F, 0x23, 0xCF, 0x41, 0x17, + 0xCA, 0x08, 0x5A, 0xC1, 0xC3, 0xDF, 0xA3, 0xA4, 0xCC, 0xB9, 0xDC, 0x6F, + 0xF6, 0xE7, 0xA7, 0x8B, 0xB7, 0xD7, 0x3B, 0xA1, 0x15, 0xD4, 0x9A, 0x4B, + 0x19, 0xBD, 0x07, 0x21, 0x9E, 0x5E, 0x9C, 0x0F, 0x7D, 0x3B, 0x79, 0xFF, + 0x4F, 0xBF, 0xFE, 0xE2, 0xFA, 0x76, 0xF3, 0xD3, 0x1F, 0x7D, 0x64, 0xAD, + 0xFD, 0xC5, 0xAF, 0x3E, 0x5B, 0x2D, 0x87, 0xF3, 0xF3, 0xD3, 0xC6, 0x39, + 0x63, 0xF4, 0x07, 0xEF, 0x3F, 0xDF, 0x6E, 0xF7, 0x08, 0xE0, 0x00, 0x7C, + 0xDF, 0x6F, 0xB6, 0xFB, 0xB3, 0x93, 0xF3, 0xE0, 0xD2, 0x67, 0x9F, 0x7F, + 0xFD, 0xDD, 0xAB, 0xB7, 0xC3, 0xD0, 0x9D, 0x9F, 0x9E, 0x7E, 0xF0, 0xDE, + 0xF3, 0x71, 0xF6, 0x6D, 0xD3, 0x86, 0x94, 0x37, 0xBB, 0x91, 0xA7, 0x5B, + 0x2D, 0xE5, 0xB7, 0xAF, 0xDE, 0xB4, 0x8D, 0x53, 0x4A, 0xEF, 0xF7, 0x53, + 0x48, 0xB1, 0x6D, 0x5A, 0xAD, 0xD5, 0xD3, 0x8B, 0xB3, 0x9C, 0x72, 0x2A, + 0x65, 0xBB, 0xDD, 0xD7, 0x8A, 0xBB, 0x71, 0x26, 0x80, 0xFD, 0x34, 0x57, + 0x44, 0xEE, 0x73, 0x62, 0x18, 0x8B, 0xD5, 0x94, 0xB9, 0x54, 0xAD, 0x4D, + 0x29, 0x75, 0x9A, 0x3D, 0x21, 0x36, 0xAD, 0x23, 0xA2, 0x5C, 0xEA, 0xEC, + 0x63, 0xDB, 0x3A, 0x29, 0x94, 0x52, 0x4A, 0xA3, 0xAE, 0x15, 0x39, 0xC7, + 0x62, 0x9C, 0x7C, 0x2A, 0x45, 0x0A, 0xBE, 0x15, 0xC4, 0x30, 0xB4, 0x6D, + 0xD3, 0x30, 0x0B, 0x5F, 0x11, 0xE7, 0x10, 0xB5, 0x92, 0x0C, 0x69, 0x31, + 0x7D, 0x2C, 0x15, 0xA7, 0x36, 0x96, 0xA3, 0x64, 0x9A, 0xB4, 0xD1, 0x9C, + 0xF9, 0x9C, 0x4B, 0x05, 0x10, 0xE3, 0x1C, 0xA4, 0x92, 0xA5, 0x14, 0x09, + 0x60, 0xE6, 0xA0, 0xB5, 0x04, 0x40, 0xD7, 0x34, 0x42, 0xAA, 0xBB, 0xFB, + 0x5D, 0x29, 0x85, 0x58, 0x5A, 0x58, 0x2B, 0x2F, 0x34, 0x52, 0x8E, 0xF3, + 0x34, 0x5F, 0x5D, 0xDF, 0x35, 0x8D, 0xCD, 0x39, 0x95, 0xEA, 0x72, 0xC1, + 0x2F, 0xBF, 0x7E, 0x39, 0xFB, 0x60, 0xAD, 0x99, 0xBD, 0x27, 0x82, 0x94, + 0xB3, 0x56, 0x6A, 0xE8, 0xBB, 0x10, 0xA3, 0x7E, 0xF6, 0xF4, 0x6C, 0xB3, + 0x9D, 0xA7, 0xC9, 0xFB, 0x29, 0xCC, 0xDE, 0x4F, 0xD3, 0xE4, 0x7D, 0xB0, + 0xC6, 0x70, 0xEF, 0xC3, 0x66, 0xBB, 0x4F, 0x31, 0x29, 0x25, 0x9E, 0x3D, + 0x3E, 0xB7, 0x5A, 0x03, 0xD0, 0x72, 0x68, 0x6F, 0xEE, 0xB6, 0x5D, 0xDB, + 0x6A, 0x25, 0xDF, 0x79, 0x72, 0x6E, 0x8C, 0x6E, 0x1B, 0xD7, 0xB5, 0xCD, + 0xA2, 0xEB, 0xBE, 0x7E, 0xF9, 0xE6, 0x7E, 0xB3, 0x2B, 0x54, 0x95, 0x10, + 0x27, 0xEB, 0xE5, 0x7A, 0x35, 0x70, 0x1B, 0x90, 0xD6, 0xBA, 0x12, 0x71, + 0xA9, 0xA5, 0x94, 0xB2, 0x20, 0x59, 0xA3, 0x88, 0x68, 0xF6, 0x51, 0x08, + 0x91, 0x52, 0xDE, 0x8F, 0x23, 0x22, 0xDD, 0xDE, 0x6D, 0xDB, 0xC6, 0xBD, + 0xFB, 0xD1, 0x8B, 0xA1, 0x6B, 0x63, 0x3E, 0x34, 0xB6, 0x2A, 0x25, 0x8D, + 0xD5, 0x00, 0xC2, 0x39, 0x2B, 0x95, 0xC4, 0xCA, 0x78, 0x30, 0x70, 0x3A, + 0x4A, 0x45, 0x9C, 0x7C, 0xCC, 0x0C, 0x4B, 0xC6, 0xDC, 0x35, 0x8E, 0x88, + 0x52, 0x4A, 0x67, 0x27, 0xCB, 0xA1, 0x6F, 0x19, 0x09, 0x0A, 0x3E, 0x71, + 0xA1, 0x6F, 0xC5, 0xCA, 0x17, 0x91, 0x94, 0x22, 0xE5, 0xDC, 0xDA, 0x3E, + 0xE6, 0xFA, 0xFA, 0x9B, 0x2F, 0x90, 0xC4, 0x38, 0xCF, 0xB6, 0x69, 0x01, + 0x6A, 0xD8, 0xED, 0x53, 0x0C, 0x4D, 0xD3, 0x08, 0xD7, 0x4F, 0xD3, 0x6C, + 0xAD, 0xB3, 0xCE, 0x6E, 0x6F, 0x6E, 0x73, 0xC9, 0xCA, 0xB8, 0x0F, 0x3E, + 0xF8, 0xE0, 0x4D, 0xE9, 0xE7, 0x71, 0x6C, 0x9B, 0xA6, 0xEB, 0xDA, 0xE5, + 0xD0, 0xDE, 0xDD, 0xEF, 0xA7, 0xC9, 0x33, 0xB4, 0xB7, 0x5E, 0x2D, 0x88, + 0x28, 0xC6, 0xBC, 0x5A, 0x2D, 0xB0, 0x62, 0x88, 0xD1, 0x5A, 0x5B, 0x4A, + 0x09, 0x21, 0xFA, 0x10, 0xB5, 0xD6, 0x5C, 0xC1, 0xE8, 0xAC, 0x2D, 0x58, + 0x63, 0x2A, 0x58, 0x0F, 0x0A, 0x03, 0x73, 0xB4, 0xE6, 0x6A, 0xA5, 0x94, + 0x62, 0xDF, 0xBB, 0x92, 0xA5, 0x96, 0x5C, 0x85, 0x40, 0x3E, 0x92, 0x52, + 0xCA, 0x52, 0x0A, 0x44, 0x7B, 0x0C, 0x1E, 0x08, 0xFC, 0x9D, 0x3A, 0x67, + 0x04, 0x88, 0xA1, 0x53, 0xFC, 0x90, 0x09, 0xC1, 0xC0, 0x10, 0xA3, 0x63, + 0x07, 0x4D, 0x06, 0x1E, 0xDB, 0xB4, 0xE8, 0x98, 0x2A, 0x25, 0x84, 0x13, + 0xA2, 0x94, 0x52, 0x52, 0xCE, 0xBC, 0xFC, 0xD5, 0x63, 0xB6, 0x00, 0x10, + 0x29, 0x29, 0x19, 0x8E, 0x04, 0x00, 0x02, 0xA1, 0xA4, 0x96, 0x56, 0x12, + 0x41, 0xCE, 0xDC, 0xB6, 0x89, 0x47, 0xE5, 0x86, 0x00, 0x22, 0x65, 0xAC, + 0x32, 0x96, 0x52, 0xD8, 0x7C, 0xF1, 0x0B, 0xEF, 0x83, 0x8F, 0xB1, 0x1F, + 0x86, 0xA6, 0x6B, 0x05, 0x80, 0x6D, 0x1A, 0xB7, 0x58, 0x75, 0xFD, 0x20, + 0x95, 0x06, 0xD3, 0x10, 0x40, 0xC9, 0x51, 0x3C, 0x48, 0xAD, 0x80, 0x40, + 0x40, 0x0C, 0x09, 0x0E, 0x37, 0x39, 0x5A, 0x6B, 0xD8, 0x01, 0xC0, 0x40, + 0x9E, 0xB6, 0x06, 0x09, 0x95, 0x52, 0xDA, 0x28, 0xF4, 0x20, 0x89, 0xAC, + 0x31, 0x15, 0xA1, 0x56, 0xFA, 0xE6, 0xD5, 0x15, 0x97, 0xC4, 0xF3, 0x27, + 0x2B, 0x25, 0x8B, 0xD4, 0xD1, 0xE7, 0xC4, 0xEF, 0x5E, 0x2E, 0x85, 0x31, + 0xAC, 0xE4, 0x03, 0x09, 0x58, 0x74, 0x1D, 0x01, 0x69, 0xA9, 0x99, 0xD6, + 0x60, 0x9A, 0x8C, 0xD5, 0x00, 0x24, 0x15, 0x86, 0x90, 0x52, 0x96, 0x4A, + 0x5A, 0xAB, 0x1F, 0xDC, 0x05, 0x09, 0x09, 0xB1, 0xC2, 0x51, 0xBE, 0x6B, + 0x8C, 0x29, 0xA5, 0xEC, 0xC7, 0xB9, 0xB1, 0x9A, 0xA7, 0x4F, 0xC6, 0x07, + 0x4A, 0x29, 0x21, 0xC6, 0x5A, 0xEB, 0x62, 0x18, 0x94, 0x52, 0x80, 0x78, + 0xBF, 0xDD, 0xFF, 0x2F, 0xFF, 0xFB, 0x5F, 0xBC, 0xFF, 0xE2, 0xE9, 0xBF, + 0xFA, 0x8F, 0x7E, 0xBC, 0xDD, 0xEE, 0xFF, 0xEE, 0x1F, 0x7F, 0xA5, 0x95, + 0x22, 0x21, 0xDE, 0x79, 0x7A, 0x21, 0x85, 0xB4, 0xD6, 0x38, 0xE7, 0xAE, + 0x6E, 0x6E, 0x17, 0x8B, 0xDE, 0x87, 0x20, 0x95, 0x4C, 0xB9, 0xB4, 0x4D, + 0x93, 0x73, 0xB9, 0xDF, 0xEE, 0xAC, 0x31, 0x9B, 0xCD, 0x6E, 0xB7, 0x1B, + 0x8D, 0xB1, 0xDF, 0xBD, 0xBA, 0x7C, 0xFE, 0xF4, 0xC2, 0x87, 0xE0, 0x7D, + 0x90, 0x42, 0x6E, 0x76, 0xA3, 0x56, 0x2A, 0xE7, 0x32, 0xCF, 0x5E, 0x0A, + 0xB9, 0x5E, 0x9D, 0x5B, 0x6B, 0x57, 0xCB, 0xC5, 0xED, 0xDD, 0xE6, 0xFA, + 0xF6, 0x7E, 0x9A, 0x03, 0x03, 0x61, 0x31, 0x25, 0xDE, 0xB7, 0x8C, 0xD6, + 0xDC, 0x1F, 0xAA, 0xA4, 0xDA, 0x4F, 0x53, 0xD7, 0x34, 0xE3, 0xEC, 0x85, + 0x10, 0x7D, 0xEB, 0x5A, 0x67, 0xA7, 0xC9, 0x8F, 0xE3, 0x6C, 0xAD, 0x25, + 0x00, 0x6B, 0xD4, 0x6A, 0x31, 0xE8, 0x43, 0x0E, 0x07, 0x10, 0xC0, 0x38, + 0xCD, 0xDB, 0x71, 0xAA, 0x88, 0x47, 0x2D, 0x9E, 0xF0, 0x31, 0x35, 0xCE, + 0x23, 0xA2, 0x90, 0x0A, 0x2B, 0xB6, 0xD5, 0x4A, 0x29, 0x1A, 0x6B, 0x18, + 0xD7, 0xE4, 0x69, 0x40, 0x4A, 0x09, 0x74, 0xB0, 0x6A, 0x19, 0xAD, 0x6B, + 0x9D, 0x84, 0x00, 0x6B, 0x4C, 0x4C, 0x55, 0x08, 0xA8, 0x58, 0xA7, 0x79, + 0x56, 0x4A, 0x72, 0xFA, 0x40, 0xDF, 0x35, 0xDC, 0x9D, 0xF9, 0xE4, 0x64, + 0xBD, 0xDB, 0xEF, 0x6F, 0x6E, 0xEF, 0x40, 0x88, 0xB6, 0x69, 0x7C, 0xC9, + 0x97, 0x97, 0xD7, 0x6F, 0xAF, 0x6E, 0xDE, 0x7D, 0xE7, 0x29, 0x11, 0xDD, + 0xDC, 0xDC, 0x6B, 0xAD, 0x17, 0x8B, 0xFE, 0xF1, 0xC5, 0xF9, 0xCD, 0xED, + 0x66, 0xB3, 0xDD, 0x29, 0xAD, 0xA6, 0x79, 0x3E, 0xA0, 0xAE, 0x44, 0x3C, + 0xC7, 0x29, 0x29, 0xF4, 0xD5, 0xCD, 0x36, 0xC5, 0x74, 0x73, 0x77, 0x97, + 0x52, 0xF6, 0x21, 0xAC, 0x57, 0x0B, 0xA9, 0x54, 0x08, 0x31, 0xC6, 0x34, + 0x8E, 0x13, 0x1C, 0x9F, 0x2A, 0x21, 0xC4, 0xF9, 0xE9, 0xAA, 0x6B, 0x9B, + 0xDD, 0x38, 0x3E, 0x7B, 0xF2, 0xA8, 0xEF, 0xDA, 0xFB, 0xFB, 0xAD, 0x35, + 0x7A, 0xB5, 0x5E, 0xA6, 0x54, 0xDE, 0x5E, 0xDD, 0xD5, 0x5A, 0xAD, 0x31, + 0x5D, 0xD3, 0x34, 0x8D, 0xEB, 0xBB, 0xC6, 0x18, 0x3D, 0x87, 0x34, 0xCE, + 0xA1, 0x56, 0xBC, 0xBB, 0xDF, 0xE5, 0x52, 0xE7, 0x39, 0x72, 0x7E, 0x29, + 0x83, 0x7C, 0xBB, 0xC9, 0x07, 0x1F, 0xAE, 0x88, 0xD6, 0xEB, 0x05, 0x01, + 0x5C, 0xDF, 0x6E, 0xAD, 0x35, 0xEF, 0x3C, 0xBB, 0x58, 0xF4, 0xBD, 0x75, + 0xDA, 0x38, 0xAB, 0x0F, 0xEA, 0x3B, 0xA3, 0x95, 0x42, 0xE0, 0x4E, 0x1A, + 0x41, 0x48, 0x5A, 0x6B, 0x8E, 0xA9, 0xA4, 0x83, 0x04, 0xA9, 0x7A, 0x1F, + 0x43, 0x4C, 0xDE, 0xFB, 0xAE, 0xB5, 0xAD, 0x73, 0x15, 0x79, 0x31, 0xB1, + 0x4A, 0x48, 0x42, 0x0A, 0x29, 0x97, 0x52, 0xE4, 0xEF, 0x07, 0x45, 0x91, + 0x00, 0x2A, 0xE8, 0x7A, 0xD4, 0xED, 0xEB, 0x2F, 0x7E, 0x3D, 0x9C, 0x3D, + 0xDE, 0xEF, 0x77, 0xFB, 0xDD, 0xFD, 0xB0, 0x3A, 0x7F, 0xFA, 0xEC, 0xC5, + 0x9B, 0x5A, 0x56, 0xEF, 0x7C, 0x78, 0xB7, 0xB9, 0x5B, 0x10, 0x9C, 0x9C, + 0x3D, 0x52, 0xC6, 0xF9, 0x79, 0xCA, 0x39, 0xAD, 0x56, 0x27, 0xCB, 0xD3, + 0xB3, 0x71, 0x96, 0xCE, 0xA8, 0xAE, 0x6D, 0xD8, 0x0A, 0x3B, 0xCD, 0xF1, + 0xEC, 0x64, 0xD5, 0x36, 0xAE, 0x6B, 0xDB, 0xAE, 0x6D, 0x63, 0x4A, 0x5A, + 0x1B, 0x67, 0x4D, 0x4C, 0xA9, 0xD4, 0xB2, 0xDF, 0x4F, 0x5A, 0xEB, 0x94, + 0xE3, 0x38, 0xFB, 0xB6, 0x71, 0xAC, 0x4E, 0x98, 0x43, 0xD8, 0xEF, 0xE7, + 0xC9, 0x7B, 0x00, 0x32, 0x46, 0x61, 0x25, 0x29, 0x0F, 0xD6, 0x3C, 0x21, + 0x04, 0x2B, 0xBC, 0xD9, 0x8A, 0x5C, 0x0A, 0x5A, 0xAB, 0xE7, 0xD9, 0x23, + 0x12, 0xFB, 0x2E, 0x95, 0x4E, 0x07, 0x8C, 0xBC, 0x56, 0x00, 0xD0, 0xA0, + 0x10, 0xC1, 0x59, 0x7D, 0xA0, 0x0B, 0x4A, 0x71, 0x46, 0xB3, 0x86, 0x80, + 0x65, 0x8C, 0x4A, 0x29, 0x63, 0x14, 0x80, 0xC1, 0x07, 0x7C, 0x9B, 0x48, + 0x08, 0xC1, 0x4A, 0x54, 0xEE, 0x12, 0x86, 0x43, 0xFC, 0xB4, 0xC0, 0x83, + 0x20, 0x5F, 0x54, 0x02, 0xAA, 0x28, 0x84, 0x40, 0xA4, 0x5A, 0xB1, 0xD4, + 0x0A, 0xE5, 0xE0, 0xF4, 0xAE, 0x87, 0x3E, 0x47, 0x09, 0x20, 0x80, 0x50, + 0xB9, 0x36, 0xDF, 0x5D, 0x4E, 0x6F, 0xBE, 0x0E, 0xB7, 0xAF, 0xAE, 0xBE, + 0xFB, 0xB2, 0x48, 0x55, 0x10, 0x04, 0x80, 0x31, 0x3A, 0xE7, 0x8A, 0x20, + 0x96, 0xA7, 0xA7, 0xAB, 0xF5, 0xAA, 0x94, 0x22, 0x9B, 0xE1, 0xD9, 0x47, + 0x3F, 0x39, 0x7B, 0xF1, 0xFD, 0x52, 0x92, 0x20, 0x3C, 0xCA, 0x47, 0x65, + 0xAE, 0xBC, 0xCB, 0x08, 0xC9, 0xD6, 0xE5, 0x5A, 0xA7, 0xC9, 0xE7, 0x82, + 0x15, 0x23, 0x08, 0xD1, 0xB5, 0x6D, 0xA9, 0x34, 0x0C, 0x3D, 0x0B, 0x02, + 0x78, 0xCA, 0x20, 0x44, 0x6B, 0x54, 0xA9, 0x35, 0xE6, 0xC2, 0x16, 0xD4, + 0x94, 0x0A, 0x3B, 0x9F, 0x0B, 0x56, 0xCD, 0xAB, 0xAD, 0xD2, 0xBC, 0xC5, + 0x6A, 0x46, 0x67, 0x6A, 0x9D, 0x43, 0x64, 0xEE, 0x32, 0xE5, 0xA2, 0x4A, + 0x15, 0x00, 0x21, 0x46, 0x25, 0x84, 0xED, 0xB4, 0x35, 0x7A, 0xE8, 0x5B, + 0x22, 0x6A, 0x1A, 0x27, 0x85, 0x08, 0x29, 0x0B, 0x01, 0x8D, 0xB3, 0x73, + 0x88, 0x8C, 0x62, 0xD3, 0x31, 0x69, 0x1A, 0x09, 0xEF, 0x36, 0x63, 0x2E, + 0x85, 0x38, 0xA1, 0xFB, 0x68, 0x81, 0x48, 0x39, 0xEF, 0xC6, 0xD1, 0x5A, + 0x5B, 0x10, 0x87, 0xA1, 0x8B, 0xA9, 0x7C, 0xF1, 0xF5, 0xAB, 0xCD, 0x6E, + 0xFC, 0x93, 0x9F, 0xFC, 0xE0, 0xC9, 0xC5, 0xF9, 0x76, 0xBB, 0x7F, 0x7B, + 0x7D, 0x77, 0x7B, 0xBB, 0xE5, 0x7B, 0x65, 0xB9, 0x5C, 0x58, 0x6B, 0xFE, + 0xE4, 0xA7, 0x3F, 0x7C, 0x74, 0xB6, 0x46, 0xA4, 0x1F, 0x7D, 0xFC, 0xC1, + 0xDB, 0xCB, 0xDB, 0x2F, 0xBF, 0x7A, 0x49, 0x00, 0x52, 0x8A, 0xBB, 0xBB, + 0x7B, 0x9F, 0xD2, 0x34, 0x79, 0x44, 0x7C, 0x73, 0x79, 0xC3, 0xAF, 0x24, + 0x12, 0x4D, 0x93, 0x1F, 0x86, 0x6E, 0xF6, 0xC1, 0x39, 0xBB, 0xE8, 0xBB, + 0xFB, 0xCD, 0x6E, 0x31, 0xF4, 0x67, 0xEB, 0x65, 0xE8, 0xDA, 0xCD, 0x76, + 0x94, 0x32, 0x57, 0x44, 0x1F, 0x53, 0xA9, 0xA8, 0x95, 0xE6, 0x3B, 0x9B, + 0xBF, 0xC0, 0x52, 0x51, 0x08, 0xAE, 0x31, 0x54, 0xE7, 0x27, 0xAB, 0xC6, + 0xD9, 0x39, 0x84, 0x9C, 0xF3, 0x72, 0x18, 0x42, 0x0C, 0x73, 0x48, 0x8B, + 0xBE, 0x65, 0x9F, 0x03, 0xD7, 0x89, 0x01, 0xC8, 0xFD, 0x34, 0x85, 0x10, + 0x95, 0xE6, 0xF6, 0x29, 0x2E, 0xAC, 0xCB, 0x53, 0xC5, 0x8A, 0x68, 0x8D, + 0x31, 0x46, 0x03, 0x40, 0xDB, 0x3A, 0x09, 0xC0, 0x81, 0xE3, 0x88, 0x35, + 0x85, 0x22, 0x04, 0xB8, 0xC6, 0x02, 0x40, 0x08, 0xC1, 0x13, 0xD4, 0x5A, + 0xD8, 0x09, 0xED, 0x9C, 0x49, 0x6C, 0x05, 0x03, 0x3A, 0x66, 0x64, 0xD6, + 0x69, 0x0E, 0xAE, 0xB1, 0xB7, 0x77, 0x9B, 0x71, 0x9C, 0x9D, 0x73, 0x8F, + 0x2F, 0xCE, 0x5F, 0xBF, 0xB9, 0xBA, 0xBC, 0xBC, 0x11, 0x42, 0x20, 0xD0, + 0xE8, 0xC3, 0xFD, 0x66, 0xAB, 0x15, 0x6B, 0xD6, 0x60, 0x37, 0x8E, 0x5F, + 0x7F, 0xFB, 0xEA, 0xFC, 0xFC, 0x44, 0x6B, 0x19, 0x53, 0x94, 0x52, 0x86, + 0x10, 0x16, 0xC3, 0x50, 0x73, 0xF9, 0xE5, 0xAF, 0x3F, 0x5B, 0x2E, 0x16, + 0x5A, 0x2B, 0xF5, 0xA3, 0x3F, 0xFE, 0x37, 0x77, 0x9B, 0x4D, 0xCA, 0xF9, + 0x64, 0xBD, 0xEA, 0xBB, 0xD6, 0x87, 0x94, 0x73, 0x0A, 0x21, 0xFA, 0x18, + 0x09, 0x88, 0x5B, 0x3C, 0x80, 0xA0, 0x6F, 0x9B, 0x8B, 0xF3, 0x35, 0x37, + 0xD4, 0xC7, 0x94, 0x6F, 0xEE, 0xB6, 0xB3, 0x4F, 0x31, 0xD7, 0xCD, 0x6E, + 0xFC, 0xE6, 0xE5, 0x9B, 0xD7, 0x6F, 0xAF, 0xAD, 0x35, 0x43, 0xDF, 0x2D, + 0x97, 0xFD, 0xD0, 0x77, 0x29, 0xE7, 0xFD, 0x7E, 0xF2, 0x21, 0x4A, 0x29, + 0xA7, 0xD9, 0xCF, 0x3E, 0xB0, 0xA4, 0xA0, 0xEB, 0x9A, 0xB6, 0x6D, 0x94, + 0x92, 0xDB, 0xDD, 0x78, 0x7B, 0xB7, 0xD9, 0x8F, 0x93, 0xB3, 0xF6, 0xEC, + 0x64, 0x25, 0x40, 0xDC, 0x6E, 0x76, 0xDF, 0xFF, 0xF0, 0xF9, 0xD3, 0x27, + 0xE7, 0xD6, 0x99, 0xC6, 0x19, 0xA3, 0x15, 0x48, 0x29, 0x95, 0x04, 0x10, + 0x52, 0x31, 0x35, 0x21, 0x98, 0x53, 0x63, 0xD4, 0xE3, 0xC1, 0x5B, 0xE3, + 0x63, 0xDE, 0xEE, 0xC6, 0x79, 0x9A, 0x17, 0x8B, 0xEE, 0xEC, 0x74, 0xE5, + 0xAC, 0xE1, 0x04, 0x5E, 0xAD, 0x64, 0x2E, 0x25, 0x1F, 0x22, 0x62, 0x2A, + 0xBF, 0xC0, 0xE9, 0x68, 0xCD, 0x22, 0x80, 0x9C, 0x8B, 0x6B, 0x86, 0xE9, + 0xE6, 0xF5, 0xCD, 0xFD, 0xED, 0xFD, 0xED, 0x35, 0x46, 0xFF, 0xC1, 0x0F, + 0x7F, 0x9A, 0x36, 0xD7, 0xFB, 0xFB, 0x9B, 0xD5, 0x8B, 0xEF, 0xDF, 0xDF, + 0x5C, 0xAF, 0xCF, 0xCE, 0xCF, 0x1F, 0x3F, 0xD3, 0x52, 0x7F, 0xFA, 0xF3, + 0xBF, 0xFE, 0xF2, 0xD3, 0x5F, 0x9C, 0x9F, 0x9C, 0x3C, 0xFD, 0xFE, 0x9F, + 0x04, 0x52, 0x6D, 0x63, 0x9D, 0x63, 0xFC, 0xDE, 0x9E, 0x9E, 0xAC, 0xDA, + 0xC6, 0x0D, 0x43, 0xB7, 0xE8, 0x3B, 0x38, 0xA8, 0xA5, 0x8E, 0x5E, 0x42, + 0xAD, 0x84, 0x90, 0xDA, 0x98, 0xA6, 0xB1, 0x42, 0x08, 0x4E, 0x6D, 0x65, + 0xDB, 0x6D, 0xCE, 0xC5, 0x19, 0xC3, 0x91, 0x32, 0x00, 0xE0, 0x43, 0xEC, + 0xBB, 0xB6, 0x6D, 0xD9, 0xA7, 0x52, 0x10, 0xB9, 0xF2, 0x47, 0x38, 0xB6, + 0x2F, 0x18, 0x56, 0xD9, 0x60, 0x8C, 0xA9, 0x14, 0xEE, 0xB8, 0x05, 0x56, + 0x24, 0x6A, 0xA5, 0x9C, 0xD5, 0x42, 0x08, 0x29, 0x40, 0x49, 0x69, 0x8D, + 0xB6, 0xF6, 0x90, 0x81, 0x25, 0x25, 0x2B, 0x9D, 0x05, 0x2F, 0x71, 0xB9, + 0x1E, 0x5A, 0x43, 0x84, 0x90, 0x0C, 0x81, 0xE5, 0x9C, 0xB9, 0x12, 0xFC, + 0xC0, 0x84, 0x62, 0x7D, 0xA0, 0x23, 0xC5, 0xD1, 0x01, 0xC9, 0x12, 0x22, + 0xFE, 0x53, 0x3C, 0x49, 0x21, 0x21, 0x12, 0x20, 0x92, 0x00, 0x12, 0xB6, + 0xAD, 0xAF, 0x3F, 0xFB, 0xEE, 0x3F, 0xFC, 0x6F, 0x9F, 0x7D, 0xFA, 0x8B, + 0xCB, 0x9B, 0xBB, 0x04, 0x4A, 0x6A, 0x33, 0x2C, 0x57, 0x15, 0x20, 0xE5, + 0xBA, 0x8F, 0x79, 0x0C, 0x71, 0x9E, 0xFD, 0xDE, 0xC7, 0x5C, 0xCA, 0xF6, + 0xE6, 0xED, 0xAB, 0xCF, 0x7F, 0x25, 0x52, 0xEC, 0xD7, 0x8F, 0x84, 0xB1, + 0x84, 0x15, 0x00, 0x72, 0xAE, 0xE3, 0x34, 0x4F, 0x53, 0x20, 0xA2, 0x9C, + 0x4A, 0xCC, 0x99, 0xDB, 0x42, 0x4B, 0x41, 0xEF, 0x63, 0xCA, 0x19, 0x84, + 0xE0, 0x6C, 0x1F, 0x10, 0x72, 0xF6, 0xBE, 0x6D, 0x9A, 0xB6, 0x71, 0x21, + 0x46, 0x1F, 0x52, 0xCC, 0x25, 0xE6, 0x02, 0x02, 0x24, 0x40, 0x2C, 0x55, + 0x2A, 0x59, 0x91, 0xA4, 0x90, 0x20, 0x84, 0xD2, 0x3A, 0xE7, 0x82, 0x88, + 0x52, 0x49, 0xAD, 0x35, 0x10, 0x4C, 0x3E, 0x10, 0x40, 0xDF, 0xB5, 0x7D, + 0xE3, 0x8E, 0x1A, 0x76, 0x6A, 0x9D, 0x3D, 0x59, 0x2F, 0x1B, 0x67, 0x39, + 0xC1, 0x89, 0x9D, 0x3D, 0x5A, 0x2B, 0xD6, 0x9D, 0x6B, 0xA5, 0x8C, 0xD2, + 0xD6, 0x68, 0xA3, 0x35, 0x67, 0x96, 0xF2, 0x5F, 0xC5, 0x8A, 0xCD, 0x07, + 0x12, 0x56, 0x08, 0x41, 0x04, 0xB9, 0x30, 0x10, 0x4F, 0x1C, 0x40, 0x94, + 0x4B, 0x95, 0x52, 0x94, 0x52, 0xBE, 0x7D, 0xF9, 0xF6, 0xE2, 0xD1, 0xE9, + 0xBB, 0xCF, 0x9F, 0xC4, 0x94, 0xAF, 0x6F, 0x36, 0xDB, 0xED, 0x9E, 0xE1, + 0x8E, 0x57, 0xAF, 0x2F, 0xBF, 0xF8, 0xFA, 0x25, 0x01, 0x6C, 0xF6, 0x13, + 0x0F, 0xCE, 0x6F, 0x2F, 0x6F, 0x63, 0x8C, 0x3F, 0xF8, 0xF0, 0xDD, 0xCF, + 0xBE, 0xF8, 0xE6, 0xE6, 0x76, 0xA3, 0xA4, 0xEC, 0xDA, 0x96, 0xFD, 0xF0, + 0x52, 0x48, 0xEB, 0x6C, 0x0C, 0xC1, 0xFB, 0xA0, 0x8D, 0xE6, 0xE4, 0x55, + 0x1F, 0xC2, 0x34, 0x7B, 0x9E, 0x0F, 0xF6, 0xE3, 0xB4, 0x1D, 0xA7, 0x10, + 0x73, 0x2A, 0x15, 0x8E, 0x94, 0x8B, 0xB3, 0x26, 0xE7, 0x5A, 0xB1, 0x76, + 0x8D, 0x5B, 0x74, 0xCD, 0xA2, 0x6F, 0xD6, 0x43, 0x0F, 0x70, 0x40, 0x24, + 0x95, 0x94, 0xB9, 0xD6, 0x10, 0xE3, 0xD0, 0xB6, 0x52, 0xCA, 0x71, 0x9C, + 0x53, 0xCE, 0x4A, 0xAA, 0xBB, 0xED, 0x6E, 0xB7, 0x9F, 0xB4, 0xD6, 0xF6, + 0xE8, 0xAB, 0x4F, 0x29, 0x1B, 0x63, 0x9C, 0x73, 0xA3, 0xF7, 0x9C, 0xEE, + 0x07, 0x88, 0xBB, 0xFD, 0x28, 0x85, 0xF0, 0x21, 0xF2, 0x4D, 0x59, 0x0A, + 0xA7, 0x8F, 0x1D, 0xF2, 0x5A, 0x4B, 0xAE, 0x31, 0xA6, 0x54, 0x4A, 0x2E, + 0x95, 0x43, 0x05, 0x72, 0x2E, 0xB9, 0x64, 0xAC, 0x15, 0x2B, 0xC3, 0x29, + 0x62, 0xBD, 0x5E, 0x4A, 0x21, 0x89, 0x28, 0x97, 0x12, 0x52, 0x2C, 0xA5, + 0x2C, 0x86, 0x5E, 0x48, 0xB1, 0xDB, 0x8F, 0x95, 0x50, 0x4A, 0x85, 0x87, + 0x00, 0x6E, 0x02, 0x20, 0x4E, 0xA3, 0xAD, 0xB9, 0x3C, 0x3A, 0x3F, 0x63, + 0x56, 0x61, 0x1C, 0xE7, 0x52, 0x2A, 0x10, 0x6C, 0x77, 0xFB, 0x9B, 0xDB, + 0xFB, 0xC9, 0x07, 0x6D, 0x8C, 0x1A, 0x16, 0xA7, 0xA5, 0xD6, 0xCD, 0x76, + 0x37, 0x8E, 0xE3, 0x83, 0x07, 0xA5, 0x16, 0xCE, 0xCC, 0x26, 0x05, 0x82, + 0x88, 0x62, 0xCA, 0x31, 0x65, 0x70, 0x62, 0x9C, 0xFC, 0xED, 0x66, 0xEF, + 0x7D, 0xB8, 0xB9, 0xDF, 0xD4, 0x72, 0x10, 0xDA, 0xD4, 0x5A, 0x81, 0x44, + 0x2E, 0x35, 0x97, 0xC2, 0x81, 0x62, 0xCB, 0x45, 0x5F, 0x11, 0xDF, 0x5C, + 0xDD, 0x6A, 0xA5, 0x38, 0x3A, 0x7D, 0xBD, 0x5A, 0x18, 0x63, 0x72, 0xC9, + 0xB7, 0xF7, 0xE3, 0x34, 0x86, 0x10, 0x62, 0xC1, 0x0A, 0x00, 0xB5, 0x56, + 0x6B, 0xCD, 0x62, 0xE8, 0xB4, 0xD6, 0x3E, 0xC4, 0x5A, 0xB1, 0x71, 0x46, + 0x49, 0x35, 0xF4, 0x3A, 0xA6, 0x0C, 0x40, 0x0F, 0x8B, 0x12, 0x1E, 0x9B, + 0xAB, 0xD9, 0x3E, 0x53, 0x11, 0x63, 0x2E, 0x44, 0x14, 0x53, 0xCA, 0xA5, + 0xAE, 0x16, 0x03, 0xCB, 0x5F, 0x89, 0x44, 0xCA, 0xF9, 0xFA, 0x6E, 0x2B, + 0xA5, 0xB0, 0x47, 0x3F, 0x85, 0x56, 0x07, 0xEE, 0xAC, 0x22, 0x15, 0x42, + 0xC8, 0x05, 0x11, 0xB5, 0x36, 0xA7, 0xE7, 0x8F, 0x6B, 0xBB, 0x6C, 0x97, + 0x67, 0x17, 0xA7, 0x27, 0xEF, 0xBE, 0xFF, 0xC1, 0xFF, 0xFC, 0x3F, 0xFE, + 0xAF, 0xCF, 0x3F, 0xFA, 0xF1, 0xD0, 0xBA, 0xF5, 0x87, 0x1F, 0xAE, 0xCF, + 0x1F, 0x81, 0xD0, 0x95, 0xA4, 0x52, 0x4A, 0x68, 0xD3, 0x74, 0xCB, 0x29, + 0x0B, 0xEB, 0xB4, 0x3A, 0xDA, 0xD0, 0x18, 0x13, 0x35, 0xC6, 0x38, 0xA7, + 0x59, 0x05, 0x6E, 0xAD, 0x96, 0x52, 0xCD, 0xB3, 0x97, 0x52, 0x19, 0x63, + 0x4E, 0x4E, 0x2C, 0x0F, 0x47, 0x5A, 0xE9, 0x39, 0x04, 0xA5, 0x54, 0xEE, + 0x32, 0x10, 0xCD, 0x21, 0xA5, 0x5C, 0x94, 0x52, 0x31, 0xC6, 0xDD, 0x7E, + 0x34, 0xC6, 0xF0, 0xD9, 0x67, 0xAD, 0x22, 0xE2, 0x76, 0x22, 0x28, 0xA5, + 0xAC, 0x57, 0xC3, 0xB2, 0xEF, 0x79, 0x8C, 0xDA, 0x89, 0x71, 0x9A, 0xBD, + 0xF7, 0x5E, 0x69, 0x6D, 0x8E, 0x58, 0x7D, 0x2E, 0x25, 0x17, 0xA5, 0xB5, + 0x46, 0x82, 0xAE, 0x6B, 0xC4, 0x31, 0xE8, 0x95, 0xD1, 0x74, 0xFE, 0xD4, + 0x58, 0x5C, 0x9A, 0x12, 0x47, 0x12, 0x03, 0xBB, 0xF4, 0x31, 0x97, 0xD9, + 0x87, 0x52, 0x8B, 0x92, 0xCA, 0x54, 0xCC, 0x99, 0x83, 0x23, 0x85, 0x3E, + 0xCC, 0x73, 0x92, 0x89, 0x5D, 0x24, 0xCA, 0x25, 0xB3, 0x3A, 0x14, 0x85, + 0x40, 0x14, 0x48, 0x24, 0x85, 0x40, 0x20, 0x10, 0x86, 0x5E, 0xFD, 0xFA, + 0xF2, 0x1F, 0xFE, 0xAF, 0xEF, 0xAE, 0xB7, 0xF7, 0x53, 0x12, 0x10, 0xC5, + 0x3C, 0x4B, 0xA3, 0xDF, 0xDE, 0xDE, 0x03, 0x01, 0x73, 0x73, 0x48, 0xD8, + 0x34, 0x0D, 0x02, 0x3C, 0x7A, 0xFA, 0xD8, 0xEA, 0xB3, 0xEF, 0xBE, 0xFC, + 0xF2, 0xAF, 0x34, 0x25, 0x98, 0x90, 0x00, 0x00, 0x20, 0x00, 0x49, 0x44, + 0x41, 0x54, 0xFF, 0xF2, 0xFF, 0x78, 0xFE, 0xD5, 0x67, 0x7F, 0xFC, 0x9F, + 0xFE, 0x7B, 0xBB, 0x3C, 0xA1, 0x52, 0x40, 0xC0, 0x72, 0x31, 0xCC, 0x93, + 0xAF, 0x88, 0xA5, 0xA2, 0xF7, 0x9E, 0xBB, 0x27, 0x6A, 0xA9, 0x04, 0x14, + 0x53, 0x51, 0x4A, 0xB9, 0xC6, 0xEE, 0xA7, 0x89, 0x4B, 0x43, 0x66, 0xCF, + 0xCE, 0x1E, 0x48, 0xA5, 0x1E, 0x14, 0xAA, 0x00, 0x05, 0x2B, 0xA7, 0x72, + 0x17, 0xCC, 0x20, 0x25, 0x22, 0x09, 0x81, 0x42, 0x08, 0xAB, 0x75, 0xAE, + 0xD5, 0x97, 0xE4, 0xAC, 0xD3, 0x4A, 0x13, 0x10, 0x61, 0x4D, 0x89, 0x1A, + 0xE7, 0x94, 0x3A, 0x84, 0xD9, 0xF3, 0x3E, 0xCE, 0xE8, 0x9A, 0x31, 0xA6, + 0xD4, 0xEA, 0x77, 0x91, 0x88, 0x94, 0xD6, 0xB5, 0x22, 0x03, 0x67, 0x5A, + 0xE9, 0xD6, 0x39, 0x4F, 0x07, 0x4D, 0x6F, 0xCE, 0x59, 0x4A, 0x69, 0x94, + 0x06, 0x80, 0x4A, 0x08, 0x20, 0x0E, 0x32, 0x62, 0xEE, 0x1D, 0xAE, 0x55, + 0x2A, 0x59, 0x6A, 0x55, 0x5A, 0x9D, 0x9F, 0xAD, 0x25, 0x88, 0xBF, 0xFA, + 0xFB, 0x5F, 0x6D, 0xF7, 0xE3, 0x7B, 0xCF, 0x9F, 0x54, 0xC2, 0x14, 0x33, + 0x56, 0x24, 0x80, 0xC5, 0xD0, 0x85, 0x90, 0xFE, 0x9F, 0xBF, 0xFC, 0x5B, + 0x63, 0xF4, 0xC5, 0xA3, 0xD3, 0xC7, 0xE7, 0xA7, 0x3E, 0x44, 0x22, 0xF8, + 0xE6, 0xBB, 0xB7, 0x3F, 0xF8, 0xE8, 0x7B, 0xDB, 0xED, 0x27, 0x97, 0x57, + 0xB7, 0xF7, 0x76, 0xC7, 0xF7, 0x50, 0x08, 0xBD, 0xB3, 0xC6, 0x35, 0x0D, + 0xC7, 0x31, 0xA6, 0x5C, 0xA4, 0x94, 0x8D, 0xB5, 0x44, 0xB4, 0xD9, 0xEC, + 0x26, 0x1F, 0xC6, 0x39, 0xD4, 0x5A, 0x1B, 0x67, 0x73, 0x29, 0xCE, 0x35, + 0xCB, 0xA1, 0x65, 0xA2, 0x29, 0xE7, 0xC2, 0x67, 0x16, 0xA7, 0xEF, 0x4E, + 0x7E, 0xE2, 0x92, 0x91, 0xBE, 0xEF, 0x88, 0x60, 0x9A, 0x03, 0xEB, 0x04, + 0xBC, 0x0F, 0x5C, 0x3E, 0xDD, 0xB6, 0xB0, 0xE8, 0xFB, 0xC6, 0xD5, 0xF2, + 0x40, 0xE0, 0x54, 0x0C, 0x31, 0x4A, 0xA5, 0x22, 0x73, 0x93, 0x84, 0x9B, + 0xED, 0xEE, 0xFE, 0x7E, 0xDB, 0x38, 0x9B, 0x72, 0x6D, 0xDB, 0xA6, 0x20, + 0x18, 0xAD, 0x6B, 0xC5, 0x4A, 0x58, 0x0B, 0x72, 0xFE, 0xA5, 0x00, 0x91, + 0x72, 0xAA, 0x48, 0x15, 0xC9, 0x9A, 0xDA, 0x36, 0x2E, 0xA6, 0x54, 0x4A, + 0x49, 0xB9, 0x8E, 0xD3, 0x7C, 0x7E, 0xBA, 0xFA, 0xDE, 0x7B, 0xCF, 0x9D, + 0x35, 0x2C, 0xA4, 0xAF, 0xB5, 0x8E, 0x63, 0x91, 0x52, 0x12, 0xD2, 0xD0, + 0xB7, 0x53, 0xDF, 0x4E, 0x3E, 0xE6, 0x54, 0x85, 0x3C, 0xF4, 0x2D, 0x29, + 0x25, 0xBB, 0xAE, 0x19, 0xBA, 0x56, 0x08, 0xE0, 0x0E, 0xB0, 0x18, 0xD3, + 0x38, 0xCE, 0x31, 0x25, 0x25, 0xE4, 0x72, 0x39, 0x48, 0xA5, 0x72, 0x2D, + 0xEA, 0x3F, 0xFF, 0xAF, 0xFE, 0xBB, 0x94, 0xF3, 0xCD, 0xCD, 0xED, 0x34, + 0x4D, 0xEA, 0x98, 0x13, 0x54, 0x8F, 0x35, 0x2A, 0x92, 0x40, 0x4A, 0x79, + 0x7E, 0xB6, 0xFA, 0xC3, 0x8F, 0x3F, 0x38, 0x59, 0x2D, 0x36, 0xBB, 0xF1, + 0xF2, 0x66, 0xF3, 0xE5, 0xB7, 0xAF, 0x6E, 0xEF, 0x36, 0xCC, 0x41, 0xCD, + 0xB3, 0x6F, 0xDB, 0x66, 0xB1, 0xE8, 0x8D, 0xD6, 0x42, 0x8A, 0xC6, 0xD9, + 0xB3, 0xD3, 0xD5, 0x62, 0xE8, 0x84, 0x14, 0x88, 0x6C, 0x5B, 0x83, 0x94, + 0x32, 0x08, 0x68, 0x1A, 0x1B, 0x53, 0x7A, 0x7B, 0x75, 0xB7, 0xDD, 0x4E, + 0x3E, 0x84, 0xDD, 0x38, 0x97, 0x52, 0x8C, 0xD5, 0x67, 0x27, 0xCB, 0x61, + 0xE8, 0x52, 0x2A, 0x39, 0x65, 0x00, 0xA1, 0x8D, 0xB2, 0xD6, 0x54, 0x42, + 0xAB, 0x8D, 0x38, 0x96, 0x39, 0x03, 0x40, 0xC9, 0x95, 0xBD, 0x33, 0x5C, + 0x34, 0xC9, 0x3D, 0x4F, 0x4C, 0x36, 0x8F, 0xD3, 0x9C, 0x52, 0x1E, 0xFA, + 0xAE, 0x6B, 0x5C, 0x48, 0x69, 0xF6, 0xA1, 0xE4, 0x92, 0x62, 0xAE, 0x15, + 0xE7, 0x90, 0x4A, 0x45, 0x21, 0x24, 0x01, 0xB0, 0x92, 0xA8, 0xD4, 0x1A, + 0x42, 0x64, 0xF2, 0x21, 0xA3, 0xC8, 0xFB, 0xCD, 0xDB, 0x6F, 0xBF, 0x58, + 0x3C, 0x7E, 0xF7, 0xF9, 0x07, 0x3F, 0xD8, 0xBC, 0xFA, 0xE2, 0x1F, 0xFE, + 0xC3, 0x9F, 0xFF, 0x67, 0xFF, 0xED, 0xFF, 0xB0, 0x6C, 0xF5, 0xE5, 0xE5, + 0xDB, 0x47, 0x8F, 0x9F, 0x35, 0x8B, 0x33, 0x22, 0x11, 0xC7, 0xFB, 0x79, + 0xBF, 0xFB, 0xE8, 0xA3, 0x3F, 0x18, 0x9E, 0x7D, 0x08, 0x00, 0x42, 0xF1, + 0xAE, 0x2D, 0x89, 0x20, 0xC6, 0xEC, 0xDC, 0xC1, 0x24, 0x6C, 0x8C, 0x6E, + 0x1A, 0x6B, 0x79, 0x7F, 0xD0, 0x92, 0x87, 0x26, 0x22, 0xAA, 0x15, 0xAD, + 0xB5, 0x6D, 0xD3, 0x74, 0x6D, 0xA3, 0x8D, 0xD2, 0x4A, 0x35, 0x8D, 0x35, + 0x47, 0x3B, 0x11, 0xCB, 0x26, 0x59, 0x5F, 0x16, 0x42, 0x44, 0x44, 0xF6, + 0xB4, 0x61, 0xAD, 0x4A, 0x29, 0xA5, 0x15, 0x67, 0x47, 0x18, 0x6D, 0x26, + 0xEF, 0xF7, 0xB3, 0xA7, 0xDF, 0x29, 0x51, 0x0F, 0x86, 0x38, 0x26, 0x89, + 0xAC, 0xD1, 0xC6, 0x18, 0x6B, 0xEC, 0xEF, 0x25, 0xB0, 0x33, 0x8A, 0x5F, + 0x89, 0x80, 0x37, 0xCD, 0xC3, 0x1E, 0x94, 0x72, 0x29, 0x35, 0xA5, 0x74, + 0x20, 0xE9, 0x2A, 0xB2, 0xCF, 0x03, 0x11, 0x73, 0xA9, 0x88, 0x24, 0x40, + 0x80, 0x10, 0xBC, 0xDA, 0x33, 0xBF, 0xCC, 0x73, 0x47, 0xA9, 0x87, 0xB6, + 0x5D, 0x50, 0x76, 0xB9, 0xFB, 0xE6, 0x93, 0xFF, 0xF3, 0x7F, 0xFA, 0xF4, + 0xF5, 0x5D, 0x01, 0xC9, 0x0E, 0xCD, 0x98, 0xA2, 0x00, 0xC8, 0xB5, 0xE6, + 0xC2, 0x89, 0xEC, 0x85, 0xF5, 0x56, 0xCB, 0x93, 0xD3, 0xA7, 0xDF, 0xFB, + 0xA8, 0x59, 0x2C, 0xEF, 0xDE, 0xBC, 0xBA, 0xDB, 0x6C, 0x77, 0x9B, 0xFB, + 0xBE, 0x6D, 0xCF, 0xDE, 0xFD, 0xA8, 0xD6, 0xC2, 0x77, 0x78, 0xCE, 0x95, + 0x73, 0x4A, 0x58, 0x35, 0x0A, 0x48, 0x8C, 0x48, 0xE4, 0x5C, 0x7C, 0x88, + 0x4D, 0xE3, 0x9A, 0xC6, 0x4D, 0xB3, 0x47, 0xC4, 0x94, 0x0B, 0xEB, 0x63, + 0x41, 0x08, 0xB6, 0xEF, 0x01, 0x1D, 0xF4, 0x1F, 0xCC, 0x18, 0x3C, 0x64, + 0x6F, 0x34, 0xD6, 0x18, 0xCD, 0x17, 0xA1, 0xD0, 0x02, 0xB4, 0x3A, 0x84, + 0x38, 0x72, 0x61, 0xC2, 0x6E, 0xF6, 0x70, 0x38, 0xEB, 0xA1, 0xD4, 0x52, + 0x09, 0x4B, 0x2E, 0xA9, 0xE4, 0x8A, 0xC8, 0x9E, 0x2D, 0xBE, 0x23, 0x85, + 0x94, 0x02, 0x64, 0x48, 0xA9, 0x12, 0x59, 0x6B, 0xA7, 0x69, 0x66, 0x62, + 0x8E, 0xAF, 0x6A, 0x00, 0x90, 0x20, 0x38, 0x04, 0x55, 0x49, 0xC5, 0xAA, + 0x3A, 0x24, 0xD0, 0x4A, 0xF1, 0x16, 0xEF, 0xAC, 0xE5, 0x7D, 0xFE, 0xE6, + 0x76, 0x73, 0x79, 0x7D, 0x27, 0x84, 0xE4, 0xCE, 0xBD, 0xBE, 0x73, 0x20, + 0x44, 0x88, 0x89, 0xF5, 0x10, 0x39, 0xE7, 0x6F, 0x5E, 0xBE, 0xC5, 0x8A, + 0xE7, 0x67, 0x27, 0xBF, 0xFD, 0xE2, 0x9B, 0x37, 0x97, 0x57, 0xBB, 0xFD, + 0x24, 0xE5, 0x21, 0xA6, 0xDC, 0x18, 0xD3, 0xB6, 0xCD, 0x34, 0xFB, 0x9C, + 0xB3, 0x38, 0xFA, 0x52, 0xCC, 0xC1, 0xB9, 0x05, 0x1C, 0x04, 0xA4, 0x94, + 0x5C, 0x2F, 0x06, 0x67, 0xD4, 0x7A, 0xD1, 0x3D, 0x3A, 0x5D, 0xAE, 0x87, + 0x5E, 0x4A, 0x31, 0xF4, 0x1D, 0x10, 0xF4, 0x5D, 0x63, 0xAD, 0x96, 0x52, + 0xC4, 0x94, 0x85, 0x50, 0xCE, 0x59, 0x63, 0x8D, 0x52, 0x32, 0xE7, 0xA2, + 0xB5, 0x6A, 0x9B, 0xA6, 0x94, 0x3A, 0xCE, 0x21, 0x95, 0x22, 0xB5, 0xE2, + 0x61, 0x25, 0xE5, 0x12, 0x73, 0x62, 0x62, 0xA7, 0xD6, 0xA2, 0xB4, 0x66, + 0x9D, 0x2D, 0x13, 0xD3, 0xD3, 0x34, 0x57, 0xC4, 0xE5, 0xA2, 0x67, 0x14, + 0x92, 0x10, 0x7D, 0x8C, 0x29, 0x67, 0x16, 0xD3, 0xE4, 0x52, 0xE6, 0x10, + 0x59, 0x86, 0x16, 0x53, 0xC9, 0xA5, 0x84, 0x94, 0x7C, 0x88, 0x40, 0x34, + 0xCD, 0x7E, 0xF6, 0xF1, 0xC9, 0xE3, 0x47, 0xEF, 0x3C, 0x7D, 0x4C, 0x40, + 0x48, 0xBF, 0x8B, 0x0E, 0x97, 0x20, 0x99, 0x60, 0x61, 0x95, 0xFB, 0x6E, + 0x1C, 0xA5, 0x14, 0x4F, 0x1F, 0x9F, 0x3D, 0x7E, 0x74, 0xEA, 0xAC, 0x26, + 0x80, 0x18, 0x33, 0xAF, 0xBD, 0xDB, 0xDD, 0x7E, 0xB7, 0x9F, 0xE6, 0xD9, + 0x0B, 0x10, 0xC6, 0xE8, 0xD3, 0xB3, 0xF5, 0x7A, 0xBD, 0x10, 0x42, 0x74, + 0x8D, 0xD3, 0x9F, 0x7F, 0xF1, 0xED, 0x34, 0x4D, 0x00, 0xD4, 0x77, 0x1D, + 0xE3, 0x76, 0x02, 0x84, 0x56, 0xD2, 0xFB, 0xA0, 0x95, 0x34, 0xDA, 0xF4, + 0x7D, 0x77, 0xB6, 0x5E, 0xEE, 0xA7, 0xF9, 0x6F, 0xFE, 0xE9, 0xD3, 0xFD, + 0x38, 0x7B, 0x1F, 0xE7, 0xE0, 0x87, 0xAE, 0x23, 0x22, 0x1F, 0x23, 0x2F, + 0x47, 0x46, 0x69, 0x29, 0x65, 0xD7, 0x38, 0x0E, 0x14, 0x0B, 0x31, 0xB5, + 0x4D, 0x73, 0x9C, 0xB0, 0x68, 0x3F, 0x8E, 0xA5, 0x54, 0x1F, 0x92, 0x14, + 0x62, 0xBB, 0x9B, 0xE6, 0x10, 0x52, 0xCE, 0x21, 0x84, 0x45, 0xDF, 0x39, + 0x7B, 0x08, 0x6E, 0xEF, 0xDB, 0x46, 0x29, 0xB9, 0x18, 0xDA, 0xAE, 0x6B, + 0x08, 0x48, 0x0A, 0xC9, 0xE3, 0x2A, 0xBF, 0xA5, 0xB5, 0x60, 0xCE, 0xA5, + 0x3E, 0x78, 0x29, 0x2A, 0x85, 0x98, 0x43, 0x48, 0x29, 0x97, 0x9C, 0x4B, + 0xDF, 0xB5, 0xCE, 0x5A, 0x10, 0xC0, 0x89, 0x80, 0x39, 0xD7, 0x18, 0x93, + 0xD6, 0x5A, 0x6A, 0x4D, 0x88, 0x39, 0x97, 0x89, 0x02, 0x57, 0xE0, 0x70, + 0x6C, 0x4B, 0x29, 0x25, 0xA5, 0x5C, 0x6B, 0x05, 0x11, 0xBA, 0xF3, 0xF7, + 0xD4, 0x2F, 0xFF, 0x4E, 0x52, 0xCD, 0x61, 0xFE, 0xEB, 0x3F, 0xFF, 0xB3, + 0xD5, 0xC5, 0x3B, 0xCD, 0xE9, 0x3B, 0xB0, 0x2F, 0x88, 0xD8, 0x34, 0x6D, + 0x4A, 0x15, 0x11, 0x4F, 0x1E, 0x3D, 0x79, 0xF1, 0xF1, 0x1F, 0x9E, 0xBE, + 0xF8, 0x40, 0x48, 0x45, 0x58, 0x53, 0x2E, 0x02, 0x0E, 0xA6, 0xC5, 0xB6, + 0x1D, 0x98, 0xAF, 0xA8, 0x88, 0x42, 0x48, 0xAC, 0x54, 0xA9, 0x72, 0x7C, + 0x53, 0xCE, 0x25, 0x1D, 0x4B, 0x16, 0x58, 0xB7, 0xA5, 0x95, 0x42, 0xC4, + 0x63, 0xA2, 0xC0, 0x81, 0x22, 0x34, 0x46, 0xB7, 0xD0, 0xF0, 0x29, 0x16, + 0x53, 0x36, 0x5A, 0x95, 0x52, 0xDB, 0xB6, 0x51, 0x5A, 0xE5, 0x5C, 0xF8, + 0x81, 0x63, 0x5E, 0xAD, 0xEF, 0xDA, 0x39, 0x44, 0x09, 0x87, 0x54, 0x2F, + 0x21, 0x84, 0xD1, 0xBA, 0x6D, 0x9C, 0xB3, 0xE6, 0xA0, 0xCF, 0x06, 0x28, + 0xC7, 0x25, 0xFA, 0x41, 0xCF, 0xC5, 0x8C, 0x24, 0x3B, 0x6C, 0x79, 0x8C, + 0x25, 0x24, 0x56, 0x7B, 0x70, 0x39, 0x93, 0xD1, 0x9A, 0x48, 0xF2, 0xC2, + 0x48, 0x04, 0x39, 0xA7, 0x28, 0x72, 0xD7, 0x39, 0x7E, 0x76, 0xAD, 0x35, + 0x95, 0x28, 0xE5, 0x2C, 0x4A, 0x61, 0x25, 0x1A, 0x62, 0x5E, 0xBF, 0xFD, + 0xD5, 0x27, 0x3F, 0xFF, 0xCB, 0xDF, 0x5C, 0x6E, 0x48, 0x28, 0x55, 0x3D, + 0x48, 0x51, 0x4A, 0x09, 0xDE, 0x5B, 0xE7, 0x9E, 0x5E, 0x5C, 0xDC, 0xDE, + 0xDE, 0x02, 0x55, 0x42, 0x92, 0x52, 0x74, 0x6D, 0x73, 0x7A, 0x7E, 0xDA, + 0xF4, 0x03, 0x81, 0x08, 0xF3, 0x1C, 0xC3, 0x9C, 0x84, 0xFA, 0xE6, 0xB3, + 0x4F, 0x9E, 0xFE, 0xC1, 0x9F, 0xB8, 0xD5, 0x09, 0x54, 0x02, 0x21, 0xBA, + 0x8E, 0x7B, 0x67, 0x22, 0x2F, 0xE6, 0x43, 0xD7, 0x0A, 0x21, 0x6E, 0xEF, + 0xB7, 0x0C, 0xC9, 0x79, 0x1F, 0xAC, 0xB3, 0xC3, 0x62, 0x28, 0xB5, 0x8A, + 0x94, 0x39, 0x5F, 0x4C, 0x2A, 0x19, 0x73, 0x49, 0x29, 0x13, 0x11, 0x96, + 0xC3, 0x01, 0xCD, 0x2F, 0x83, 0x90, 0x42, 0x6B, 0xAD, 0xA4, 0xF4, 0x29, + 0x69, 0xA5, 0xD8, 0xC9, 0x5B, 0x4A, 0xD1, 0x4A, 0xF3, 0xD3, 0x93, 0x4B, + 0xB5, 0xC6, 0x48, 0xA9, 0x72, 0x45, 0x00, 0x62, 0x20, 0x6C, 0xBD, 0x58, + 0xE4, 0x5A, 0x35, 0x81, 0x92, 0x54, 0x91, 0x32, 0x16, 0x20, 0xC8, 0xB9, + 0x38, 0x6B, 0x8C, 0x35, 0x07, 0x6B, 0x7A, 0xD3, 0x04, 0x1F, 0x95, 0x16, + 0x44, 0x54, 0x25, 0x69, 0xAD, 0x6A, 0xA9, 0x4A, 0x4A, 0xC4, 0x9A, 0x52, + 0xE4, 0x62, 0x1F, 0xD6, 0x91, 0x12, 0xA2, 0x10, 0xE0, 0x7D, 0x20, 0x80, + 0xE0, 0xA3, 0xB3, 0x7A, 0x3B, 0xCE, 0xE3, 0x1C, 0x76, 0xBB, 0xA9, 0x6B, + 0xDD, 0xA3, 0xB3, 0x35, 0x5B, 0xCA, 0xB8, 0x5F, 0x23, 0xA6, 0x62, 0x8C, + 0x21, 0x80, 0xBE, 0xEF, 0xC6, 0x71, 0xDE, 0xEE, 0xF7, 0x7D, 0xDF, 0xE5, + 0x94, 0x19, 0xED, 0x34, 0xC6, 0x48, 0x21, 0xCF, 0x4E, 0x4F, 0xA6, 0x69, + 0x1E, 0xBD, 0x67, 0x63, 0x53, 0x29, 0x45, 0x0A, 0x99, 0x72, 0x12, 0x52, + 0x34, 0xD6, 0x08, 0x21, 0x00, 0xA4, 0x52, 0x07, 0x1A, 0x45, 0x48, 0x49, + 0x85, 0x7C, 0x08, 0x6D, 0xE7, 0x88, 0xA8, 0xE4, 0x0A, 0xC0, 0xF3, 0x26, + 0x32, 0xC5, 0x52, 0x4A, 0x25, 0x01, 0x42, 0x8A, 0x94, 0xB3, 0xF7, 0x29, + 0xA5, 0xB2, 0x58, 0x74, 0x95, 0x20, 0x25, 0x5F, 0x6B, 0x4D, 0xA5, 0x3A, + 0x67, 0x95, 0x94, 0xDE, 0x07, 0x56, 0x14, 0xB1, 0x5C, 0xB4, 0x96, 0xB2, + 0xDD, 0x8D, 0x44, 0xF4, 0xF4, 0xE2, 0xDC, 0xC7, 0x08, 0x44, 0x31, 0x05, + 0x22, 0x97, 0x6A, 0x01, 0x10, 0xDC, 0x37, 0x35, 0x7B, 0x0F, 0x42, 0x5A, + 0xA3, 0x89, 0xA8, 0x62, 0x6D, 0x9C, 0xCB, 0xA5, 0x20, 0xD6, 0x69, 0x8E, + 0x3E, 0x84, 0x27, 0x8F, 0xCE, 0x3A, 0xE7, 0x66, 0xEF, 0xF9, 0xFB, 0x52, + 0x5A, 0x12, 0x41, 0x8A, 0x5C, 0x20, 0x57, 0x58, 0x7B, 0xBC, 0x5A, 0x2E, + 0x40, 0x40, 0xEB, 0x1C, 0x33, 0x3F, 0xF6, 0x64, 0xC5, 0x4F, 0x5D, 0xA9, + 0x95, 0x45, 0xC2, 0xCE, 0x5A, 0x29, 0xA4, 0xF7, 0xA1, 0x10, 0xA5, 0x5C, + 0x72, 0x2A, 0xBC, 0x75, 0xE9, 0x79, 0x9E, 0x9D, 0xB3, 0x00, 0x10, 0x62, + 0x12, 0x40, 0x56, 0x69, 0x8E, 0xC7, 0x02, 0x82, 0x52, 0xD0, 0x68, 0x98, + 0x26, 0xFF, 0x9B, 0x2F, 0xBF, 0xDB, 0xEE, 0x47, 0x64, 0x43, 0x3F, 0x22, + 0x87, 0x99, 0x31, 0xE2, 0x9E, 0x4B, 0x8E, 0x31, 0x46, 0xE7, 0xAC, 0x35, + 0xA5, 0xD6, 0x94, 0x8A, 0x14, 0x62, 0xF6, 0x71, 0x9C, 0x03, 0x11, 0xCE, + 0x3E, 0x28, 0xA5, 0x53, 0x2A, 0x93, 0x0F, 0x04, 0x42, 0x4A, 0xB9, 0xD9, + 0xED, 0xBC, 0x0F, 0x00, 0x60, 0xAD, 0x7E, 0x74, 0x76, 0xD2, 0xF7, 0x2D, + 0x1C, 0x33, 0x69, 0x01, 0xA0, 0xEF, 0x1B, 0x67, 0x8D, 0xE5, 0x94, 0x35, + 0xC4, 0x92, 0x0B, 0x53, 0x69, 0x25, 0xD7, 0x5C, 0x0B, 0x11, 0xEF, 0xBC, + 0x2C, 0xD1, 0xAE, 0xA5, 0x94, 0x07, 0x07, 0x0C, 0x63, 0x4C, 0xAC, 0x5A, + 0xDE, 0x6C, 0x47, 0x02, 0x92, 0x4A, 0x22, 0x62, 0xD7, 0x35, 0xA5, 0x62, + 0x4A, 0x29, 0x04, 0xE4, 0x9D, 0x5F, 0x08, 0xC1, 0xD0, 0x26, 0xE7, 0x40, + 0x44, 0xE3, 0x4E, 0xDE, 0xFB, 0xE1, 0xD5, 0xCB, 0xDF, 0xAE, 0x16, 0xFD, + 0x57, 0xBF, 0xFD, 0xF4, 0x5F, 0xFC, 0xDB, 0x7F, 0x3F, 0xC6, 0xBA, 0x76, + 0xDD, 0xE9, 0xD9, 0x39, 0x08, 0x35, 0xCD, 0x5E, 0x48, 0x29, 0xA4, 0x39, + 0x39, 0x7D, 0x64, 0x17, 0x67, 0x13, 0x6F, 0x4C, 0x88, 0xCE, 0x1A, 0x6B, + 0x6D, 0xDB, 0x36, 0xB5, 0x94, 0x10, 0x13, 0xEB, 0x09, 0xAA, 0x44, 0x3A, + 0xFA, 0x81, 0xF8, 0x2B, 0x64, 0xFD, 0x42, 0x39, 0x34, 0x5D, 0xF2, 0x35, + 0x95, 0x89, 0x68, 0xF6, 0x81, 0xBD, 0xCD, 0x7C, 0x20, 0xCA, 0x22, 0x7D, + 0x8C, 0xFC, 0x59, 0x3E, 0x9C, 0x3E, 0x4A, 0x29, 0x22, 0xE1, 0x7D, 0x6A, + 0x1A, 0x63, 0xB4, 0xC6, 0x5A, 0x8D, 0xD6, 0xAB, 0xC5, 0x90, 0x52, 0x39, + 0x84, 0x7B, 0x01, 0x49, 0x25, 0xB4, 0x52, 0xD6, 0x98, 0x7F, 0xDE, 0x8E, + 0x05, 0x52, 0x8A, 0x94, 0x52, 0x88, 0x09, 0xB9, 0x9E, 0x86, 0x28, 0xA5, + 0xC4, 0x71, 0x9D, 0x4C, 0x37, 0x36, 0x60, 0x7D, 0x38, 0x7C, 0x6E, 0xE6, + 0xA8, 0xE2, 0x11, 0x87, 0xB0, 0xD6, 0xC4, 0x1F, 0xAE, 0x75, 0xD6, 0x1A, + 0x3D, 0x00, 0x28, 0xA5, 0x42, 0xC9, 0xC6, 0x68, 0x25, 0x45, 0x91, 0xBA, + 0xBD, 0xFC, 0xF5, 0xE7, 0x9F, 0xFC, 0xC5, 0x3F, 0x7C, 0x7B, 0x69, 0x5D, + 0x2B, 0x84, 0x08, 0x39, 0x82, 0x90, 0x00, 0xC2, 0x58, 0xA7, 0x8C, 0x7D, + 0xFF, 0x87, 0x3F, 0x91, 0xBF, 0xFE, 0xC5, 0x3C, 0x8D, 0xB3, 0x0F, 0xAE, + 0x6D, 0xDE, 0xFF, 0xF0, 0xC3, 0xD5, 0xC5, 0x13, 0xD7, 0x0F, 0xFB, 0xBB, + 0xDB, 0x69, 0xB7, 0x6D, 0x8C, 0xF1, 0x31, 0x97, 0xE8, 0x77, 0x57, 0x2F, + 0x4F, 0x97, 0xA7, 0x84, 0x68, 0x8C, 0x1A, 0x86, 0x4E, 0x0A, 0x29, 0xB7, + 0x3B, 0x31, 0x41, 0x41, 0x4C, 0xA5, 0x2C, 0x87, 0x1E, 0x09, 0xBD, 0x4F, + 0xFD, 0x30, 0x08, 0x01, 0x25, 0x45, 0xAA, 0x45, 0x48, 0x5D, 0x10, 0xA5, + 0x44, 0x00, 0x76, 0x02, 0x1C, 0x12, 0x77, 0x2B, 0xA2, 0x94, 0x0A, 0x80, + 0x72, 0xCE, 0x1C, 0x9D, 0x96, 0x73, 0xE6, 0x48, 0x77, 0x2D, 0x25, 0x72, + 0xF4, 0x6E, 0x45, 0xCE, 0x32, 0x38, 0x3C, 0x30, 0x00, 0x21, 0xA5, 0xC3, + 0xA5, 0x82, 0xD8, 0x38, 0xCB, 0x15, 0x9D, 0x95, 0x88, 0x83, 0xCF, 0x72, + 0xE4, 0x86, 0x04, 0x91, 0x32, 0x8B, 0x76, 0x50, 0x08, 0xD1, 0xB5, 0x6D, + 0x08, 0x11, 0x40, 0x18, 0xA3, 0x72, 0xC2, 0x0C, 0xD5, 0x68, 0x29, 0x41, + 0x1A, 0x6B, 0xAC, 0xB5, 0xF7, 0xDB, 0x1D, 0xCF, 0xE9, 0x11, 0x93, 0xD2, + 0x8A, 0xC5, 0x89, 0x52, 0xCA, 0xB6, 0x75, 0xC6, 0xE8, 0x14, 0x53, 0x4C, + 0xF9, 0x66, 0xB3, 0x35, 0x7B, 0x7D, 0x7D, 0xB7, 0xED, 0x5B, 0xC7, 0xBD, + 0x8B, 0x6D, 0xDB, 0x84, 0x10, 0x2A, 0x52, 0x08, 0xF1, 0x67, 0x7F, 0xFB, + 0x4F, 0x5A, 0xA9, 0xAE, 0x6D, 0xD9, 0xED, 0xC0, 0x9E, 0x47, 0xD6, 0x88, + 0x50, 0x8C, 0x93, 0xF7, 0x87, 0x7C, 0x5B, 0x44, 0x44, 0x04, 0xF9, 0xD0, + 0xDB, 0x06, 0x9C, 0xB6, 0xC6, 0x23, 0xB6, 0x54, 0x8A, 0xD1, 0x18, 0x8E, + 0x44, 0x92, 0x42, 0x12, 0x55, 0x56, 0xF0, 0x02, 0x08, 0x24, 0x64, 0xC1, + 0x33, 0xCB, 0x92, 0x67, 0x1F, 0x72, 0xAE, 0xB9, 0x24, 0xA0, 0x76, 0x9E, + 0x3D, 0x11, 0xA5, 0x94, 0xA5, 0x56, 0x46, 0xEB, 0x94, 0x52, 0xCC, 0x19, + 0x11, 0x65, 0x91, 0xCE, 0x39, 0x29, 0xE5, 0xE4, 0x83, 0x00, 0x38, 0x3D, + 0x5D, 0xEF, 0xA6, 0x29, 0xE7, 0xB2, 0x5A, 0x2D, 0x94, 0xD4, 0xB9, 0x14, + 0x12, 0xA0, 0x95, 0x02, 0x25, 0x59, 0xEE, 0xDF, 0xF7, 0xBD, 0x94, 0xB2, + 0xD4, 0x62, 0xAC, 0xD1, 0xC6, 0xC4, 0xA3, 0xB0, 0xD9, 0x18, 0x6D, 0x8D, + 0x26, 0x38, 0x58, 0x6E, 0x8D, 0x56, 0xCE, 0x9A, 0x5C, 0x39, 0xC0, 0x4A, + 0x4E, 0x53, 0x65, 0xBD, 0xA4, 0x10, 0xB0, 0x1C, 0xBA, 0x72, 0xEC, 0x52, + 0xE2, 0xEB, 0x64, 0x0E, 0xC1, 0x28, 0x75, 0x38, 0x87, 0x31, 0x2B, 0x2D, + 0xA5, 0x51, 0x10, 0x8B, 0xF7, 0xC9, 0x1A, 0x7B, 0x76, 0xBA, 0x26, 0x02, + 0x2D, 0xA4, 0x9C, 0x27, 0xAF, 0xB4, 0x56, 0x4A, 0x1A, 0xA5, 0x32, 0x17, + 0xA9, 0xE5, 0x2C, 0x84, 0x70, 0xCE, 0xA5, 0x52, 0x62, 0xCC, 0x3E, 0x04, + 0x86, 0x57, 0x18, 0x28, 0x6D, 0x9B, 0x86, 0x08, 0x26, 0xEF, 0x41, 0x88, + 0xCE, 0x39, 0x21, 0xA5, 0x0F, 0xA1, 0xEB, 0x0E, 0xC2, 0xA8, 0xFD, 0xE4, + 0x6F, 0xEE, 0xB6, 0x02, 0x0E, 0xA9, 0x92, 0x02, 0xA0, 0x6B, 0x9B, 0xD3, + 0xF5, 0x32, 0x57, 0x7A, 0x7D, 0x79, 0x35, 0x8E, 0x93, 0x90, 0xD2, 0x1A, + 0x7D, 0x7A, 0xB2, 0x7A, 0xFE, 0xCE, 0xE3, 0x8B, 0xF3, 0xF5, 0x62, 0xE8, + 0x78, 0x3B, 0xB3, 0xC6, 0x34, 0xAD, 0x95, 0x9C, 0xE6, 0x41, 0x40, 0x40, + 0x29, 0x1F, 0xF8, 0xEF, 0x43, 0xE1, 0x4C, 0xC5, 0x94, 0x4A, 0xCC, 0xA5, + 0x22, 0x0A, 0x01, 0x52, 0x29, 0xCC, 0x31, 0xC6, 0xC8, 0xC2, 0x13, 0x6B, + 0x74, 0xCA, 0x65, 0xF6, 0x41, 0x4A, 0xD5, 0x36, 0xBA, 0xD4, 0xD2, 0xB5, + 0xAD, 0xF7, 0x7E, 0x1C, 0xE7, 0x8A, 0xB5, 0xEB, 0xFA, 0xA6, 0xD1, 0x00, + 0xC4, 0xBE, 0x4B, 0x7D, 0xC8, 0x14, 0x14, 0xF3, 0xB8, 0xB7, 0xE7, 0xEF, + 0x5D, 0xFE, 0xD5, 0xFF, 0x5D, 0x72, 0x02, 0x69, 0xCE, 0x5F, 0x7C, 0xFF, + 0xF6, 0x6E, 0x2B, 0xDB, 0x4C, 0x44, 0x25, 0x85, 0x94, 0x28, 0x55, 0xA2, + 0x18, 0xA3, 0x9F, 0xB7, 0x9B, 0xCD, 0x88, 0xCD, 0xA2, 0x73, 0x87, 0x94, + 0x09, 0xA9, 0x42, 0x88, 0x87, 0x51, 0x11, 0xB1, 0x94, 0xC2, 0xE1, 0x88, + 0x6C, 0x62, 0xE1, 0xB0, 0x71, 0xC9, 0x42, 0x36, 0x29, 0x0B, 0xA2, 0x0F, + 0x91, 0xBF, 0x0B, 0x4E, 0x61, 0x16, 0x02, 0x95, 0x94, 0x52, 0x48, 0x56, + 0x36, 0x33, 0x5F, 0x89, 0x88, 0x39, 0x27, 0x6B, 0xD8, 0xBD, 0x21, 0x38, + 0x98, 0x89, 0x7D, 0x8E, 0x8C, 0xD5, 0x4B, 0x21, 0x94, 0x56, 0x84, 0x24, + 0x80, 0xB4, 0xD6, 0x46, 0x1B, 0x02, 0xF0, 0x31, 0xF5, 0x6D, 0xC3, 0x5C, + 0x70, 0x29, 0x87, 0xC9, 0xCB, 0x7B, 0x56, 0x66, 0x17, 0xE7, 0x34, 0x4B, + 0xA8, 0x62, 0x4A, 0x7D, 0xD7, 0x71, 0x98, 0x22, 0x83, 0x8C, 0x52, 0x2A, + 0xAD, 0x35, 0x1D, 0xE2, 0x61, 0x91, 0xC3, 0xFA, 0xF9, 0x9F, 0x19, 0xE0, + 0x10, 0x04, 0x23, 0x78, 0x63, 0x0C, 0x21, 0x12, 0x55, 0x65, 0xDB, 0x61, + 0xBA, 0xBC, 0xFD, 0xF2, 0x1F, 0x3F, 0x79, 0x79, 0x0D, 0x20, 0xDA, 0xB6, + 0x91, 0xDA, 0xE4, 0xED, 0x36, 0xE7, 0x82, 0xB5, 0x34, 0xAE, 0x99, 0xC7, + 0x3D, 0xE9, 0xE6, 0x7B, 0x7F, 0xF4, 0xA7, 0xB7, 0xDF, 0x7D, 0xE5, 0x9A, + 0xD6, 0xB6, 0xDD, 0xFA, 0xF1, 0x13, 0xDB, 0xF5, 0xCA, 0x35, 0xF3, 0xB8, + 0x8B, 0x31, 0x28, 0x6D, 0x18, 0x6F, 0x8E, 0x31, 0xD6, 0x52, 0xB0, 0xB0, + 0x04, 0x49, 0x76, 0x7D, 0x8B, 0x84, 0x25, 0xD7, 0x1A, 0x62, 0xA5, 0x9A, + 0x6B, 0x91, 0x52, 0x39, 0x4D, 0x6F, 0xBF, 0xF9, 0xCC, 0x6A, 0xD1, 0x6A, + 0xF1, 0xD5, 0x6F, 0x3F, 0x9B, 0xAB, 0x5E, 0x3C, 0xFE, 0x5E, 0x46, 0x2A, + 0x29, 0x69, 0x6D, 0xA4, 0x54, 0x5A, 0x49, 0x25, 0x44, 0xC8, 0x07, 0x1C, + 0x50, 0x29, 0xC5, 0x88, 0x24, 0x11, 0xA5, 0x52, 0x9D, 0xD6, 0x08, 0x1C, + 0x01, 0x22, 0x85, 0x80, 0x43, 0x54, 0x3F, 0x1E, 0x3C, 0x34, 0x5A, 0x0B, + 0x38, 0x74, 0xE5, 0x21, 0x8B, 0xE6, 0x10, 0xAB, 0x10, 0x0A, 0xA4, 0x8C, + 0x39, 0xE7, 0x72, 0x08, 0xB5, 0xD1, 0x42, 0x19, 0xFE, 0xDD, 0x5A, 0x19, + 0xCC, 0x1D, 0xA7, 0xD9, 0x5A, 0xA3, 0xA4, 0x8A, 0x31, 0x01, 0x19, 0x21, + 0x0E, 0xD6, 0xA8, 0x93, 0xF5, 0x6A, 0x9A, 0xE7, 0x10, 0x32, 0x49, 0x80, + 0x8A, 0xEC, 0x18, 0xCD, 0xB9, 0x60, 0x55, 0xAC, 0xAD, 0xE7, 0xB6, 0x01, + 0xA5, 0x64, 0x88, 0x71, 0x9C, 0x3C, 0xDF, 0x3A, 0x7D, 0xDF, 0x2E, 0xFA, + 0xEE, 0x64, 0x35, 0x68, 0xA5, 0x78, 0xA5, 0x65, 0x49, 0xB3, 0x73, 0x0E, + 0xB1, 0xF2, 0xAA, 0x95, 0x52, 0x92, 0x52, 0xF6, 0x5D, 0xC7, 0x31, 0xB9, + 0x7C, 0xC6, 0x71, 0xE4, 0x7F, 0x4C, 0x89, 0xCF, 0x85, 0x5A, 0x2B, 0xD5, + 0x43, 0xFC, 0x19, 0x81, 0x30, 0xD6, 0x12, 0x51, 0xA9, 0x28, 0x95, 0x92, + 0x1A, 0xFD, 0x94, 0xB4, 0x36, 0x93, 0x0F, 0x4A, 0x2B, 0xA7, 0x35, 0x09, + 0x10, 0x42, 0xB1, 0xF1, 0xE3, 0x7E, 0xB3, 0xEB, 0xBB, 0xF6, 0x7E, 0xBB, + 0xD7, 0x5A, 0xB3, 0x2E, 0xBF, 0x69, 0xDB, 0x5C, 0x78, 0xFF, 0x21, 0x66, + 0x8D, 0x9C, 0x73, 0x31, 0x04, 0x63, 0xD4, 0x7A, 0xB5, 0xAC, 0x44, 0xB3, + 0x8F, 0x8B, 0xA1, 0x07, 0x10, 0x24, 0x65, 0x2D, 0x05, 0x08, 0x50, 0x62, + 0x2D, 0xD8, 0x18, 0xC7, 0x81, 0x80, 0x05, 0xAB, 0xD1, 0xC6, 0xC7, 0x38, + 0xFB, 0x98, 0x53, 0x8E, 0x31, 0x1B, 0x25, 0xB9, 0x19, 0x56, 0x0B, 0x81, + 0x48, 0x4A, 0x09, 0xD6, 0x5A, 0x1E, 0x7D, 0x78, 0x7A, 0xE8, 0x7B, 0x44, + 0x44, 0xC2, 0x94, 0x33, 0x13, 0x79, 0x77, 0xB7, 0xF7, 0x29, 0xE5, 0xE5, + 0xA2, 0x37, 0x4A, 0x3B, 0x63, 0x72, 0xA9, 0x58, 0xC9, 0x5A, 0xF3, 0x10, + 0xAC, 0x6E, 0x1B, 0x63, 0x8D, 0xB1, 0x46, 0x7B, 0x1F, 0xAC, 0x35, 0x7A, + 0x1A, 0xE7, 0xA6, 0x71, 0x00, 0x80, 0xA5, 0xEC, 0x7D, 0xD9, 0x8D, 0x53, + 0x45, 0x6A, 0x9C, 0x35, 0xD6, 0x94, 0x92, 0xF7, 0xE3, 0x44, 0x48, 0x52, + 0x49, 0x8E, 0xDA, 0x60, 0x61, 0xD4, 0x34, 0xCF, 0x39, 0x67, 0xA5, 0xF4, + 0x6A, 0xD1, 0x5B, 0x63, 0x42, 0x08, 0x5C, 0xD0, 0x1D, 0x42, 0xDE, 0x17, + 0x7F, 0xBF, 0xD9, 0xA5, 0x92, 0x95, 0x54, 0x40, 0x50, 0x6A, 0xE9, 0xDA, + 0xE6, 0xD4, 0x39, 0x21, 0xC5, 0xCB, 0x97, 0xAF, 0xE6, 0xD9, 0x2B, 0xAD, + 0xCE, 0x4F, 0x4F, 0x9E, 0x5C, 0x9C, 0x19, 0xA3, 0x16, 0x7D, 0xB7, 0xE8, + 0xBB, 0xAE, 0x6D, 0x58, 0xE2, 0x4C, 0x40, 0x25, 0x57, 0xA5, 0x81, 0xB0, + 0xE6, 0x52, 0x81, 0xE8, 0x70, 0xB7, 0x08, 0x21, 0xA4, 0x50, 0xA0, 0x72, + 0x2E, 0x21, 0xE5, 0x10, 0xB9, 0x03, 0x97, 0x38, 0x39, 0x64, 0xF6, 0xA9, + 0xD6, 0x62, 0xAD, 0xE1, 0x27, 0xB8, 0x56, 0x34, 0x5A, 0x4B, 0x25, 0x0D, + 0x18, 0xEF, 0xFD, 0xED, 0xCD, 0xAD, 0x6D, 0x3B, 0xA9, 0x4C, 0xA9, 0xD5, + 0xFB, 0xC0, 0x65, 0x71, 0x44, 0x54, 0x6A, 0x69, 0x9B, 0xA6, 0x22, 0xEE, + 0xF7, 0x93, 0x6B, 0xDA, 0x2A, 0xCD, 0x17, 0xBF, 0xFC, 0xC7, 0x61, 0xFD, + 0xC8, 0x74, 0x4B, 0xC2, 0x7A, 0xBB, 0xCF, 0x29, 0x95, 0x71, 0xDC, 0xFA, + 0xDA, 0xEF, 0x23, 0xC8, 0x52, 0xFC, 0xE6, 0xD6, 0x08, 0x3D, 0x37, 0x8F, + 0x05, 0x10, 0x87, 0xED, 0xF8, 0x10, 0x72, 0x2E, 0x52, 0x0A, 0x86, 0x84, + 0x58, 0x58, 0x24, 0x33, 0xCB, 0xC7, 0x05, 0xE7, 0xF9, 0xB1, 0x6C, 0xED, + 0x00, 0x66, 0x1D, 0x90, 0x78, 0x92, 0x52, 0x3C, 0x38, 0xA5, 0x04, 0xB0, + 0x15, 0x96, 0x15, 0xF8, 0xAC, 0x84, 0x30, 0x04, 0x94, 0x52, 0xA9, 0x48, + 0x5A, 0x6B, 0x6B, 0xB4, 0xD6, 0xD2, 0x68, 0xED, 0x40, 0xC8, 0x46, 0x4C, + 0x4A, 0xFB, 0x18, 0x4B, 0xAD, 0x86, 0xD7, 0x28, 0x21, 0xD8, 0x3C, 0x38, + 0x87, 0xC0, 0x21, 0x3C, 0x52, 0x49, 0xAC, 0x58, 0x72, 0x19, 0xE7, 0xC0, + 0x5C, 0x8F, 0xD6, 0x12, 0x0C, 0x95, 0x52, 0x09, 0xA1, 0x6D, 0x1A, 0x00, + 0xA8, 0xEA, 0x77, 0x5D, 0xDF, 0x0F, 0xE5, 0x0E, 0xA5, 0x54, 0x38, 0xDA, + 0x26, 0x95, 0x52, 0x40, 0x14, 0x63, 0xE4, 0x80, 0x8A, 0xC2, 0xA9, 0x60, + 0x42, 0x9C, 0x88, 0x79, 0xFE, 0xFC, 0x67, 0x7F, 0xF5, 0xC9, 0xAF, 0xA7, + 0x54, 0x9E, 0x3E, 0x79, 0xFA, 0xFC, 0x7B, 0xDF, 0x1F, 0x96, 0x8B, 0xCB, + 0x37, 0xAF, 0xC7, 0xDD, 0xCE, 0x4F, 0xE3, 0xB4, 0xDF, 0x87, 0x94, 0x36, + 0x37, 0x37, 0xCF, 0x3E, 0xFA, 0xFE, 0x8B, 0x9F, 0xAC, 0xAD, 0xD6, 0xE3, + 0x7E, 0x5B, 0x08, 0xBA, 0x76, 0x48, 0x55, 0x5C, 0xBF, 0x79, 0x3B, 0x8E, + 0x7B, 0x90, 0xDA, 0x3A, 0x27, 0xA5, 0x12, 0xBA, 0x49, 0xA9, 0xD4, 0x52, + 0xB4, 0x24, 0x21, 0x01, 0x91, 0xA4, 0x50, 0xDA, 0x68, 0x15, 0x13, 0x49, + 0x89, 0x44, 0x6D, 0xD7, 0xEC, 0x93, 0x0F, 0xE3, 0xE6, 0xCD, 0xCB, 0xCF, + 0x52, 0xAD, 0xA6, 0x5B, 0xFC, 0xFC, 0x6F, 0x7E, 0xD6, 0xAE, 0x1E, 0x7F, + 0xFF, 0xA7, 0xFF, 0x7A, 0xB9, 0x3E, 0x55, 0x4A, 0x69, 0x2D, 0x15, 0x88, + 0x5A, 0xB9, 0x1E, 0xE5, 0x90, 0x50, 0x54, 0xCA, 0xA1, 0xC0, 0x4D, 0x0A, + 0x40, 0x42, 0x00, 0x50, 0x52, 0x28, 0x21, 0x94, 0x73, 0x3E, 0x26, 0x3E, + 0xB9, 0x40, 0x6B, 0x10, 0x87, 0xFA, 0x6E, 0x00, 0x90, 0x42, 0x58, 0xAD, + 0xB5, 0x92, 0xD5, 0x98, 0x78, 0x38, 0x13, 0x0F, 0xB6, 0xAA, 0x52, 0x6B, + 0x89, 0x55, 0x49, 0xD9, 0x3A, 0x97, 0x52, 0xE2, 0x78, 0x52, 0x21, 0x04, + 0xC3, 0x79, 0x0C, 0x29, 0x6A, 0xA9, 0x94, 0x16, 0xB5, 0x52, 0xAD, 0xC5, + 0xB9, 0xA6, 0x56, 0x0A, 0x21, 0xA1, 0xA4, 0x8A, 0x1C, 0x7E, 0x0F, 0x31, + 0x67, 0xCE, 0xDE, 0x68, 0xAC, 0x63, 0x88, 0x5D, 0xD0, 0x41, 0x2B, 0xE7, + 0xAC, 0xDA, 0xEE, 0xC6, 0xBB, 0xCD, 0xEE, 0xFA, 0xD6, 0x9D, 0x9F, 0xAE, + 0xD7, 0xCB, 0x81, 0x51, 0xF9, 0x3F, 0xFA, 0xC3, 0x8F, 0xB7, 0xBB, 0xA9, + 0x6B, 0xDD, 0x7E, 0x3F, 0xBF, 0x7E, 0x7B, 0x55, 0x11, 0x9D, 0x73, 0x6D, + 0xEB, 0x72, 0xCE, 0x4A, 0x1E, 0xE0, 0x24, 0x01, 0x04, 0x20, 0xF8, 0xF4, + 0xE1, 0x85, 0xD1, 0x18, 0xC3, 0xB6, 0x01, 0x24, 0x94, 0xDC, 0xCF, 0x5D, + 0x0F, 0x9F, 0xA9, 0xD1, 0x7A, 0x9C, 0xC3, 0x6E, 0x9C, 0x4E, 0xD7, 0x4B, + 0xA1, 0x24, 0x0B, 0x20, 0xEE, 0xEF, 0x77, 0xBC, 0x2A, 0x12, 0x40, 0xD7, + 0x36, 0xEC, 0x67, 0xB0, 0xD6, 0x72, 0xD6, 0x16, 0x57, 0x40, 0xB1, 0xF5, + 0x35, 0xE7, 0x9C, 0x52, 0x32, 0xC6, 0x22, 0xC0, 0xEC, 0x7D, 0xDF, 0x35, + 0xBF, 0x17, 0x19, 0x82, 0x3C, 0xF8, 0x61, 0x05, 0x5F, 0x83, 0xD6, 0x6A, + 0x9E, 0x83, 0x10, 0x42, 0x38, 0x51, 0x0B, 0x62, 0xAD, 0x21, 0x84, 0x9C, + 0xB3, 0x6E, 0x9C, 0x73, 0x76, 0x1C, 0x27, 0x29, 0x85, 0x51, 0x8A, 0xA3, + 0x19, 0xF7, 0xE3, 0x4C, 0x44, 0x48, 0xC8, 0x67, 0x85, 0x4F, 0xB1, 0x96, + 0x42, 0x00, 0x58, 0xC9, 0x68, 0xB5, 0x5E, 0x2D, 0xC7, 0x71, 0xDE, 0x8F, + 0x1E, 0x00, 0xAC, 0xB1, 0x5D, 0xA7, 0xAC, 0x31, 0xCE, 0x39, 0x6B, 0xB5, + 0x52, 0x2A, 0xA7, 0x12, 0x42, 0x70, 0xD6, 0x1A, 0x6B, 0x08, 0x28, 0xA7, + 0xAC, 0x53, 0x4E, 0x5A, 0xC9, 0xC6, 0xDA, 0x39, 0xC4, 0xC9, 0x47, 0xA5, + 0x75, 0xA3, 0x15, 0x22, 0xD6, 0x52, 0x42, 0x8C, 0x02, 0x84, 0x6B, 0x9A, + 0x5A, 0xD8, 0x07, 0x67, 0xBC, 0xF7, 0x3C, 0xA6, 0xB7, 0x4D, 0xD3, 0x77, + 0x2D, 0x3B, 0x3C, 0xBA, 0xAE, 0xB3, 0xC6, 0x6E, 0xB6, 0xFB, 0x90, 0x52, + 0x39, 0xE0, 0x7C, 0x79, 0xE8, 0x5A, 0x63, 0x8C, 0x16, 0xFA, 0x74, 0xBD, + 0x0A, 0x39, 0x4F, 0xDB, 0x59, 0x0A, 0x69, 0x8D, 0x01, 0xA2, 0xD5, 0x62, + 0xB0, 0xD6, 0x74, 0xAD, 0x63, 0x44, 0x33, 0xE7, 0x82, 0x28, 0x6B, 0xAD, + 0x08, 0x54, 0x2B, 0x89, 0x94, 0x85, 0x14, 0xA5, 0x54, 0x25, 0xA4, 0x54, + 0x92, 0x4B, 0x40, 0xA4, 0x10, 0xB9, 0x96, 0x94, 0x2A, 0x0F, 0x35, 0xE2, + 0xD0, 0xD2, 0x56, 0x89, 0x40, 0x2B, 0x29, 0x85, 0x6E, 0x1D, 0x77, 0x9D, + 0x1D, 0x6A, 0x84, 0x4A, 0xC5, 0xD9, 0x87, 0xAB, 0xCB, 0xB7, 0xC3, 0xF2, + 0x24, 0x15, 0x0A, 0x61, 0xB2, 0xD6, 0x12, 0xD6, 0x71, 0xDC, 0x10, 0x28, + 0x22, 0x79, 0x4C, 0x74, 0x16, 0xD6, 0x1A, 0x90, 0xEA, 0xE4, 0xE9, 0x8B, + 0x8B, 0xA1, 0xCC, 0xC5, 0x2E, 0xD6, 0xA7, 0xB6, 0x69, 0x43, 0x10, 0xD5, + 0x3A, 0x41, 0x55, 0x0B, 0x14, 0x20, 0x97, 0xCB, 0x45, 0x7C, 0x39, 0x4E, + 0x63, 0x8B, 0xCD, 0xE3, 0x10, 0x83, 0x75, 0x36, 0x84, 0x5C, 0x8A, 0x7F, + 0x30, 0x11, 0x12, 0xFD, 0x7F, 0x4C, 0xBD, 0xC9, 0xAF, 0x5D, 0x59, 0x7A, + 0xE5, 0xB7, 0xFB, 0xBD, 0x4F, 0x77, 0xFB, 0xFB, 0x3A, 0x3E, 0x76, 0x41, + 0x46, 0x1F, 0xD9, 0x29, 0x25, 0x57, 0x95, 0xAA, 0xA4, 0x92, 0xA1, 0x42, + 0x01, 0x06, 0x8C, 0xAA, 0x91, 0x01, 0x4F, 0x8C, 0x02, 0x0C, 0xDB, 0x63, + 0x0F, 0x6A, 0xE2, 0xB9, 0xFF, 0x28, 0xBB, 0x60, 0xA0, 0x20, 0x97, 0x2C, + 0x59, 0xA9, 0xCC, 0x94, 0x32, 0x32, 0xA3, 0x25, 0x19, 0xEC, 0x5E, 0x7F, + 0xDB, 0xD3, 0xEE, 0x7E, 0x6F, 0x0F, 0xF6, 0x7D, 0x61, 0x05, 0x81, 0x18, + 0x90, 0x04, 0x41, 0xDE, 0xF7, 0xCE, 0x77, 0xBE, 0x66, 0xAD, 0xDF, 0x8A, + 0x9C, 0x33, 0x00, 0x81, 0x56, 0xD6, 0x7B, 0xCF, 0x39, 0xF5, 0x3E, 0x22, + 0x04, 0xAD, 0x4D, 0xC3, 0x26, 0x88, 0x30, 0x40, 0x00, 0xD2, 0x8C, 0x09, + 0x61, 0x48, 0x3B, 0x32, 0x7F, 0xF0, 0xF4, 0xC0, 0x94, 0xB7, 0xE4, 0x9C, + 0x13, 0x82, 0x7B, 0x8F, 0x62, 0x08, 0x88, 0xE2, 0x90, 0xF2, 0x44, 0x12, + 0xE5, 0x84, 0x10, 0x8A, 0x31, 0x44, 0x50, 0x3B, 0x9F, 0x01, 0xA8, 0xAD, + 0x49, 0xCF, 0x1B, 0xBA, 0x0F, 0x55, 0x8C, 0x31, 0x4A, 0xA8, 0x89, 0xC3, + 0x08, 0xC2, 0x10, 0xFC, 0xA0, 0x4C, 0x2F, 0x15, 0x46, 0x88, 0xD0, 0x44, + 0x34, 0x07, 0x09, 0x52, 0xFA, 0xE3, 0x74, 0x99, 0x26, 0xD0, 0xF4, 0x6E, + 0x0B, 0x21, 0xC4, 0x18, 0x0E, 0xB2, 0xD2, 0x7B, 0x85, 0x57, 0x08, 0xC1, + 0x39, 0x8F, 0x30, 0xA6, 0xD4, 0x22, 0x08, 0x23, 0x80, 0x50, 0xCA, 0xF6, + 0xDB, 0xBF, 0xFB, 0xCD, 0xEF, 0xFE, 0x5E, 0x3B, 0x2F, 0x18, 0x3D, 0x7B, + 0xF2, 0xEC, 0xE1, 0x27, 0x9F, 0x67, 0x45, 0x39, 0x39, 0x39, 0x45, 0x08, + 0xB5, 0xFB, 0xE6, 0xCB, 0xBF, 0xF9, 0xAB, 0xF7, 0x6F, 0x5F, 0x4B, 0x25, + 0x23, 0x22, 0x11, 0xE1, 0x80, 0xD0, 0x30, 0xA8, 0x08, 0xF5, 0xF8, 0xF8, + 0xE1, 0xF6, 0xEE, 0xAE, 0xD9, 0x6D, 0x01, 0x80, 0x83, 0x52, 0x2E, 0xC6, + 0x62, 0x32, 0x67, 0xA3, 0xB9, 0xD6, 0x3A, 0x7A, 0xE7, 0xF1, 0x81, 0xC2, + 0x94, 0xDC, 0x94, 0x59, 0x26, 0xFA, 0x43, 0x54, 0x22, 0xAD, 0x26, 0xD3, + 0x3F, 0xFA, 0xD3, 0xBF, 0x7C, 0xF1, 0x57, 0xFB, 0x6F, 0x5F, 0x7C, 0x7B, + 0x7C, 0x7A, 0xF6, 0xA7, 0xFF, 0xF2, 0x2F, 0x7E, 0xFD, 0xEB, 0xBF, 0xDB, + 0xDD, 0xFC, 0x70, 0x74, 0x7A, 0x26, 0x07, 0x89, 0x31, 0x8A, 0x31, 0xF8, + 0x10, 0xE1, 0x41, 0x34, 0xE7, 0x93, 0x29, 0x9E, 0xE6, 0x19, 0x00, 0x40, + 0x1B, 0x0B, 0x63, 0x8A, 0x7A, 0x40, 0x10, 0x21, 0xEB, 0x42, 0xC2, 0x33, + 0x10, 0x8C, 0x7F, 0x14, 0xD3, 0xC1, 0xFB, 0xE8, 0x36, 0x08, 0xE0, 0x90, + 0xD8, 0x21, 0x04, 0x27, 0xAF, 0xC5, 0xE1, 0x83, 0xBD, 0xFF, 0x6D, 0xCE, + 0xBB, 0xD1, 0xA8, 0x68, 0x3B, 0x19, 0xFE, 0xC9, 0x25, 0x85, 0x10, 0x1C, + 0x82, 0x77, 0x00, 0xC0, 0x40, 0x10, 0x42, 0xD6, 0xB9, 0x94, 0x56, 0xE3, + 0x7D, 0x20, 0x04, 0x1B, 0x63, 0x5D, 0x04, 0x94, 0x20, 0x9C, 0x78, 0x79, + 0xE9, 0x73, 0x06, 0xD1, 0x1E, 0xB6, 0x75, 0xD1, 0x07, 0xAF, 0x6D, 0xA0, + 0x84, 0xA0, 0x10, 0xB4, 0x71, 0x6F, 0x2E, 0xAE, 0x8F, 0xE6, 0x93, 0xC7, + 0xE7, 0xA7, 0x00, 0x40, 0x6B, 0x5D, 0xDD, 0x34, 0xAB, 0x95, 0xED, 0xA5, + 0xD4, 0xDA, 0xC4, 0x18, 0x95, 0x56, 0xDA, 0x64, 0xC6, 0x5A, 0x08, 0x00, + 0x25, 0x38, 0xE5, 0x3A, 0xC3, 0x43, 0xBC, 0x1E, 0x06, 0x00, 0x70, 0x46, + 0xD3, 0xF5, 0x82, 0xA0, 0x03, 0xA9, 0xCD, 0x39, 0x07, 0xEF, 0x5D, 0xFE, + 0x84, 0x12, 0x42, 0x50, 0x26, 0x38, 0x26, 0x38, 0x19, 0x5D, 0x37, 0xDB, + 0xBA, 0x6E, 0x3B, 0x98, 0x38, 0xE9, 0x87, 0x1A, 0x1D, 0x22, 0x00, 0x7D, + 0x2F, 0xA5, 0x36, 0x21, 0x44, 0xEF, 0x3C, 0xE7, 0x2C, 0x15, 0x74, 0xAD, + 0x35, 0x63, 0x94, 0xA0, 0xC4, 0x40, 0x06, 0x18, 0xA3, 0xBE, 0x1F, 0xF2, + 0xA2, 0xE0, 0xF7, 0xE9, 0xC5, 0x11, 0x80, 0x08, 0x3C, 0x42, 0x44, 0x69, + 0x15, 0x01, 0x72, 0xD6, 0x79, 0xEF, 0xB5, 0xD2, 0xC9, 0x99, 0x93, 0xFC, + 0xAD, 0x83, 0xD4, 0x21, 0x46, 0xB5, 0xDE, 0x8D, 0x46, 0xF6, 0x68, 0x3E, + 0x4D, 0x5F, 0xB2, 0x24, 0x22, 0x41, 0x08, 0x31, 0xCA, 0x56, 0x9B, 0x1D, + 0x3C, 0xE4, 0x99, 0x86, 0xA2, 0xC8, 0x8F, 0x16, 0xB3, 0xB6, 0x1F, 0x94, + 0xB1, 0x8C, 0x12, 0xC1, 0x58, 0xF2, 0x90, 0x39, 0x6B, 0x41, 0x8C, 0x79, + 0x41, 0x19, 0xA3, 0x3E, 0xAD, 0xD6, 0x9C, 0x4F, 0x76, 0x38, 0x92, 0xCE, + 0x37, 0xBD, 0x52, 0x10, 0x22, 0x21, 0x58, 0x72, 0xFC, 0xA4, 0x2F, 0x76, + 0x72, 0xB1, 0xB9, 0xFB, 0x9C, 0x64, 0x63, 0x8C, 0x73, 0x16, 0x63, 0x92, + 0xE2, 0x10, 0x41, 0x84, 0x6D, 0x3F, 0x68, 0x63, 0x32, 0x21, 0xB4, 0x31, + 0xD6, 0x3A, 0x65, 0x4C, 0xB2, 0x7F, 0x43, 0x84, 0xA4, 0x31, 0x11, 0x80, + 0xE9, 0x78, 0xE4, 0x43, 0x68, 0xFB, 0x21, 0xED, 0xC5, 0x12, 0x96, 0xBB, + 0x57, 0x9A, 0x52, 0x32, 0x2A, 0x0B, 0x88, 0x90, 0x75, 0xDE, 0x0F, 0x12, + 0x02, 0x90, 0x84, 0xFB, 0xCE, 0x27, 0xE4, 0x31, 0x44, 0x10, 0x45, 0x10, + 0x53, 0x7C, 0x6F, 0xAA, 0x15, 0x09, 0x73, 0x8A, 0x31, 0xCE, 0xB3, 0xF4, + 0x15, 0x0C, 0xC1, 0x7B, 0x69, 0x7C, 0x2E, 0xA8, 0xA0, 0x28, 0xCB, 0xF3, + 0x3C, 0xCF, 0xBC, 0x73, 0x5E, 0x2B, 0xC1, 0xB3, 0xDB, 0xBB, 0x55, 0x3F, + 0x0C, 0xCE, 0xD9, 0xA0, 0x77, 0x14, 0x21, 0x63, 0x06, 0x1B, 0xC4, 0xD0, + 0xF4, 0xC6, 0xBA, 0x6A, 0xB2, 0xBC, 0xBE, 0x78, 0x31, 0x9D, 0x1E, 0x19, + 0x96, 0x73, 0x91, 0x63, 0x8C, 0x57, 0xB7, 0x97, 0xB3, 0xA3, 0x49, 0x51, + 0xCE, 0x42, 0x76, 0x86, 0x19, 0xD7, 0x5A, 0x61, 0xC2, 0x28, 0xF2, 0x8C, + 0x62, 0x8F, 0xB2, 0x2C, 0x78, 0x10, 0x8D, 0x0B, 0x9D, 0x0D, 0x47, 0x25, + 0x8C, 0x45, 0xC6, 0xFB, 0xBE, 0x1B, 0xA2, 0xCF, 0xB2, 0x92, 0x52, 0x0A, + 0x21, 0x48, 0x53, 0x39, 0xC1, 0x38, 0x78, 0x8F, 0x30, 0x84, 0x00, 0x1A, + 0xE3, 0xEE, 0x9F, 0x4C, 0x14, 0xBC, 0x77, 0xCE, 0x23, 0x8C, 0x5C, 0x62, + 0xE6, 0xC6, 0x80, 0x11, 0xB4, 0x36, 0xA4, 0xD7, 0x75, 0x6A, 0xE0, 0x13, + 0x45, 0x2B, 0x09, 0x45, 0xF2, 0x4C, 0x38, 0xE7, 0x40, 0x8C, 0x10, 0xC1, + 0xB6, 0xED, 0xD3, 0x93, 0xA3, 0x8D, 0x71, 0x18, 0x63, 0x84, 0xD3, 0x9F, + 0x91, 0x16, 0xCC, 0xE8, 0xDE, 0x49, 0x93, 0x9E, 0x3A, 0x6D, 0xAC, 0x8A, + 0x06, 0x21, 0x18, 0x7C, 0x70, 0xDE, 0xC7, 0x10, 0x20, 0xC6, 0x94, 0x10, + 0xC1, 0x79, 0xC6, 0x59, 0x55, 0x95, 0xDE, 0xFB, 0x41, 0xEA, 0x24, 0x4D, + 0xD0, 0x5A, 0xDF, 0x73, 0xC4, 0x50, 0x08, 0x21, 0xC6, 0xF4, 0x48, 0x03, + 0xE7, 0x0E, 0x40, 0xA4, 0x24, 0x55, 0x33, 0xDA, 0xF6, 0x60, 0xC0, 0x08, + 0x21, 0xCA, 0x8A, 0xDB, 0xDF, 0xFD, 0xEA, 0x57, 0xFF, 0xF7, 0xDE, 0x84, + 0xF1, 0xA8, 0x5C, 0x2E, 0x8F, 0x67, 0xC7, 0x4B, 0xC2, 0x18, 0xE5, 0x7C, + 0xC4, 0x8F, 0xBF, 0xFD, 0xC7, 0xDF, 0x0C, 0x7D, 0x8F, 0x19, 0x2F, 0xB3, + 0x4C, 0xB6, 0xF5, 0x6E, 0x75, 0xB7, 0x38, 0x3E, 0x71, 0x11, 0xD4, 0xED, + 0x70, 0x74, 0x76, 0x06, 0x11, 0xFE, 0x87, 0xBF, 0xF9, 0xCF, 0x41, 0x4B, + 0x87, 0x88, 0x0D, 0xBA, 0xA4, 0xFC, 0xD1, 0xE7, 0xBF, 0x8C, 0x54, 0x68, + 0xA5, 0x00, 0x88, 0xD1, 0xDA, 0xF0, 0xA3, 0xF8, 0xF6, 0x3E, 0x95, 0x2A, + 0xC5, 0xCA, 0x84, 0x08, 0xFB, 0xF5, 0xF5, 0xE5, 0xAB, 0xAF, 0x82, 0xF5, + 0x67, 0x67, 0x0F, 0x96, 0xD9, 0x31, 0x1B, 0x1D, 0x73, 0x51, 0x58, 0xE7, + 0x62, 0x3C, 0x20, 0x4D, 0x8D, 0xF3, 0xFE, 0x60, 0x08, 0x3D, 0x84, 0x0A, + 0x27, 0x5C, 0x5D, 0x6A, 0x66, 0x53, 0x2A, 0x95, 0x8F, 0x11, 0x40, 0x90, + 0x3E, 0xD8, 0x24, 0x3A, 0x07, 0xF7, 0x50, 0x6F, 0x6F, 0x6D, 0x08, 0x21, + 0x90, 0xA8, 0x8D, 0xCD, 0x04, 0xCB, 0x18, 0xBF, 0xBF, 0xF3, 0x42, 0x08, + 0x21, 0x21, 0x24, 0x26, 0x3B, 0xFC, 0xA1, 0xAD, 0x06, 0x59, 0xC6, 0x11, + 0x42, 0x52, 0xA9, 0x43, 0x37, 0x87, 0x0E, 0x91, 0xC9, 0x28, 0xD9, 0x0C, + 0x9C, 0xB3, 0xD6, 0x02, 0x10, 0x11, 0x22, 0x79, 0x2E, 0x86, 0x41, 0x69, + 0x63, 0x11, 0x82, 0x8C, 0xD1, 0xA4, 0xF3, 0x4C, 0xCF, 0x51, 0x2A, 0x86, + 0x18, 0xE3, 0xF4, 0xA0, 0xA5, 0x77, 0x21, 0x25, 0x64, 0xB5, 0xD9, 0x9F, + 0x1C, 0x2D, 0xC6, 0x65, 0xF1, 0x87, 0xAF, 0x5F, 0x28, 0xAD, 0x83, 0xF7, + 0x98, 0x90, 0x34, 0x48, 0xC6, 0x10, 0xA4, 0x94, 0x21, 0x1C, 0xAA, 0x58, + 0x0A, 0xC1, 0x82, 0x10, 0x06, 0x1F, 0xD2, 0xC8, 0x82, 0x10, 0x74, 0xCE, + 0x23, 0x84, 0x21, 0x8C, 0xA9, 0xD1, 0x76, 0xD6, 0x32, 0xCE, 0x13, 0xD9, + 0xD5, 0xC5, 0x10, 0x01, 0x28, 0x8B, 0x1C, 0x41, 0x28, 0xB5, 0xD9, 0xED, + 0x9A, 0xBA, 0xED, 0x22, 0x00, 0xC1, 0xFB, 0x74, 0x90, 0x69, 0xBB, 0x01, + 0x00, 0xA0, 0x93, 0x12, 0xED, 0x7E, 0xD7, 0x9A, 0xD4, 0x64, 0xDE, 0x7B, + 0x4E, 0x29, 0xC6, 0x48, 0x69, 0xD3, 0x0F, 0x2A, 0x5D, 0xBD, 0x11, 0xC6, + 0xE9, 0x80, 0x90, 0xCE, 0x4A, 0x84, 0x10, 0x68, 0x0C, 0x04, 0x90, 0x60, + 0x02, 0x10, 0xC2, 0x10, 0x49, 0x29, 0x95, 0x3C, 0x74, 0xF4, 0xE1, 0xB0, + 0x14, 0x76, 0x08, 0xA1, 0xA4, 0x9D, 0xB4, 0xC6, 0xFA, 0xE0, 0xA5, 0x36, + 0x5D, 0x3F, 0xA4, 0xBE, 0x2C, 0xA9, 0x58, 0xD2, 0xB5, 0x02, 0x21, 0x28, + 0x95, 0xBE, 0x5B, 0x6F, 0x28, 0x25, 0xF3, 0xD9, 0x38, 0x2D, 0x3D, 0x92, + 0xC4, 0xAF, 0x6D, 0xBB, 0x10, 0x02, 0x86, 0xC8, 0xDA, 0xC4, 0x5C, 0x04, + 0xF8, 0xDE, 0x93, 0x4B, 0xA6, 0xE3, 0xB1, 0x54, 0xCA, 0x5A, 0x1B, 0x62, + 0x54, 0xDA, 0x40, 0x88, 0x52, 0x2B, 0x04, 0x00, 0x0C, 0x11, 0x80, 0x08, + 0x84, 0xE0, 0xDE, 0x7B, 0xAD, 0x52, 0x10, 0x16, 0x4C, 0x98, 0xB4, 0x10, + 0x22, 0x84, 0x40, 0x4A, 0x19, 0xEE, 0x99, 0x9F, 0xA9, 0xF4, 0x62, 0x4C, + 0x94, 0x52, 0x00, 0xC2, 0x08, 0xA0, 0xF3, 0x01, 0x22, 0x38, 0x28, 0xDD, + 0x0F, 0x52, 0x19, 0xC3, 0x28, 0x2D, 0xB2, 0xEC, 0x10, 0xC5, 0xC8, 0x68, + 0x8C, 0x51, 0x69, 0x93, 0x96, 0x7F, 0x04, 0x23, 0x42, 0x09, 0x44, 0x00, + 0x42, 0xC4, 0x08, 0x71, 0xDE, 0x3B, 0x67, 0x13, 0x27, 0x21, 0xBD, 0x79, + 0xB4, 0x4E, 0xCF, 0x32, 0xA1, 0x28, 0x22, 0x8C, 0x21, 0x80, 0x88, 0x53, + 0x6D, 0x20, 0x23, 0x20, 0x58, 0x49, 0x49, 0xA6, 0x86, 0x06, 0x23, 0xD0, + 0x36, 0x9B, 0xBE, 0xDB, 0x78, 0x07, 0xD6, 0xAB, 0xCB, 0xD9, 0xA8, 0x82, + 0xBA, 0xFF, 0xFD, 0x8B, 0x77, 0x0F, 0xCE, 0x16, 0xC6, 0xC7, 0xED, 0xEA, + 0x9D, 0x0F, 0x2E, 0x42, 0x36, 0xDE, 0xCF, 0x20, 0x00, 0xFB, 0xBB, 0xFA, + 0xE1, 0xE3, 0x4F, 0x70, 0x70, 0x6D, 0xDD, 0xA8, 0xED, 0xC5, 0xB8, 0xC0, + 0xAD, 0xD6, 0x3C, 0x8B, 0x58, 0x5F, 0x59, 0x0B, 0x78, 0x31, 0x9E, 0x2E, + 0x79, 0xD3, 0xED, 0x06, 0xAB, 0x7D, 0x88, 0xAD, 0xDE, 0x11, 0x21, 0x1C, + 0x42, 0xBB, 0xD5, 0xBB, 0x3D, 0xB4, 0x7D, 0xB3, 0x9D, 0x2E, 0x1F, 0x60, + 0x7C, 0x4A, 0x49, 0x15, 0x63, 0x54, 0x7D, 0xCF, 0x38, 0x77, 0x10, 0x60, + 0xC2, 0x95, 0xEC, 0xAA, 0x6A, 0x4C, 0x31, 0x4C, 0x59, 0x70, 0x99, 0xA0, + 0x5A, 0xAB, 0xE5, 0xB8, 0xE8, 0x75, 0x8C, 0x80, 0x02, 0x1F, 0x38, 0x23, + 0x8C, 0x12, 0xEF, 0x03, 0xE7, 0x24, 0xF8, 0x00, 0x00, 0xB4, 0xC6, 0x42, + 0x10, 0x33, 0x41, 0x23, 0x60, 0x18, 0x41, 0x21, 0x18, 0x25, 0xB9, 0xD2, + 0x26, 0x35, 0x4D, 0x69, 0x00, 0x4C, 0x9F, 0x83, 0xF3, 0x4E, 0x2A, 0x15, + 0x42, 0xE0, 0x94, 0x11, 0x4C, 0x20, 0x84, 0xD6, 0x5A, 0x00, 0x61, 0x12, + 0xD7, 0x10, 0x92, 0x02, 0x84, 0x0E, 0xDF, 0xC7, 0x3E, 0x84, 0xAA, 0x2A, + 0xAB, 0x22, 0x13, 0x9C, 0x51, 0xC6, 0x52, 0xCC, 0x47, 0x26, 0xD2, 0x4D, + 0xDD, 0x03, 0xC0, 0x13, 0xAC, 0xC5, 0xB9, 0xE4, 0x66, 0x65, 0xF7, 0xFA, + 0x75, 0x1C, 0x23, 0x80, 0x30, 0x42, 0x08, 0x92, 0x74, 0x40, 0x0E, 0x12, + 0x50, 0x7E, 0xDC, 0x5E, 0xBE, 0xFC, 0xC3, 0xDF, 0x6E, 0x94, 0x1D, 0x57, + 0xA3, 0xB2, 0xA8, 0x96, 0x0F, 0x1E, 0x4D, 0x16, 0x47, 0x04, 0x43, 0x42, + 0xE9, 0xD0, 0x77, 0xFB, 0xBB, 0xAB, 0xF5, 0x7A, 0x13, 0x9C, 0x87, 0x10, + 0xE6, 0x45, 0xFE, 0xE2, 0xAB, 0x7F, 0xAC, 0x66, 0xFF, 0x66, 0x3C, 0x1E, + 0x8F, 0xA7, 0xD3, 0xAC, 0x28, 0xB6, 0x77, 0x37, 0x97, 0x2F, 0xBF, 0xD9, + 0xF7, 0x32, 0x46, 0x30, 0x62, 0xEC, 0xF1, 0xF3, 0x4F, 0xA7, 0xE7, 0xCF, + 0xD7, 0xFB, 0xA4, 0x58, 0x8C, 0xC9, 0x76, 0x89, 0x21, 0x82, 0x49, 0x2A, + 0x18, 0x23, 0x63, 0xD4, 0x39, 0x6F, 0xB4, 0xD5, 0x1E, 0x82, 0xBB, 0x8B, + 0x9B, 0x9B, 0x0B, 0x92, 0x8F, 0x10, 0x2D, 0xA4, 0x23, 0xE3, 0xE5, 0x79, + 0x0C, 0xC0, 0xB4, 0x2D, 0x23, 0x08, 0x02, 0xE8, 0x23, 0x00, 0xD1, 0xC5, + 0x10, 0x92, 0x71, 0xD5, 0x18, 0x93, 0x82, 0x79, 0x72, 0x21, 0x08, 0x26, + 0x10, 0x22, 0x04, 0xE2, 0x01, 0xA3, 0x16, 0x13, 0xA1, 0x8C, 0x43, 0x08, + 0xE1, 0x3D, 0xDD, 0x34, 0x75, 0xF4, 0x10, 0xA2, 0x41, 0x6A, 0x88, 0x60, + 0x55, 0xE4, 0x18, 0x23, 0xEB, 0x28, 0xA3, 0xA4, 0x1F, 0x74, 0xAA, 0x2F, + 0xDE, 0x7B, 0x10, 0xEF, 0x13, 0x8F, 0x7C, 0x48, 0xBC, 0x8A, 0x84, 0xA0, + 0x51, 0xDA, 0x68, 0xE3, 0x38, 0xA4, 0x10, 0x44, 0x04, 0x10, 0x82, 0x30, + 0x15, 0x4A, 0x6B, 0xED, 0x30, 0xC8, 0x3C, 0xCF, 0x38, 0xA7, 0x52, 0x7A, + 0xEF, 0x63, 0x0C, 0x11, 0x62, 0xE8, 0xBD, 0x47, 0x07, 0x72, 0x74, 0x88, + 0x31, 0x52, 0x0A, 0xEE, 0x07, 0x79, 0x98, 0xF6, 0x21, 0x20, 0x82, 0x37, + 0xEF, 0xAF, 0x3F, 0x7A, 0xFA, 0x30, 0xE5, 0x07, 0xA6, 0x9B, 0xEC, 0x01, + 0x52, 0x82, 0x50, 0xDA, 0xA8, 0x58, 0xE7, 0x71, 0x1A, 0x99, 0x31, 0xA6, + 0x94, 0x86, 0x18, 0xD3, 0x3E, 0x8F, 0x92, 0x43, 0x6E, 0x08, 0x42, 0x28, + 0xA9, 0x47, 0x93, 0xA4, 0x4E, 0x1B, 0xCB, 0x39, 0x6F, 0xDA, 0x46, 0x19, + 0xCB, 0x19, 0xA0, 0x08, 0x0F, 0x83, 0x6C, 0x9A, 0x0E, 0x1C, 0x82, 0xAD, + 0x62, 0x99, 0x65, 0x4A, 0x25, 0xD4, 0x38, 0x38, 0x28, 0xF1, 0x41, 0x2A, + 0xE2, 0x58, 0x08, 0x1E, 0xC2, 0x81, 0x72, 0xD9, 0x76, 0x83, 0x3E, 0x44, + 0xE1, 0x81, 0x43, 0x6D, 0x8D, 0x51, 0x2A, 0x4D, 0x09, 0xD2, 0xDA, 0x58, + 0xE7, 0xD3, 0xA5, 0x12, 0x63, 0x32, 0x48, 0xA5, 0x95, 0x52, 0x4A, 0x43, + 0x00, 0x21, 0x82, 0x07, 0xCB, 0xCA, 0xFD, 0xBB, 0x11, 0x21, 0xD4, 0xF5, + 0x83, 0x49, 0x0A, 0x20, 0x1F, 0x52, 0xD8, 0x6B, 0x1A, 0x51, 0xC1, 0x21, + 0xF0, 0x2D, 0x26, 0x9A, 0x0B, 0x67, 0xAC, 0xC8, 0xB3, 0x08, 0x00, 0x84, + 0x00, 0x01, 0x94, 0x8C, 0x89, 0xA3, 0xAA, 0x32, 0xE6, 0x00, 0x46, 0x47, + 0x18, 0x41, 0x88, 0x0E, 0xE9, 0xF4, 0x4A, 0x92, 0xA6, 0xEB, 0x07, 0xA9, + 0x00, 0x8C, 0xDE, 0xD9, 0x3C, 0x2B, 0x0E, 0x2C, 0x74, 0x00, 0x52, 0x21, + 0x84, 0x08, 0xB5, 0x5D, 0x1F, 0x13, 0x3C, 0x13, 0x23, 0x0C, 0xB1, 0xB1, + 0xD6, 0x69, 0x23, 0x38, 0x95, 0x52, 0x22, 0x8C, 0xF2, 0x2C, 0x8B, 0x31, + 0x5A, 0xEB, 0x21, 0x82, 0xD0, 0x07, 0x6B, 0x65, 0xEA, 0x11, 0x08, 0x84, + 0x08, 0x23, 0xA5, 0x0D, 0xC6, 0x28, 0x13, 0x42, 0x08, 0x9E, 0xCE, 0x3D, + 0xE8, 0xDE, 0x4F, 0x8F, 0x30, 0xD4, 0xC6, 0xC4, 0x10, 0x8C, 0x75, 0x9C, + 0xD3, 0xAA, 0xC8, 0x62, 0x04, 0x72, 0x18, 0x1C, 0x65, 0xF1, 0x1E, 0x28, + 0x1A, 0x41, 0xB4, 0x5A, 0xCB, 0x41, 0x61, 0x42, 0xD6, 0x57, 0x17, 0x67, + 0x8F, 0x1F, 0xAB, 0xBE, 0xF6, 0xDE, 0xCA, 0x7E, 0xB7, 0xDD, 0x6E, 0x09, + 0xA1, 0xD4, 0xEF, 0x47, 0x25, 0x45, 0x45, 0xD5, 0xB5, 0xDD, 0xE6, 0x8D, + 0x24, 0x98, 0xDC, 0xED, 0x74, 0xD7, 0xB6, 0x01, 0x62, 0xB9, 0xBD, 0xF5, + 0x28, 0x1B, 0x06, 0xF5, 0xF5, 0xD7, 0xDF, 0xCA, 0xF6, 0x12, 0x22, 0x1F, + 0x11, 0x17, 0x59, 0xB5, 0x5B, 0x5D, 0x60, 0x14, 0x1E, 0x3C, 0xFE, 0xC5, + 0x37, 0x5F, 0xFF, 0x0E, 0x45, 0x39, 0x1D, 0x71, 0x81, 0x2D, 0x86, 0xE5, + 0xE9, 0x83, 0x63, 0x29, 0xF7, 0x6E, 0xFF, 0x5D, 0x3B, 0xA8, 0xFA, 0xC6, + 0x3E, 0x38, 0x9A, 0xD7, 0xBB, 0x3D, 0x22, 0xB4, 0x6F, 0x1B, 0x29, 0x25, + 0x06, 0xB4, 0xCA, 0xB7, 0xBD, 0xD4, 0xDF, 0x7D, 0xFB, 0x87, 0xF1, 0x78, + 0x1C, 0xAA, 0xDC, 0xE9, 0xDC, 0xFA, 0xD5, 0xD0, 0xB7, 0x5C, 0x54, 0x02, + 0x4D, 0x95, 0x31, 0x75, 0xB3, 0x23, 0x84, 0xBB, 0xE6, 0xDA, 0x78, 0xEF, + 0x43, 0xA8, 0x26, 0xC7, 0xAA, 0x6F, 0xBC, 0x07, 0x31, 0x64, 0x9C, 0xC2, + 0xA6, 0xED, 0x19, 0xC1, 0x19, 0x03, 0x3E, 0x86, 0x82, 0x23, 0x17, 0x1C, + 0x46, 0x84, 0xE1, 0x40, 0x05, 0x43, 0x90, 0x0E, 0xDA, 0x61, 0x8C, 0x19, + 0xC1, 0x3E, 0xC4, 0x9C, 0x53, 0xC1, 0x69, 0xD7, 0xCB, 0xC0, 0x48, 0x32, + 0xFD, 0x92, 0x7B, 0x47, 0xAE, 0xF7, 0x0E, 0x41, 0x14, 0xE2, 0xA1, 0x0B, + 0x8B, 0x31, 0x08, 0x46, 0xBD, 0x4B, 0x26, 0x08, 0x68, 0x01, 0x00, 0x20, + 0x42, 0x88, 0xDC, 0x7D, 0x9B, 0x26, 0x95, 0x46, 0xF7, 0xA4, 0xC3, 0x83, + 0x5C, 0x16, 0x42, 0x48, 0x70, 0x04, 0x89, 0x9F, 0x18, 0xAD, 0xFD, 0xFF, + 0x51, 0x88, 0xDA, 0x1A, 0x10, 0x0F, 0xE9, 0x38, 0x11, 0x44, 0x17, 0x02, + 0x27, 0x44, 0x05, 0x74, 0x16, 0xDA, 0xFE, 0xF5, 0xDF, 0xBF, 0x58, 0x6D, + 0xCA, 0x72, 0x54, 0x8D, 0x46, 0x93, 0xC5, 0xD1, 0xC3, 0x8F, 0x3F, 0x17, + 0xC5, 0x8C, 0x40, 0x9F, 0x51, 0xDA, 0x2A, 0x09, 0x63, 0x98, 0x8E, 0x47, + 0x17, 0x17, 0x17, 0x75, 0x53, 0x23, 0x84, 0x6C, 0x5F, 0xF7, 0xDB, 0x95, + 0xA0, 0x48, 0x88, 0x0C, 0x01, 0xF0, 0xEA, 0xCB, 0x5F, 0x2F, 0xE6, 0xF3, + 0x46, 0xDD, 0x0E, 0x52, 0xB3, 0x82, 0x9E, 0x3C, 0xFA, 0xA0, 0x95, 0x4E, + 0x2A, 0x85, 0x10, 0xC6, 0x08, 0x7A, 0xEF, 0x23, 0x88, 0x0E, 0x26, 0xE0, + 0xEF, 0xC1, 0x42, 0xDB, 0xB4, 0x83, 0x35, 0x06, 0x13, 0xDE, 0x5E, 0xFD, + 0x20, 0x8D, 0x3F, 0x3F, 0xAA, 0x3A, 0x03, 0x35, 0xD0, 0xDE, 0x1A, 0xE7, + 0x1C, 0x04, 0x11, 0x23, 0xD4, 0xB4, 0xBD, 0xF1, 0xDE, 0x7B, 0x3F, 0x2E, + 0x0B, 0x1F, 0x83, 0x52, 0xDA, 0x3A, 0xA7, 0xB5, 0x16, 0xFC, 0xB0, 0x72, + 0xF6, 0x31, 0xA6, 0xDB, 0x65, 0x08, 0x01, 0x22, 0x84, 0x71, 0x02, 0x02, + 0x86, 0xB4, 0xDE, 0x4A, 0xE8, 0xB1, 0x44, 0xA0, 0xCA, 0x31, 0x66, 0x9C, + 0x12, 0x82, 0x07, 0x29, 0x21, 0x8C, 0x9C, 0x33, 0xEB, 0x3C, 0x25, 0xB4, + 0x1B, 0x24, 0x8A, 0x88, 0x71, 0x0A, 0x01, 0x3D, 0x80, 0x6E, 0x94, 0x21, + 0x94, 0x10, 0x4C, 0x28, 0xA3, 0x9C, 0xF3, 0xDD, 0xBE, 0xB5, 0xCE, 0x53, + 0x8C, 0xB5, 0xB6, 0x94, 0x92, 0x74, 0xAE, 0xA1, 0x94, 0x11, 0x12, 0x93, + 0x6E, 0x96, 0x31, 0xAA, 0xB5, 0x75, 0xCE, 0x21, 0x0F, 0x13, 0x14, 0x28, + 0x84, 0x88, 0x50, 0x52, 0xE1, 0xE8, 0x14, 0x8F, 0xE7, 0x3D, 0x0C, 0x69, + 0xB7, 0x4B, 0x69, 0xD7, 0xAB, 0xF7, 0xD7, 0xAB, 0xA7, 0x0F, 0x8F, 0xFD, + 0xFD, 0xCC, 0x98, 0x68, 0x82, 0x09, 0x61, 0x24, 0x95, 0x4E, 0xEA, 0x4E, + 0x00, 0x93, 0xC7, 0xD3, 0x30, 0x4A, 0x93, 0x77, 0x58, 0x1B, 0x4F, 0xEF, + 0xE9, 0x89, 0x31, 0x46, 0x84, 0x71, 0x8C, 0x30, 0x05, 0x44, 0x28, 0xA5, + 0x8D, 0x31, 0x19, 0x63, 0x4A, 0x6B, 0xEF, 0xC8, 0x7E, 0xDF, 0x26, 0x6A, + 0x43, 0x04, 0x20, 0x31, 0xF2, 0xD2, 0x93, 0x6E, 0x0F, 0xBD, 0xD8, 0xE1, + 0x3F, 0xE7, 0xFD, 0xD0, 0x0F, 0x08, 0x40, 0xAD, 0x8D, 0x4E, 0x32, 0xD7, + 0x7B, 0x7E, 0x53, 0xFA, 0x4E, 0x3A, 0x1C, 0xE8, 0x23, 0x0C, 0x00, 0xA8, + 0x41, 0xC1, 0x5C, 0x60, 0x84, 0xA4, 0x52, 0x7D, 0xD7, 0xFB, 0xE8, 0x21, + 0x04, 0x84, 0x60, 0x74, 0x30, 0xE7, 0x07, 0x6B, 0x6D, 0x9E, 0x89, 0xE9, + 0x64, 0xDC, 0xF5, 0x43, 0x3F, 0x48, 0x89, 0x10, 0x88, 0x31, 0x1D, 0xFD, + 0xA4, 0xD2, 0xDE, 0x7B, 0xC6, 0x18, 0x84, 0xD0, 0x1A, 0xE7, 0x9C, 0x9B, + 0x4E, 0x46, 0xB3, 0xD9, 0x64, 0xBD, 0xDE, 0x78, 0xEF, 0xF3, 0x3C, 0xFB, + 0xF1, 0x45, 0xAE, 0x94, 0x22, 0x04, 0x67, 0x19, 0xB7, 0xCE, 0x33, 0x9E, + 0x8D, 0x26, 0x23, 0x63, 0x4C, 0xD2, 0xA5, 0x87, 0x10, 0x88, 0x54, 0x3A, + 0x75, 0xD1, 0x9C, 0x52, 0x00, 0x61, 0x0C, 0x21, 0xA5, 0xE9, 0x18, 0x63, + 0x8D, 0x01, 0x31, 0x04, 0x42, 0x29, 0xE7, 0x38, 0x55, 0xCC, 0x14, 0x0B, + 0xC8, 0x28, 0x31, 0x46, 0x53, 0x82, 0x19, 0xE7, 0x49, 0x86, 0x0E, 0x20, + 0x44, 0x08, 0x3B, 0x1F, 0x9C, 0xB3, 0x31, 0xC6, 0x2A, 0xCB, 0x38, 0xA3, + 0xB9, 0xE0, 0x31, 0x02, 0x6B, 0x1C, 0xC6, 0xB8, 0x2C, 0xCB, 0xE4, 0x8C, + 0x26, 0x18, 0x0B, 0x46, 0x8D, 0xB1, 0x4D, 0x1B, 0x33, 0x4E, 0x41, 0x88, + 0x10, 0x63, 0xC1, 0x18, 0x00, 0x70, 0xBF, 0xDD, 0x06, 0xE7, 0xA7, 0xF3, + 0x05, 0xC6, 0x24, 0xC6, 0x60, 0x8D, 0x1E, 0xFA, 0xAE, 0x69, 0x36, 0x7D, + 0xD7, 0x44, 0x20, 0xD7, 0x97, 0xAF, 0x5F, 0xBF, 0xFE, 0xDB, 0x7A, 0xD7, + 0x14, 0x82, 0xF9, 0x60, 0x40, 0xF4, 0x93, 0x51, 0xA1, 0xFB, 0x7D, 0x59, + 0xE4, 0x79, 0x9E, 0xED, 0x6A, 0x49, 0x00, 0xC2, 0x64, 0xF4, 0xFB, 0x17, + 0x77, 0x37, 0x77, 0x77, 0xF3, 0xE5, 0xB1, 0xD4, 0x6E, 0x32, 0x2A, 0x67, + 0xF3, 0xA3, 0xEB, 0x37, 0x77, 0xCF, 0x3F, 0xF9, 0x67, 0xFB, 0xD5, 0x45, + 0xDF, 0xED, 0xD6, 0xB7, 0x77, 0x47, 0x0F, 0x9E, 0xF2, 0xAC, 0xBC, 0xB9, + 0xB9, 0x6D, 0x9B, 0x0B, 0x6B, 0xEA, 0x93, 0x93, 0x07, 0x79, 0x56, 0x2A, + 0xB5, 0x2D, 0x04, 0xA6, 0x30, 0xEE, 0xEA, 0xDA, 0x3A, 0x35, 0xAE, 0xCA, + 0x7A, 0xBF, 0x59, 0x4C, 0xC6, 0x4D, 0xB7, 0xDF, 0xED, 0xF6, 0xBB, 0xA6, + 0xE1, 0x4C, 0x30, 0x68, 0xBB, 0xBA, 0x99, 0x8F, 0x73, 0x21, 0x30, 0xF6, + 0xDB, 0xF5, 0x9B, 0x77, 0x05, 0x0B, 0x83, 0x05, 0x4F, 0x9E, 0x7E, 0xB8, + 0xBD, 0x7A, 0x75, 0x71, 0x75, 0x13, 0x63, 0x9C, 0x8D, 0xAA, 0xA3, 0xD3, + 0x67, 0xF5, 0x7E, 0x17, 0xBC, 0x9A, 0x88, 0xA1, 0xED, 0xDA, 0xD9, 0x28, + 0x9B, 0x65, 0xF8, 0xC5, 0x9B, 0x37, 0x56, 0xCA, 0xD1, 0x74, 0xD6, 0xEF, + 0x72, 0x2C, 0xE6, 0xC1, 0x49, 0xC1, 0x70, 0x3D, 0x48, 0x88, 0x45, 0x96, + 0x8D, 0x42, 0x84, 0x8C, 0xD2, 0xE4, 0x06, 0xAF, 0x72, 0x16, 0x21, 0xA4, + 0x10, 0x78, 0x46, 0x40, 0x08, 0x08, 0x41, 0x10, 0x01, 0x86, 0x88, 0x50, + 0xEC, 0x42, 0x4C, 0x91, 0x02, 0x94, 0x20, 0x10, 0x81, 0xD2, 0x86, 0x60, + 0xEC, 0x7C, 0x04, 0x90, 0x24, 0x51, 0x0E, 0x42, 0x10, 0x21, 0x96, 0x6E, + 0x8E, 0x49, 0xB4, 0x6D, 0x8C, 0x21, 0xF7, 0x6F, 0x8E, 0xB4, 0xAB, 0x0E, + 0x21, 0x24, 0x9A, 0x5B, 0x0A, 0x15, 0xC9, 0x04, 0x03, 0x00, 0x18, 0x6B, + 0xB5, 0xB5, 0xD6, 0x3B, 0x04, 0x11, 0xF0, 0x09, 0x1A, 0x05, 0x18, 0xA1, + 0x75, 0xAF, 0x4E, 0x73, 0x68, 0x2F, 0x7E, 0xF3, 0xE5, 0x9B, 0xB7, 0x59, + 0x56, 0x64, 0x22, 0x1B, 0x4F, 0xA7, 0xCF, 0x7F, 0xF1, 0xCF, 0x71, 0x75, + 0x72, 0xB1, 0x55, 0x31, 0x82, 0xA7, 0x22, 0xD2, 0xE0, 0x38, 0xE3, 0x84, + 0xC6, 0xA3, 0xC5, 0xF2, 0xE2, 0xC5, 0x77, 0xD1, 0xC7, 0x2F, 0x7E, 0xF2, + 0x0B, 0xE4, 0x35, 0x70, 0x8E, 0xE5, 0x63, 0xAF, 0x65, 0x90, 0xED, 0xF1, + 0xC9, 0xA9, 0x28, 0x27, 0x75, 0x27, 0xA7, 0x34, 0xD2, 0x6A, 0xD1, 0x28, + 0x1F, 0x11, 0xF3, 0x20, 0x42, 0x88, 0x00, 0x21, 0x18, 0x02, 0xA7, 0x65, + 0x18, 0x06, 0x80, 0x59, 0x20, 0xD4, 0x1A, 0xD7, 0x75, 0x43, 0x2B, 0x75, + 0x09, 0xF6, 0x97, 0xAF, 0xBF, 0x0E, 0x10, 0x55, 0xA3, 0x49, 0x59, 0x4D, + 0x4C, 0xAF, 0xEA, 0xB6, 0xB7, 0x49, 0x8F, 0x10, 0x82, 0x71, 0x2E, 0xE9, + 0xE9, 0x77, 0x4D, 0x9B, 0x3A, 0x2C, 0xEB, 0x1C, 0x4F, 0x55, 0x0C, 0xC2, + 0xD4, 0x78, 0xA6, 0x20, 0xB8, 0xC4, 0xCE, 0xEF, 0x07, 0x95, 0xBA, 0x95, + 0x24, 0xEB, 0x83, 0xF7, 0xD9, 0x28, 0x65, 0x71, 0x90, 0x4F, 0xF6, 0x83, + 0x44, 0x08, 0x32, 0x42, 0xD3, 0xDD, 0x46, 0x6B, 0x8D, 0x11, 0x64, 0x94, + 0xA7, 0xFB, 0x20, 0x21, 0x94, 0x31, 0xAE, 0x94, 0x01, 0x00, 0x68, 0x63, + 0xBA, 0xAE, 0x1F, 0x8D, 0x47, 0x79, 0xC6, 0x9B, 0xAE, 0xB7, 0x1E, 0x12, + 0x8C, 0xAC, 0xF3, 0x10, 0x44, 0x42, 0xB0, 0x73, 0xDE, 0x7B, 0x07, 0x00, + 0x34, 0xC6, 0xA5, 0x41, 0x29, 0xC6, 0x00, 0x11, 0x4E, 0x86, 0xD6, 0x94, + 0x4C, 0x04, 0x0F, 0x88, 0xDD, 0x88, 0x20, 0x71, 0x3E, 0x80, 0x10, 0x7D, + 0x08, 0xDE, 0x07, 0x42, 0xC8, 0xCD, 0xDD, 0x06, 0xC4, 0x70, 0x7A, 0x3C, + 0xA7, 0x04, 0xFF, 0x38, 0xEE, 0xA4, 0x7B, 0x22, 0x67, 0x34, 0x84, 0xF0, + 0xA3, 0xE3, 0x3D, 0x82, 0x44, 0x58, 0x23, 0x00, 0x00, 0x4A, 0x28, 0xF8, + 0x27, 0x5D, 0x8F, 0x3B, 0x50, 0x12, 0x3D, 0x88, 0x51, 0x1B, 0x13, 0x41, + 0x50, 0x5A, 0x49, 0x65, 0x9C, 0x1D, 0xB4, 0xB1, 0x11, 0xC0, 0x84, 0x53, + 0x27, 0x08, 0xFF, 0x78, 0x22, 0x83, 0x10, 0x22, 0x08, 0x52, 0x0E, 0x09, + 0x00, 0x10, 0x45, 0xA0, 0xA4, 0xC2, 0x10, 0x19, 0xE7, 0x7D, 0x8C, 0xF0, + 0x90, 0x83, 0x1B, 0x20, 0x44, 0x07, 0x52, 0x7A, 0x1A, 0x66, 0x53, 0xD8, + 0x0C, 0x88, 0x52, 0xE9, 0xE0, 0xBD, 0xD6, 0x3A, 0xED, 0x1C, 0x11, 0x46, + 0x84, 0xE0, 0xA4, 0xB2, 0xAE, 0x0A, 0xE1, 0x1C, 0x43, 0x08, 0x8D, 0x47, + 0x95, 0xF5, 0x4E, 0x1B, 0x83, 0x20, 0x2C, 0xB2, 0xDC, 0x79, 0x8F, 0x11, + 0x62, 0x84, 0x48, 0xA5, 0xC2, 0xC1, 0x6D, 0x8E, 0x30, 0x14, 0xD6, 0xDA, + 0xDB, 0xBB, 0x15, 0xA3, 0xCC, 0x5A, 0x2B, 0x07, 0x80, 0x10, 0xE4, 0x9C, + 0xC7, 0x10, 0x53, 0x11, 0x37, 0xC6, 0x72, 0x21, 0xBC, 0xF7, 0x29, 0xD4, + 0x35, 0xFD, 0x93, 0x9D, 0x73, 0x84, 0x51, 0xCA, 0x05, 0x1F, 0x06, 0x69, + 0x7D, 0xF0, 0xDE, 0x32, 0x4A, 0x31, 0xC6, 0x29, 0x37, 0xA4, 0x2A, 0x33, + 0x84, 0x90, 0x60, 0x78, 0x5B, 0xB7, 0x08, 0x42, 0xA5, 0xAD, 0xE0, 0x34, + 0x51, 0x62, 0xCA, 0x3C, 0x43, 0x08, 0x6B, 0xE7, 0x18, 0xE3, 0x98, 0x50, + 0xEB, 0xAC, 0x1C, 0x64, 0xBA, 0xE8, 0xE7, 0x19, 0xCF, 0x33, 0x31, 0x1B, + 0x95, 0x31, 0x46, 0xE3, 0x02, 0x88, 0x11, 0x22, 0x50, 0x72, 0x04, 0x11, + 0xC2, 0x10, 0xE6, 0x45, 0x41, 0x08, 0xEE, 0x7A, 0xA9, 0x95, 0x46, 0x5E, + 0x7B, 0x8C, 0x8C, 0x51, 0xBA, 0xA5, 0x7D, 0x57, 0x46, 0x67, 0xAB, 0xF1, + 0xE4, 0xB7, 0xBF, 0xF9, 0xFB, 0xCD, 0x66, 0x5B, 0xE6, 0xF4, 0xFD, 0xBB, + 0x97, 0x18, 0x85, 0xB6, 0xDD, 0x38, 0x2F, 0x11, 0xF2, 0xD1, 0x7A, 0x65, + 0xCC, 0xD1, 0xEC, 0xEC, 0xBA, 0x76, 0xEF, 0xAF, 0xEF, 0x3E, 0xF9, 0x70, + 0xB9, 0xAD, 0x2F, 0x39, 0x02, 0x57, 0xAB, 0x5D, 0x08, 0xF4, 0x64, 0xF9, + 0xB0, 0xA0, 0x78, 0xBD, 0xEF, 0x06, 0xA5, 0xF3, 0x3C, 0x77, 0xCE, 0x0C, + 0x43, 0x7F, 0x77, 0x7B, 0xB1, 0xA8, 0x8F, 0x1F, 0x9D, 0x3F, 0x5B, 0xAF, + 0x56, 0xE3, 0xC9, 0xD2, 0x7B, 0xFD, 0xD9, 0xA3, 0x9F, 0x41, 0x08, 0xDE, + 0xBE, 0xFC, 0x6D, 0x88, 0xB8, 0x6E, 0xF7, 0x18, 0xFA, 0x1F, 0x5E, 0xBE, + 0x76, 0xCE, 0x9D, 0x2C, 0xE7, 0x3A, 0xCF, 0xDA, 0xAE, 0xEF, 0x87, 0x61, + 0x39, 0x1D, 0xB7, 0x9D, 0xE9, 0xFB, 0x0D, 0x09, 0xB1, 0x57, 0xAA, 0xEB, + 0x0D, 0xC5, 0xCC, 0x1A, 0xDB, 0xEE, 0x6B, 0x8E, 0xB1, 0xC7, 0xA8, 0x93, + 0xFD, 0x76, 0xFF, 0x0D, 0x0E, 0xE1, 0x3A, 0x04, 0xC2, 0x29, 0x26, 0x40, + 0x77, 0x2D, 0x88, 0x30, 0x46, 0x3F, 0xC8, 0xB8, 0x5D, 0xBD, 0xA8, 0x77, + 0x35, 0x86, 0xE8, 0xD6, 0xED, 0x6D, 0x70, 0x23, 0x3A, 0xFF, 0xC3, 0x97, + 0xEF, 0x7B, 0xAD, 0x30, 0x00, 0x7B, 0xBF, 0x3D, 0x7F, 0xF0, 0xE9, 0xC5, + 0xD5, 0x6F, 0x39, 0xA5, 0x03, 0x42, 0x31, 0x40, 0x2E, 0xA6, 0x63, 0x31, + 0x1A, 0x4C, 0x30, 0x5A, 0xE7, 0x59, 0x31, 0x29, 0xC8, 0xAE, 0x33, 0x83, + 0x94, 0x8C, 0xE7, 0x52, 0x69, 0x82, 0x51, 0x41, 0xB9, 0xB1, 0x36, 0x46, + 0xAF, 0xA5, 0x66, 0xD0, 0x31, 0xEA, 0x50, 0xA8, 0x05, 0xF6, 0x04, 0x61, + 0x80, 0xBD, 0x05, 0xA2, 0xB3, 0xF9, 0x68, 0x59, 0x56, 0x19, 0xDF, 0xF6, + 0x3E, 0xD3, 0x5E, 0x70, 0xBA, 0xAD, 0x3B, 0x82, 0x62, 0x29, 0x28, 0x67, + 0x08, 0x13, 0x0E, 0x29, 0xCB, 0x18, 0x8E, 0x08, 0x22, 0x9C, 0xD2, 0x61, + 0x95, 0xE9, 0x1D, 0x0C, 0x96, 0x53, 0xD8, 0x3B, 0xE0, 0x01, 0x46, 0xD1, + 0x01, 0x00, 0xD3, 0xA2, 0x1A, 0xC2, 0x24, 0x6E, 0x23, 0x20, 0x18, 0x64, + 0xEA, 0x27, 0x8B, 0xF9, 0x4C, 0xBF, 0xFF, 0xAB, 0xF7, 0x97, 0x34, 0x2B, + 0x38, 0xA5, 0xB3, 0xC5, 0xF2, 0xF9, 0xCF, 0xFF, 0x14, 0x56, 0xE7, 0x57, + 0x6B, 0x69, 0x9D, 0x47, 0x08, 0xBF, 0xBA, 0x51, 0x59, 0x3B, 0xCC, 0x97, + 0x27, 0x74, 0x34, 0x2D, 0xAF, 0xDE, 0xFD, 0xAD, 0x52, 0xDA, 0xC5, 0xE2, + 0xC1, 0x4F, 0xDA, 0xB6, 0xB5, 0x91, 0xB7, 0x5D, 0x98, 0xE4, 0xF9, 0xE3, + 0xC7, 0x0F, 0xB7, 0x9D, 0xFB, 0xE8, 0x8B, 0x93, 0xCB, 0xDB, 0x0D, 0x55, + 0xDD, 0x44, 0x70, 0x14, 0x6A, 0xE7, 0x06, 0x8A, 0x90, 0xAE, 0xF7, 0xBB, + 0x4E, 0x0E, 0xCD, 0xD6, 0x6C, 0x6F, 0xB4, 0x92, 0x24, 0xAB, 0xE8, 0xC9, + 0xC7, 0x48, 0x4C, 0x82, 0xB1, 0x99, 0x1D, 0x9A, 0x77, 0xBF, 0xBB, 0x5A, + 0xAF, 0x33, 0xCE, 0x27, 0xCB, 0x33, 0xCA, 0x45, 0x7B, 0xB3, 0x96, 0x5A, + 0xDB, 0x83, 0x62, 0x03, 0xA3, 0xA4, 0x0D, 0x73, 0x1E, 0x22, 0x50, 0xE4, + 0x59, 0x12, 0x5E, 0xC0, 0xFB, 0xB8, 0x80, 0x18, 0x23, 0x25, 0x98, 0x31, + 0xAA, 0xB5, 0x41, 0x10, 0x1A, 0x1F, 0xFC, 0xFD, 0x3A, 0x09, 0x4B, 0x12, + 0xE2, 0xA8, 0x00, 0x00, 0x20, 0x00, 0x49, 0x44, 0x41, 0x54, 0x22, 0xC8, + 0x19, 0xA9, 0x0A, 0xBE, 0x6F, 0xFB, 0x3C, 0xCB, 0x28, 0xC5, 0x5D, 0xDF, + 0x13, 0x8C, 0x8F, 0x97, 0x73, 0x63, 0x8C, 0xB1, 0x4E, 0x1B, 0xDB, 0xD6, + 0xED, 0xA0, 0x34, 0x84, 0x90, 0x51, 0x1A, 0x7C, 0x48, 0x2B, 0x30, 0x1F, + 0x3C, 0x63, 0x24, 0x46, 0x68, 0xAD, 0x65, 0x9C, 0x0D, 0xC3, 0x40, 0x08, + 0x11, 0x8C, 0x3A, 0x1F, 0x7E, 0x54, 0x0B, 0x02, 0x00, 0x10, 0x02, 0xC6, + 0xF8, 0x34, 0x38, 0x87, 0x90, 0xF2, 0x53, 0x80, 0xF3, 0x91, 0x1C, 0xA0, + 0x4C, 0x34, 0x61, 0x6F, 0x53, 0x1D, 0x75, 0xDE, 0x41, 0x08, 0x31, 0x44, + 0x11, 0x22, 0x6B, 0xAD, 0x73, 0x16, 0x42, 0xF4, 0xF6, 0xF2, 0xB6, 0x69, + 0xE5, 0xF9, 0xE9, 0x62, 0x34, 0xCA, 0x0F, 0x57, 0x41, 0x84, 0x52, 0x27, + 0x94, 0xC6, 0xBA, 0xE0, 0x3D, 0x88, 0x09, 0x44, 0x7C, 0x38, 0xBC, 0x26, + 0x3B, 0x81, 0x31, 0x16, 0x40, 0x18, 0x7C, 0x48, 0x01, 0xDB, 0x49, 0x68, + 0xD9, 0xF5, 0x12, 0x22, 0xD4, 0x76, 0xC3, 0x30, 0x68, 0x00, 0x40, 0x12, + 0x63, 0x39, 0xE7, 0x28, 0x21, 0x10, 0x22, 0xE7, 0x0E, 0x20, 0xDF, 0x24, + 0xB2, 0x3B, 0xAC, 0x02, 0x39, 0x0D, 0x3E, 0x80, 0x08, 0xB4, 0xB3, 0x69, + 0x5F, 0x1E, 0x40, 0x4C, 0x86, 0x13, 0xCA, 0x08, 0x67, 0x8C, 0x52, 0x92, + 0xC6, 0xA6, 0x24, 0xFB, 0x80, 0x10, 0x6A, 0xA5, 0xD2, 0xB4, 0x0E, 0x23, + 0x24, 0x18, 0x8B, 0x8C, 0x3B, 0xE7, 0xBD, 0x75, 0x08, 0x42, 0x04, 0x51, + 0x70, 0x56, 0x79, 0x73, 0x79, 0x79, 0x83, 0x09, 0x62, 0x98, 0x00, 0x08, + 0x08, 0xC1, 0x52, 0x6B, 0x07, 0x21, 0x23, 0xB8, 0x2A, 0x4B, 0xE7, 0x5C, + 0x91, 0xE7, 0x52, 0xA9, 0x61, 0x50, 0x65, 0x99, 0x59, 0x6B, 0xA3, 0xB7, + 0x18, 0x93, 0x18, 0x23, 0xC1, 0x14, 0xC4, 0x98, 0xB0, 0x2E, 0x10, 0x41, + 0x67, 0x6C, 0xD7, 0x77, 0x5A, 0x1B, 0x00, 0x40, 0x96, 0x09, 0xEF, 0x7D, + 0x62, 0x9A, 0x12, 0x84, 0xF1, 0x30, 0x0C, 0x4A, 0x69, 0x9E, 0x3C, 0xCA, + 0x84, 0x78, 0xEF, 0xCB, 0x5C, 0x2C, 0xA7, 0xE5, 0xB8, 0x14, 0x17, 0x77, + 0xFB, 0xBE, 0xB7, 0x11, 0xA0, 0xA6, 0xEB, 0xCB, 0x8C, 0x57, 0xB9, 0xD0, + 0xCE, 0x07, 0x1F, 0xF2, 0x4C, 0x18, 0x1F, 0x2A, 0x46, 0x43, 0x84, 0x11, + 0x00, 0x82, 0xC0, 0xA4, 0xCA, 0xAC, 0x0B, 0x94, 0x52, 0x46, 0x70, 0xDA, + 0xC2, 0x3A, 0x1F, 0x72, 0xC1, 0x18, 0xA3, 0x20, 0x06, 0x4E, 0xB1, 0x33, + 0xC6, 0x06, 0xA0, 0x31, 0x26, 0x0C, 0x54, 0x68, 0xE8, 0xF6, 0xEB, 0xD7, + 0x17, 0x6F, 0xA5, 0xD6, 0x08, 0x21, 0xCA, 0x59, 0x31, 0xAE, 0xC6, 0x93, + 0xE5, 0xFF, 0xF9, 0x9F, 0xFE, 0xD3, 0xF7, 0x2F, 0xBE, 0xA9, 0x77, 0x2B, + 0xC1, 0xE9, 0xD1, 0x72, 0x8C, 0x30, 0x85, 0xC0, 0xE5, 0x39, 0xE8, 0x07, + 0xC5, 0x30, 0x3F, 0x3B, 0x3E, 0xA5, 0xA4, 0xFC, 0xEE, 0x87, 0x1F, 0xDA, + 0x5E, 0xFD, 0xEE, 0xAB, 0xE1, 0xEC, 0xB4, 0x52, 0xB2, 0xC6, 0x90, 0x8E, + 0x47, 0xF3, 0xAF, 0x5E, 0x5C, 0x5C, 0xBE, 0x7F, 0xF3, 0xF9, 0xE7, 0x3F, + 0xDB, 0x6C, 0xD7, 0xE3, 0xF1, 0xA4, 0xEB, 0x87, 0x7D, 0xBD, 0x93, 0x43, + 0x1F, 0x40, 0x5C, 0x1E, 0x3D, 0xD8, 0x6C, 0x36, 0x4F, 0x3E, 0xFA, 0xB9, + 0x09, 0x62, 0x7B, 0xFB, 0x3A, 0xEA, 0x7D, 0x26, 0x44, 0x08, 0xA8, 0xA4, + 0x33, 0xE0, 0x9D, 0xD2, 0x3A, 0x42, 0x58, 0xEF, 0xDB, 0xDD, 0xA6, 0x79, + 0x78, 0xFE, 0xA8, 0xCC, 0x46, 0xCA, 0x28, 0xA9, 0xFB, 0xA7, 0xA7, 0x8B, + 0x7A, 0xDF, 0x5C, 0xAD, 0xD7, 0x90, 0x71, 0x67, 0xBD, 0x73, 0x2E, 0x48, + 0x43, 0x31, 0x21, 0x02, 0xDF, 0xDC, 0xAE, 0xAB, 0x3C, 0x17, 0x45, 0x2E, + 0x07, 0x45, 0x21, 0xBE, 0xBB, 0xBE, 0x99, 0x94, 0x93, 0x5C, 0xF0, 0xA6, + 0x93, 0x72, 0x70, 0x52, 0xAE, 0xBD, 0x8F, 0xCA, 0xA8, 0x71, 0x91, 0x41, + 0x44, 0x9B, 0xBD, 0xB2, 0xDE, 0x3B, 0x1B, 0x21, 0x25, 0x46, 0xDA, 0x97, + 0xDF, 0xFF, 0x03, 0xF4, 0x5E, 0xC3, 0x30, 0x38, 0x0F, 0x20, 0xAA, 0x8A, + 0x51, 0x94, 0xD7, 0x75, 0xD3, 0xB2, 0x7C, 0x5A, 0xD2, 0xE3, 0xEB, 0xD7, + 0xDB, 0x10, 0x28, 0x81, 0xE0, 0x68, 0xF2, 0x8C, 0x4F, 0x0A, 0xA0, 0x9B, + 0xBB, 0x5D, 0x9F, 0x8B, 0xB1, 0x56, 0x7D, 0xDC, 0xBF, 0xA0, 0x24, 0x0C, + 0x7D, 0x3D, 0xA8, 0xDE, 0x7A, 0x8F, 0x30, 0xF6, 0x36, 0x2C, 0x96, 0x53, + 0x0A, 0xB0, 0xAA, 0xB1, 0xE7, 0x1C, 0x53, 0x71, 0x3A, 0x5A, 0xC0, 0x18, + 0x9D, 0x7C, 0x7F, 0x34, 0x11, 0x00, 0x58, 0x00, 0x02, 0x8A, 0x62, 0x2C, + 0x46, 0x2A, 0x60, 0xC7, 0x1E, 0x38, 0x27, 0xA9, 0xBE, 0xD6, 0xB2, 0x99, + 0x06, 0xE8, 0x6D, 0x40, 0xC1, 0x46, 0x4B, 0x03, 0x3B, 0x8B, 0x90, 0x33, + 0xC2, 0x43, 0x84, 0x21, 0x78, 0xE7, 0x5D, 0xC1, 0xB1, 0xF5, 0xD0, 0x03, + 0xDC, 0xAE, 0xDE, 0x7E, 0x3C, 0x43, 0xAF, 0x57, 0x77, 0x40, 0x8C, 0x38, + 0x0C, 0x8B, 0xC5, 0xFC, 0xB3, 0x9F, 0xFD, 0xD2, 0x20, 0xF1, 0xEA, 0xFB, + 0xAF, 0x69, 0x36, 0x1D, 0x8D, 0x67, 0x18, 0xE3, 0xE0, 0x41, 0x1B, 0xAB, + 0xE1, 0xE6, 0xAB, 0x67, 0x0F, 0x9F, 0x05, 0xA5, 0x20, 0xC6, 0x46, 0xEB, + 0xED, 0x60, 0x9B, 0xCE, 0x0F, 0xCE, 0x19, 0xE7, 0x95, 0x63, 0x4F, 0x8E, + 0xCF, 0x03, 0xAB, 0xCB, 0xC9, 0x6C, 0x12, 0x38, 0x6E, 0x56, 0x17, 0xBF, + 0xF9, 0xBF, 0x6E, 0x6E, 0x6E, 0x01, 0x04, 0x54, 0x70, 0xCE, 0x05, 0x80, + 0x70, 0xBB, 0xDD, 0x1A, 0xA3, 0x99, 0xC8, 0x91, 0xEE, 0xFD, 0xED, 0x5B, + 0x80, 0xF9, 0xF2, 0xE8, 0xC1, 0x50, 0xAF, 0x7E, 0xF8, 0xE6, 0x0F, 0x26, + 0xC4, 0x69, 0x21, 0xCA, 0xE5, 0xF9, 0xA6, 0xEE, 0x28, 0x25, 0xD3, 0xC9, + 0xC8, 0x18, 0x9B, 0x5A, 0xD7, 0x5C, 0x70, 0xE3, 0x5C, 0xD7, 0x0F, 0xDE, + 0x7B, 0x63, 0xCC, 0x41, 0x07, 0x00, 0x00, 0xE7, 0xFC, 0x7E, 0x38, 0x0A, + 0xDE, 0x7A, 0x6B, 0x3D, 0x26, 0xD4, 0x3B, 0x97, 0xEE, 0x89, 0x00, 0xC0, + 0xE4, 0xA5, 0x4B, 0x91, 0xDD, 0x79, 0xC6, 0x87, 0x41, 0x61, 0x4C, 0x38, + 0x67, 0x9D, 0x94, 0xD6, 0xBA, 0xBA, 0x6E, 0x8C, 0x32, 0x31, 0xC6, 0xA2, + 0xC8, 0xD3, 0xA1, 0x39, 0x9D, 0xD5, 0x30, 0xC6, 0x29, 0x3A, 0xEB, 0xBE, + 0xC5, 0x83, 0x08, 0x21, 0x29, 0xE5, 0x61, 0x12, 0x83, 0x08, 0x22, 0xE4, + 0x9D, 0x43, 0x10, 0x62, 0x8C, 0x13, 0x72, 0x3E, 0x91, 0xA3, 0x93, 0x11, + 0xC7, 0x07, 0x1F, 0xED, 0x7D, 0x85, 0x3D, 0x04, 0x48, 0x83, 0x10, 0x23, + 0x3A, 0xD0, 0xC1, 0x63, 0x8C, 0x11, 0xE3, 0x14, 0xA9, 0x19, 0x30, 0x42, + 0x75, 0xDB, 0xF5, 0xFD, 0xB0, 0x9C, 0x8D, 0xCF, 0xCE, 0x96, 0x69, 0xEF, + 0x46, 0x29, 0xD5, 0x3A, 0x24, 0xFF, 0x9B, 0x09, 0xDE, 0x7B, 0x6F, 0x9C, + 0xA3, 0x04, 0x6B, 0x6D, 0x19, 0xA3, 0x8C, 0x52, 0xEF, 0x5C, 0x22, 0xD0, + 0x31, 0xC6, 0x21, 0x00, 0xC9, 0x92, 0xA9, 0x8D, 0xD1, 0xC6, 0x55, 0x65, + 0x11, 0xEF, 0xEF, 0xF4, 0xA9, 0xD0, 0x53, 0x42, 0x08, 0x42, 0x21, 0x51, + 0x64, 0xC0, 0x3D, 0xF2, 0x37, 0xC6, 0x18, 0xA3, 0x60, 0x2C, 0xF8, 0x90, + 0x32, 0x44, 0x12, 0x34, 0x31, 0xC6, 0x58, 0x95, 0x45, 0x9E, 0x89, 0x43, + 0x32, 0x61, 0x08, 0x10, 0x41, 0x0C, 0x0F, 0xDD, 0x50, 0x08, 0xCE, 0x19, + 0x1D, 0x5D, 0xF0, 0x29, 0xBD, 0x0C, 0x23, 0xC6, 0x29, 0xBA, 0xCF, 0x3C, + 0x84, 0x00, 0x4A, 0xA5, 0x95, 0xD2, 0x00, 0x41, 0x29, 0x87, 0x51, 0x55, + 0xE6, 0xB9, 0x20, 0x94, 0x38, 0xE7, 0x27, 0xE3, 0x4A, 0x6B, 0xE3, 0x9D, + 0x2F, 0x72, 0x61, 0x9D, 0xEB, 0x87, 0x21, 0xC4, 0x58, 0x96, 0x59, 0x26, + 0xF8, 0xA8, 0xCC, 0xB5, 0xD6, 0x11, 0xA6, 0xD5, 0x2E, 0x90, 0x5A, 0x03, + 0x10, 0x95, 0xD4, 0xD6, 0x58, 0x42, 0x30, 0x65, 0x0C, 0x82, 0x03, 0xCC, + 0x4A, 0x2B, 0x63, 0x8D, 0x4B, 0x39, 0x0E, 0x03, 0x00, 0x20, 0x05, 0xB1, + 0x78, 0x1F, 0x20, 0x88, 0x94, 0x60, 0xC1, 0x18, 0xC5, 0xF0, 0x6E, 0xDB, + 0x3A, 0x6B, 0x96, 0x23, 0xAA, 0x8C, 0x11, 0x04, 0x2F, 0xC6, 0x8C, 0x31, + 0x14, 0x01, 0xD5, 0x9E, 0x04, 0x80, 0x90, 0xD2, 0x08, 0x45, 0x17, 0x61, + 0x37, 0xA8, 0x52, 0x70, 0x82, 0x31, 0x21, 0xA1, 0x10, 0xD4, 0x5A, 0xE7, + 0x02, 0xB4, 0xD6, 0x0A, 0xCE, 0x30, 0x08, 0x5E, 0xB5, 0xD1, 0xC9, 0xBA, + 0xF3, 0x5E, 0xD5, 0xD6, 0xE8, 0x38, 0x5D, 0x00, 0xD8, 0xE8, 0x6E, 0xF5, + 0xED, 0x8B, 0xF7, 0x83, 0x0B, 0x1F, 0x7F, 0xF4, 0x91, 0xC8, 0xAA, 0x37, + 0x17, 0xD7, 0x5F, 0x7E, 0xFD, 0x9D, 0xC8, 0xAB, 0xED, 0xAE, 0x7E, 0xFC, + 0xF0, 0xBC, 0x1E, 0x71, 0x4A, 0x62, 0x5E, 0xCD, 0xEE, 0x56, 0xEB, 0xA7, + 0x8F, 0x9F, 0x21, 0x02, 0xD5, 0xF5, 0x9B, 0x4C, 0x54, 0x9B, 0x6D, 0x77, + 0x67, 0x6A, 0x35, 0xF4, 0x4A, 0xAA, 0x7A, 0xAF, 0xF6, 0xBB, 0xAD, 0xD2, + 0xDD, 0xD1, 0xFC, 0xF8, 0xF2, 0xF2, 0xE5, 0xED, 0xFA, 0xAE, 0xC8, 0xF3, + 0xD7, 0xEF, 0xDE, 0xBD, 0x7C, 0xFD, 0x6A, 0xB1, 0x38, 0x16, 0x22, 0x13, + 0x3C, 0x43, 0x10, 0x1B, 0x25, 0xB5, 0x1C, 0x8E, 0x1E, 0x7C, 0xF4, 0xEB, + 0xBF, 0xFD, 0x2F, 0x39, 0xF7, 0xB2, 0xBE, 0x78, 0xFC, 0xD1, 0x7F, 0xD5, + 0xB5, 0x35, 0xB1, 0xDD, 0x72, 0x7E, 0xD6, 0x6C, 0xB7, 0x8D, 0xF5, 0xE5, + 0x78, 0x72, 0x34, 0x3D, 0x1A, 0x8C, 0x9B, 0x8F, 0x67, 0x94, 0xA1, 0xCD, + 0xEE, 0xA6, 0x2C, 0xA7, 0xD3, 0xD1, 0xF4, 0xEE, 0xF6, 0x36, 0x42, 0x6C, + 0x94, 0x8C, 0x11, 0x6D, 0xB7, 0x1D, 0x9A, 0xC0, 0xB3, 0x93, 0x0A, 0xE3, + 0xF8, 0xE4, 0xF4, 0x94, 0x53, 0x72, 0xBB, 0xA9, 0x27, 0x65, 0x31, 0xAE, + 0xC6, 0x55, 0x9E, 0xAF, 0x76, 0x35, 0x0D, 0x01, 0x78, 0xFA, 0xFC, 0xD9, + 0xD3, 0xCB, 0xDB, 0xB7, 0x82, 0x61, 0x6F, 0x0D, 0x70, 0xC1, 0x3B, 0x5C, + 0x1B, 0x95, 0xE7, 0x62, 0x54, 0x8C, 0x42, 0x74, 0x5A, 0x75, 0x08, 0xC6, + 0xDD, 0x7E, 0x7F, 0x3C, 0x9F, 0x69, 0xEF, 0x00, 0x00, 0x46, 0x9A, 0xAE, + 0x7E, 0x27, 0x10, 0xBA, 0x59, 0x5F, 0xFE, 0xF6, 0x37, 0xFF, 0x79, 0x3E, + 0x1E, 0x3D, 0x3B, 0x7F, 0xB8, 0x3C, 0x7E, 0xF0, 0x6C, 0x3E, 0xBC, 0xBD, + 0x78, 0x05, 0x3D, 0x9C, 0x23, 0x50, 0x64, 0x9A, 0x16, 0xE0, 0x1F, 0xAF, + 0x87, 0x5F, 0xFD, 0xE3, 0x0B, 0x8C, 0x60, 0x55, 0xE6, 0x1E, 0x38, 0xCA, + 0x99, 0xB5, 0x7E, 0x90, 0x9B, 0x4C, 0x88, 0xBE, 0x1F, 0x8C, 0x36, 0x20, + 0xC6, 0x93, 0xC5, 0xF4, 0x64, 0x59, 0x8C, 0x28, 0x30, 0x5A, 0xAF, 0xB6, + 0xDB, 0x10, 0x91, 0xE0, 0xF4, 0xF6, 0xEA, 0xED, 0xD1, 0x72, 0x32, 0x9D, + 0xAD, 0x2F, 0xAE, 0x6E, 0x2F, 0xAF, 0x6E, 0xBB, 0xCE, 0x40, 0x08, 0x19, + 0xA7, 0x11, 0x12, 0x88, 0xA1, 0x10, 0x6F, 0x62, 0x40, 0xD5, 0x78, 0x59, + 0x94, 0x8F, 0xBB, 0x38, 0x82, 0x00, 0xBB, 0x00, 0x23, 0x88, 0x84, 0x65, + 0x1F, 0x7F, 0xF8, 0xEC, 0xFF, 0xF9, 0xD5, 0xDF, 0x70, 0x9E, 0x4D, 0x67, + 0xF3, 0xA7, 0xCF, 0x1E, 0x2D, 0x4E, 0x9E, 0xB4, 0x83, 0x7B, 0xF5, 0x0F, + 0xFF, 0x47, 0x14, 0x53, 0xC0, 0x33, 0x4B, 0xBF, 0x50, 0x56, 0x06, 0xA3, + 0xAB, 0x2C, 0xBE, 0x7C, 0xF1, 0xBD, 0x58, 0x9E, 0x2F, 0x4F, 0x9F, 0x06, + 0x52, 0xEC, 0xB7, 0x9B, 0x89, 0xD4, 0x52, 0x69, 0x00, 0x01, 0x44, 0x70, + 0xDF, 0x6A, 0x57, 0x66, 0x93, 0x71, 0x04, 0xDE, 0x01, 0x67, 0x76, 0x9B, + 0xD5, 0x0F, 0x17, 0x97, 0xD7, 0xB7, 0x6B, 0xCE, 0x18, 0x21, 0x78, 0x32, + 0x9F, 0x23, 0x84, 0x95, 0x8B, 0xFB, 0x4E, 0xE5, 0x1E, 0x8A, 0x2C, 0x83, + 0x88, 0xA8, 0xAE, 0xBE, 0x5D, 0xDF, 0x84, 0x00, 0x10, 0xE5, 0x05, 0x00, + 0xCF, 0x3F, 0xFE, 0x9C, 0xCD, 0x1E, 0xBC, 0xBB, 0xDC, 0x80, 0x18, 0xBC, + 0x3F, 0xE8, 0x78, 0x63, 0x04, 0x08, 0x01, 0x8A, 0x31, 0x21, 0x44, 0x29, + 0x35, 0x2A, 0x4B, 0xEF, 0x1D, 0x80, 0x28, 0x61, 0x48, 0x13, 0x71, 0x2C, + 0xDD, 0xC2, 0x62, 0x8C, 0x29, 0xBA, 0x25, 0x41, 0x50, 0x7E, 0x1C, 0xD3, + 0xDA, 0x4E, 0x07, 0xE7, 0x76, 0xFB, 0x1A, 0x00, 0x04, 0x62, 0xA8, 0xB5, + 0xDE, 0x6C, 0x7D, 0x42, 0x5F, 0x90, 0x74, 0x79, 0x87, 0x10, 0x42, 0x98, + 0x65, 0xE2, 0x90, 0xCA, 0x0C, 0x91, 0xF3, 0x1E, 0xC4, 0x48, 0x31, 0x46, + 0x79, 0x96, 0xB2, 0xE2, 0x39, 0x67, 0x5A, 0x5B, 0x08, 0x41, 0x88, 0x20, + 0x1D, 0x4F, 0xAD, 0xF7, 0x08, 0x42, 0x8C, 0x51, 0x08, 0x91, 0x10, 0x04, + 0x40, 0x44, 0x08, 0x3B, 0xE7, 0x04, 0x67, 0xC9, 0x85, 0x9E, 0x67, 0x5C, + 0x5B, 0x97, 0x89, 0x62, 0x18, 0xB4, 0xF3, 0x49, 0x85, 0x9B, 0x08, 0x25, + 0x21, 0x1D, 0x76, 0x28, 0x4E, 0x00, 0x82, 0xE0, 0x41, 0xBC, 0xB9, 0xDB, + 0xF6, 0x83, 0x5A, 0xCC, 0x27, 0xB3, 0xD9, 0xE8, 0x9E, 0x4E, 0x0E, 0x09, + 0xC1, 0x31, 0x52, 0x63, 0x6C, 0x0C, 0x01, 0x00, 0x9C, 0x20, 0xE9, 0x49, + 0xCA, 0x90, 0xE7, 0xF9, 0xE1, 0x66, 0x12, 0x42, 0xEA, 0xC8, 0xBA, 0x6E, + 0xA0, 0x84, 0x68, 0xAD, 0x62, 0xF0, 0x99, 0x60, 0x9D, 0xD4, 0x10, 0x21, + 0x04, 0x81, 0xA0, 0x54, 0x6B, 0x03, 0x61, 0x12, 0xDF, 0x05, 0x7F, 0x6F, + 0x6B, 0xA3, 0x84, 0x22, 0x00, 0xAC, 0x75, 0x21, 0x02, 0x00, 0x81, 0xF3, + 0x1E, 0x61, 0x5C, 0xE4, 0x59, 0xDA, 0xBB, 0x23, 0x84, 0xA4, 0x32, 0xCE, + 0xBB, 0x34, 0xE4, 0x16, 0x45, 0xD1, 0xF7, 0x83, 0xEC, 0x65, 0x4A, 0xF2, + 0x44, 0xE0, 0x7E, 0x3C, 0x44, 0x30, 0x35, 0x7D, 0xA9, 0x69, 0x53, 0x83, + 0x45, 0x08, 0xE7, 0x82, 0x31, 0x4E, 0xF3, 0x4C, 0x20, 0x84, 0x7D, 0x08, + 0x04, 0x41, 0x04, 0xA2, 0xE0, 0x94, 0x16, 0x59, 0x08, 0x81, 0x60, 0x9C, + 0x67, 0x8C, 0x31, 0x96, 0x36, 0x71, 0x75, 0xD3, 0x10, 0x42, 0x84, 0x38, + 0xB0, 0x98, 0x62, 0xF0, 0x10, 0x21, 0x21, 0xB8, 0xD1, 0xDA, 0xDA, 0x68, + 0x8C, 0x85, 0x30, 0x96, 0x65, 0x6E, 0xAC, 0xE7, 0x82, 0x95, 0x79, 0xA6, + 0x95, 0xC6, 0x9F, 0xFE, 0xFC, 0x5F, 0xA7, 0x2F, 0x36, 0x21, 0x98, 0x51, + 0x12, 0x62, 0xA4, 0x18, 0x70, 0x0C, 0x32, 0x86, 0x9D, 0x19, 0xE6, 0xA2, + 0x39, 0x9D, 0x6A, 0x0A, 0xF7, 0x47, 0xE3, 0x60, 0xE4, 0x76, 0x75, 0x73, + 0xA9, 0xFA, 0x8D, 0xEC, 0xEE, 0xA0, 0x6B, 0xC6, 0xD5, 0xC4, 0xD8, 0x80, + 0x09, 0x86, 0x10, 0x31, 0x8A, 0x49, 0x22, 0x94, 0x3A, 0xDB, 0x2B, 0x13, + 0x23, 0xA0, 0x18, 0xC8, 0x7A, 0xAD, 0xD7, 0x5F, 0x09, 0x77, 0xD5, 0xAC, + 0x5F, 0x62, 0x7B, 0x53, 0x71, 0x95, 0x61, 0xC5, 0x90, 0xDA, 0xEE, 0x6E, + 0xDB, 0xAE, 0xE1, 0x59, 0xFE, 0xD9, 0xA7, 0x9F, 0x8D, 0xAA, 0x49, 0x51, + 0x81, 0xD9, 0xD8, 0x06, 0xEF, 0x8C, 0xEC, 0x9E, 0x3F, 0x3A, 0x3A, 0x3B, + 0x1E, 0x03, 0x04, 0x1F, 0x3D, 0xFA, 0xF0, 0xA3, 0xE7, 0x9F, 0x7E, 0xF2, + 0xEC, 0xF1, 0x7A, 0x73, 0xF3, 0xEA, 0x87, 0x57, 0x08, 0x81, 0xEB, 0x9B, + 0x6B, 0x8C, 0x39, 0x20, 0xDC, 0x18, 0x6D, 0x9D, 0x1B, 0xCF, 0x16, 0xDE, + 0x7B, 0x1C, 0xD1, 0x20, 0x35, 0x46, 0x68, 0x54, 0x8D, 0x97, 0xCB, 0x93, + 0xBC, 0x1A, 0x53, 0x26, 0x56, 0x77, 0xD7, 0x9C, 0xF3, 0x5D, 0xBD, 0x6D, + 0x9B, 0xFA, 0x8B, 0x9F, 0xFE, 0xE2, 0xE9, 0xC7, 0x9F, 0xBF, 0x7F, 0xFD, + 0xFD, 0xE5, 0xBB, 0x57, 0x5C, 0x94, 0x0F, 0x1F, 0x3D, 0x59, 0x1C, 0x2D, + 0x96, 0x63, 0xF2, 0xC1, 0xE3, 0x79, 0x55, 0x89, 0x47, 0x0F, 0x8F, 0x26, + 0xF3, 0xA3, 0xF9, 0xF2, 0x8C, 0x52, 0x5C, 0x94, 0x65, 0xC6, 0x98, 0xF7, + 0xDA, 0xB9, 0x6E, 0x3E, 0x99, 0xEE, 0xF7, 0xE9, 0x00, 0x12, 0x18, 0x86, + 0x65, 0x91, 0x01, 0x84, 0x05, 0x81, 0x1C, 0xA3, 0x3C, 0xCF, 0x8A, 0xB2, + 0x94, 0xCA, 0x4C, 0x46, 0x23, 0x82, 0xF0, 0x6C, 0x34, 0xED, 0x54, 0x33, + 0x9E, 0x64, 0x4A, 0x76, 0x45, 0x96, 0xC9, 0x7E, 0x8B, 0xA0, 0xCF, 0x99, + 0xE0, 0x10, 0x0F, 0x52, 0x8F, 0xC7, 0x93, 0x18, 0x9D, 0x8F, 0xF6, 0xE2, + 0x6E, 0x95, 0x14, 0x00, 0xAB, 0xF5, 0xAE, 0x95, 0xBD, 0x31, 0xE1, 0xED, + 0xD5, 0x06, 0x45, 0xC0, 0x29, 0xFD, 0xE8, 0xE9, 0x43, 0xAD, 0xF4, 0x76, + 0x57, 0x7F, 0xF0, 0xE8, 0xC1, 0xE3, 0x07, 0x0F, 0x3A, 0xA9, 0xBC, 0xB5, + 0x97, 0xD7, 0x97, 0xDF, 0xBF, 0x7E, 0x35, 0xCA, 0xB3, 0xD3, 0xA3, 0x99, + 0xF7, 0xF6, 0xEA, 0x76, 0xFF, 0xEA, 0xFD, 0x9D, 0x94, 0xFD, 0x6C, 0x5A, + 0x41, 0x18, 0xE7, 0xF3, 0x31, 0x22, 0xD8, 0xFA, 0x68, 0xB4, 0xB5, 0xCE, + 0x55, 0xA3, 0xD2, 0xF9, 0x64, 0x67, 0x33, 0x57, 0x77, 0x3B, 0xA9, 0x0D, + 0x80, 0x91, 0x51, 0x4A, 0x30, 0x99, 0x4D, 0xC7, 0x57, 0xAB, 0xC6, 0x1B, + 0x3F, 0xF4, 0xDD, 0xDB, 0x8B, 0x3B, 0xCA, 0x04, 0xA5, 0x94, 0x71, 0xCE, + 0x85, 0xA0, 0x94, 0x30, 0x42, 0x41, 0xC4, 0xD6, 0xF8, 0xB6, 0xD9, 0x75, + 0xFB, 0xAB, 0x71, 0x8E, 0x3E, 0x7D, 0x3C, 0xFD, 0xF8, 0xBC, 0xD8, 0xB4, + 0x6E, 0xCC, 0x09, 0xE8, 0x6E, 0x42, 0x8C, 0x55, 0x99, 0x3F, 0xF9, 0xE0, + 0xF1, 0x67, 0x9F, 0x7D, 0x42, 0x31, 0x58, 0x5D, 0xBE, 0x08, 0xAA, 0x1E, + 0x65, 0x21, 0x9A, 0x86, 0x87, 0x56, 0x6B, 0x97, 0x53, 0x80, 0x29, 0xF2, + 0xC8, 0x4D, 0xA6, 0x74, 0xB6, 0x98, 0x19, 0xD3, 0x4E, 0xE6, 0x53, 0xC7, + 0x8E, 0xDB, 0x5E, 0xFB, 0xE0, 0x31, 0x04, 0x00, 0xA0, 0x32, 0xE3, 0x25, + 0x0B, 0x6D, 0xD7, 0xF7, 0x5D, 0x77, 0xFD, 0xF2, 0x9B, 0xCD, 0x66, 0xB3, + 0xAD, 0x77, 0x31, 0x06, 0x10, 0xE3, 0xD1, 0xF1, 0xE9, 0x83, 0xCF, 0x7E, + 0xA6, 0xE4, 0x60, 0x87, 0xA1, 0x1D, 0xBA, 0x7E, 0xE8, 0x39, 0x63, 0x65, + 0x91, 0xF7, 0xBD, 0xCA, 0xF3, 0x6C, 0x3A, 0x1A, 0x9D, 0x3C, 0x78, 0xFC, + 0xC5, 0x5F, 0xFC, 0xBB, 0x5F, 0x7F, 0x77, 0xB3, 0xAD, 0x7B, 0x67, 0x5D, + 0x9A, 0x2F, 0x22, 0x80, 0x11, 0xC0, 0x84, 0xB4, 0xF7, 0xCE, 0xE5, 0x99, + 0x10, 0x42, 0x40, 0xAF, 0x04, 0xF1, 0x08, 0x61, 0x1F, 0x61, 0xD2, 0x22, + 0x39, 0x1F, 0xA5, 0xD6, 0x20, 0x05, 0x09, 0xC7, 0xC3, 0x49, 0x34, 0xC6, + 0x90, 0xE7, 0xC2, 0x59, 0x97, 0xFC, 0xE1, 0x8C, 0x73, 0x74, 0x0F, 0x9E, + 0x4D, 0x61, 0x29, 0xD6, 0x3A, 0x0C, 0xF1, 0x8F, 0x45, 0x30, 0xFD, 0x6A, + 0x8A, 0x24, 0x27, 0x08, 0xC7, 0x10, 0xAD, 0x77, 0x99, 0x10, 0xC6, 0xDA, + 0x94, 0xE2, 0x9E, 0x38, 0x71, 0xA9, 0xF9, 0x4A, 0x9A, 0xE7, 0xB4, 0x9A, + 0x06, 0xC9, 0x4C, 0x8E, 0x51, 0xD2, 0x6D, 0x69, 0x63, 0x10, 0xC2, 0xA5, + 0x20, 0x0F, 0xE7, 0x45, 0xF4, 0x8E, 0x31, 0x11, 0x21, 0x0A, 0xF7, 0xB5, + 0x35, 0xFE, 0x53, 0x7B, 0x6C, 0x8C, 0x09, 0xB9, 0x0B, 0x22, 0xC0, 0x18, + 0x4B, 0xAD, 0x37, 0x75, 0xD3, 0xF7, 0x92, 0xA5, 0xC0, 0x0A, 0x00, 0x92, + 0x05, 0x0D, 0x02, 0xE4, 0x83, 0x4F, 0xE4, 0x02, 0x08, 0x0E, 0x7E, 0x26, + 0xCE, 0x58, 0x84, 0x30, 0x39, 0xF0, 0x21, 0x04, 0xD6, 0xDA, 0x6D, 0xDD, + 0x50, 0x4A, 0x9D, 0xB7, 0x89, 0x31, 0x6D, 0x5D, 0x08, 0x21, 0x30, 0x42, + 0xDC, 0x41, 0x26, 0x82, 0x62, 0x04, 0xF1, 0x5E, 0x75, 0x90, 0xD2, 0xC3, + 0x43, 0x08, 0x11, 0xC0, 0x90, 0xAE, 0x3D, 0x8C, 0x8D, 0x47, 0x55, 0x26, + 0x38, 0x00, 0x80, 0x61, 0x12, 0x63, 0x74, 0xDE, 0x4B, 0x29, 0x11, 0x44, + 0x9C, 0xB1, 0xAE, 0x1F, 0x94, 0xD2, 0xE9, 0x12, 0x45, 0x09, 0x1E, 0x8D, + 0x4B, 0x8C, 0x61, 0xB2, 0x00, 0x01, 0x10, 0x09, 0x82, 0x18, 0xA2, 0xE0, + 0x23, 0x00, 0x80, 0x71, 0x92, 0x67, 0x8C, 0x12, 0x82, 0x09, 0x89, 0x31, + 0xC0, 0x08, 0x9C, 0x77, 0x84, 0x90, 0x3C, 0xCB, 0xA4, 0x52, 0x49, 0x95, + 0x9D, 0x64, 0xB7, 0xCE, 0x39, 0xAD, 0x75, 0x8C, 0x21, 0xC1, 0x26, 0xDA, + 0xB6, 0xF7, 0xCE, 0x31, 0x46, 0x9D, 0x75, 0x04, 0x23, 0xC6, 0x68, 0x8C, + 0x87, 0x3B, 0x6F, 0x42, 0x8D, 0x62, 0x08, 0x85, 0xC8, 0x20, 0x46, 0xF8, + 0xF3, 0x5F, 0xFC, 0x39, 0x48, 0xFC, 0x2C, 0x4A, 0x40, 0xF4, 0x63, 0x1E, + 0x60, 0xF0, 0x1C, 0x03, 0xEF, 0x41, 0x94, 0x57, 0x37, 0xEF, 0xBE, 0xFF, + 0x87, 0x2F, 0x5F, 0xAD, 0xD7, 0xFB, 0xD5, 0xB6, 0xFF, 0xE1, 0xED, 0x6A, + 0x5F, 0x4B, 0xCE, 0xD9, 0xED, 0xED, 0xF5, 0xED, 0xF5, 0xE5, 0xB4, 0x82, + 0xD3, 0x8A, 0x7B, 0x0F, 0x67, 0x25, 0x1B, 0x94, 0x8B, 0x11, 0xE6, 0xA0, + 0xE7, 0xC8, 0xC7, 0x10, 0x73, 0x1A, 0xA2, 0xDC, 0xBB, 0xFA, 0xF5, 0x72, + 0x84, 0x79, 0x56, 0x8C, 0x47, 0x65, 0x84, 0x44, 0x64, 0xC5, 0x72, 0x36, + 0x82, 0x18, 0x0C, 0xBA, 0x7F, 0x7C, 0xBA, 0x78, 0xF6, 0xF8, 0x7C, 0x5C, + 0xF2, 0x42, 0x0C, 0x37, 0x37, 0xDF, 0xDD, 0xAC, 0x56, 0x9F, 0x7C, 0xF8, + 0xE0, 0xCF, 0xFF, 0xC5, 0x2F, 0x30, 0xF4, 0xDF, 0xFF, 0xF0, 0xBD, 0x37, + 0xE1, 0xDF, 0xFF, 0x9B, 0x7F, 0x5B, 0x15, 0xA2, 0x9A, 0x9D, 0x7D, 0xF2, + 0x93, 0x3F, 0xFE, 0xE1, 0xFB, 0x6F, 0x7E, 0xF8, 0xE1, 0x9D, 0x73, 0xF1, + 0xD1, 0xC3, 0xC5, 0x74, 0x36, 0xA9, 0xDB, 0x96, 0x50, 0xF6, 0xEC, 0xA3, + 0xCF, 0x3E, 0x7A, 0xF6, 0xC1, 0x17, 0xCF, 0x1F, 0x23, 0xCA, 0x03, 0xA4, + 0x85, 0x60, 0x14, 0x86, 0x7A, 0xB7, 0xFA, 0xF4, 0xF3, 0x9F, 0xCF, 0x8F, + 0xCE, 0xE4, 0xD0, 0x41, 0x84, 0x97, 0xCB, 0x93, 0x4F, 0x3E, 0xFB, 0x29, + 0xA5, 0xF8, 0x76, 0xB5, 0x9D, 0xCC, 0x16, 0xF3, 0x51, 0x7E, 0x7C, 0xF6, + 0x10, 0x42, 0xE9, 0x20, 0xAF, 0xEB, 0x6D, 0x27, 0x3B, 0x0F, 0x62, 0x5E, + 0x09, 0xEF, 0x74, 0x39, 0x12, 0x22, 0x03, 0x21, 0x28, 0x69, 0xCC, 0x6C, + 0x3A, 0xEE, 0x3A, 0x3B, 0xCA, 0xF3, 0xD3, 0xA3, 0x0A, 0xC1, 0x38, 0xAA, + 0x38, 0xC2, 0xE0, 0xFC, 0x7C, 0xF9, 0xFC, 0xE9, 0xF9, 0xA3, 0x07, 0x67, + 0x05, 0x13, 0x31, 0x06, 0x08, 0xF1, 0xC9, 0x7C, 0x0C, 0xA3, 0x69, 0xD5, + 0xD0, 0xEB, 0x61, 0xBD, 0xDB, 0x32, 0x80, 0xDE, 0xBD, 0xBB, 0xEC, 0xB5, + 0x3E, 0x5B, 0x1E, 0x45, 0xEF, 0x33, 0x91, 0x3B, 0x6B, 0xEB, 0x7D, 0x37, + 0x19, 0x57, 0x94, 0x51, 0x46, 0xF1, 0x2F, 0x3E, 0xFF, 0xC4, 0x2A, 0xF7, + 0x0F, 0xBF, 0xFF, 0x1E, 0x53, 0xDC, 0xF5, 0x32, 0x42, 0x30, 0x58, 0xC3, + 0x39, 0x16, 0x4C, 0xAC, 0xB7, 0x35, 0x25, 0xF8, 0xD1, 0xD9, 0x59, 0xF0, + 0x7E, 0x36, 0x9A, 0x22, 0x00, 0xB5, 0xB5, 0xE3, 0x6A, 0xC2, 0x28, 0xBD, + 0x5B, 0xD7, 0xDF, 0xBF, 0xBE, 0xFD, 0xEA, 0xD5, 0x6D, 0x0C, 0x6A, 0x31, + 0x15, 0xD6, 0xC7, 0x10, 0x41, 0xD3, 0x34, 0x83, 0xEC, 0x87, 0x5E, 0x23, + 0x84, 0x57, 0x77, 0xDB, 0xCD, 0xAE, 0x01, 0x20, 0x42, 0x14, 0xEB, 0x7D, + 0x9D, 0x16, 0x40, 0x5D, 0xDB, 0x31, 0xC1, 0x32, 0x46, 0x61, 0x84, 0xCB, + 0xD9, 0x78, 0x54, 0x16, 0x5A, 0x59, 0x88, 0xE0, 0x64, 0x32, 0xAA, 0x8A, + 0x22, 0x02, 0x80, 0x31, 0xE6, 0x99, 0x88, 0x10, 0x65, 0x99, 0xE0, 0x94, + 0xCE, 0x67, 0x13, 0x69, 0xF4, 0xE5, 0xE5, 0xAB, 0xB3, 0x09, 0xC2, 0xA0, + 0xD3, 0xFD, 0x96, 0x45, 0xED, 0xD4, 0x96, 0x32, 0x38, 0x9F, 0x8F, 0xCE, + 0x1F, 0x1E, 0x03, 0xBB, 0x1F, 0xA1, 0x9A, 0x13, 0xFD, 0xF8, 0xD1, 0xF1, + 0xF3, 0xC7, 0x47, 0xA7, 0xC7, 0x27, 0xC0, 0x4B, 0xC2, 0xAA, 0x9C, 0xC3, + 0x9B, 0xF7, 0xDF, 0x3F, 0x7F, 0x7E, 0x7A, 0x7D, 0x7B, 0xBD, 0x5F, 0x5D, + 0x2E, 0xE6, 0xE3, 0x3C, 0x17, 0x8B, 0x22, 0x32, 0x8A, 0x04, 0xA5, 0x0C, + 0x43, 0x69, 0x83, 0x32, 0x7E, 0xCA, 0x2D, 0x26, 0xF8, 0xC5, 0x8B, 0x57, + 0xD6, 0x1A, 0x0C, 0xC2, 0x6C, 0x32, 0x4E, 0xC8, 0x9B, 0xFD, 0x66, 0x7D, + 0xFE, 0xC9, 0xCF, 0x1F, 0x7F, 0xF4, 0x09, 0x41, 0x91, 0x80, 0x00, 0x01, + 0x28, 0xCB, 0x1C, 0x21, 0x98, 0x65, 0x94, 0x10, 0x58, 0x56, 0xF9, 0x9F, + 0xFD, 0x37, 0xFF, 0x76, 0xD5, 0xEE, 0x9A, 0x4E, 0x9E, 0x4C, 0x42, 0x8E, + 0xEA, 0x08, 0x08, 0x61, 0x45, 0x21, 0xD0, 0xA4, 0x40, 0xD1, 0x5B, 0xDD, + 0xBC, 0x29, 0x38, 0x01, 0x31, 0x00, 0xD3, 0xF6, 0xF5, 0x55, 0x34, 0x3B, + 0x44, 0xCA, 0x80, 0x18, 0xC1, 0xE8, 0xE0, 0xC6, 0xF5, 0xC1, 0xFB, 0x18, + 0xBC, 0x47, 0x20, 0xC6, 0xA0, 0x61, 0x70, 0x98, 0x90, 0x18, 0x23, 0x46, + 0xC8, 0x7B, 0x9F, 0xE7, 0xF9, 0xBD, 0x1E, 0x38, 0xA6, 0xB4, 0xB1, 0x04, + 0x5F, 0x4B, 0x9C, 0x28, 0x8C, 0x0E, 0x26, 0xEC, 0x14, 0xCB, 0x94, 0x00, + 0xD0, 0x8C, 0x62, 0x6B, 0xBD, 0xB1, 0x4E, 0x0E, 0x92, 0x33, 0x96, 0xDC, + 0xD4, 0xCE, 0xB9, 0x10, 0x3C, 0x82, 0x30, 0x86, 0x98, 0xF0, 0xFF, 0x00, + 0x46, 0x4A, 0x69, 0x08, 0x00, 0x63, 0xA2, 0xB4, 0x41, 0x10, 0x2D, 0x66, + 0xA3, 0x41, 0x9A, 0xA3, 0xB1, 0x58, 0x66, 0xF6, 0x66, 0x75, 0xD7, 0x77, + 0x1D, 0x62, 0x39, 0x80, 0x28, 0xFA, 0x03, 0x42, 0x19, 0xDC, 0x6B, 0x1A, + 0x0E, 0x13, 0xF2, 0xE1, 0x7F, 0x31, 0xA1, 0xE1, 0xA4, 0xD2, 0xEB, 0x4D, + 0x1D, 0x42, 0x28, 0xCB, 0x9C, 0x60, 0xE4, 0x9C, 0x77, 0xDE, 0x1D, 0x12, + 0xB9, 0x7C, 0x60, 0x34, 0xA1, 0x46, 0x63, 0xF2, 0xEA, 0x6A, 0xEB, 0x52, + 0x3D, 0xEA, 0x07, 0xA9, 0x8D, 0x21, 0x98, 0x68, 0xAD, 0x10, 0x44, 0xC6, + 0x46, 0x6D, 0x34, 0x86, 0x08, 0xA7, 0xC0, 0x07, 0x08, 0x41, 0x04, 0x89, + 0xE7, 0x99, 0xF4, 0xBD, 0x04, 0x23, 0xE7, 0x43, 0x48, 0xD2, 0xB9, 0x18, + 0xB3, 0x4C, 0x54, 0x45, 0x86, 0x0F, 0x4B, 0x37, 0x9C, 0x5C, 0x77, 0xE9, + 0x64, 0x01, 0x41, 0x0C, 0xDE, 0x5B, 0x6B, 0x10, 0xC6, 0x31, 0x02, 0x04, + 0x01, 0xE7, 0x34, 0x29, 0x1C, 0x21, 0x80, 0x21, 0x78, 0x10, 0x42, 0x08, + 0x51, 0x2B, 0x6B, 0x9D, 0xC3, 0x04, 0xE7, 0x59, 0x0A, 0x5D, 0x45, 0x3F, + 0x6E, 0x00, 0x92, 0x48, 0xC8, 0x18, 0xA3, 0xB5, 0x4E, 0x3F, 0x99, 0xE2, + 0x48, 0x52, 0x53, 0x85, 0x31, 0xEE, 0x7B, 0x39, 0x0C, 0xCA, 0x1A, 0xC7, + 0x39, 0x15, 0x82, 0x13, 0x4C, 0x86, 0x41, 0xA6, 0x1D, 0x02, 0xC6, 0x48, + 0x19, 0x2B, 0xB5, 0x65, 0x94, 0xA4, 0x40, 0x35, 0xCE, 0x05, 0xFE, 0xE9, + 0x1F, 0xFD, 0x85, 0x0F, 0x41, 0x2A, 0xA9, 0xB5, 0x3C, 0x1E, 0xF3, 0xE8, + 0x4C, 0x70, 0xC3, 0xD9, 0x04, 0x05, 0xD7, 0xA2, 0x20, 0x37, 0xF5, 0xFE, + 0xC5, 0xEB, 0xF7, 0x19, 0x2F, 0xAE, 0x6E, 0x36, 0xFB, 0xBA, 0xAF, 0xEB, + 0x3D, 0x86, 0xF8, 0xFC, 0xE4, 0x78, 0x54, 0xE5, 0x1C, 0x99, 0x69, 0x66, + 0x8F, 0x46, 0x6C, 0xC4, 0x10, 0x74, 0x52, 0xC4, 0xE6, 0xF1, 0xCC, 0x97, + 0x44, 0xCE, 0xC4, 0x30, 0xA1, 0xBA, 0xD9, 0xBC, 0x2B, 0xCB, 0x92, 0x64, + 0x33, 0xE5, 0x50, 0xF0, 0x7E, 0x3F, 0xE8, 0xAA, 0xCC, 0x8D, 0x81, 0x9D, + 0x36, 0x48, 0xB0, 0xC1, 0x03, 0x19, 0x7C, 0xA3, 0xA5, 0x34, 0xDD, 0xEB, + 0xB7, 0xEF, 0x9B, 0xDE, 0x03, 0x58, 0xBE, 0x78, 0xB3, 0xAF, 0xFB, 0xA1, + 0x2C, 0xCA, 0xE7, 0x0F, 0x1F, 0x5A, 0xBD, 0xFE, 0x7F, 0xBF, 0xFC, 0xFE, + 0xED, 0x6D, 0x7B, 0xF9, 0xFE, 0xDD, 0xF5, 0xC5, 0xC5, 0xE9, 0xD1, 0xFC, + 0xE1, 0xD9, 0xBC, 0xE4, 0xF0, 0xFA, 0x7A, 0xAB, 0x94, 0x5D, 0xCE, 0x96, + 0x8B, 0x1C, 0x2C, 0x17, 0x47, 0xBD, 0x45, 0x56, 0xF6, 0xCF, 0x3F, 0x38, + 0x17, 0x82, 0xA2, 0x08, 0xA7, 0xD3, 0x89, 0x28, 0xAA, 0x0F, 0xBF, 0xF8, + 0x13, 0x26, 0x8A, 0x7F, 0xF9, 0x67, 0xFF, 0xF5, 0xD1, 0xF1, 0xC9, 0x0F, + 0x2F, 0x5F, 0xA8, 0x76, 0xD7, 0x6C, 0xDE, 0x7E, 0xF1, 0x6C, 0x79, 0xFE, + 0xEC, 0xF3, 0xAB, 0xEB, 0xDB, 0x4D, 0xE3, 0x5E, 0xBE, 0x7A, 0x3F, 0x28, + 0x6D, 0x8C, 0x6F, 0x5B, 0xB9, 0xDD, 0x36, 0xD6, 0xE9, 0xEB, 0xBB, 0x75, + 0xF0, 0xA6, 0xEB, 0xBB, 0xBC, 0xCC, 0x8D, 0xD1, 0x10, 0xC0, 0x4F, 0x3F, + 0x3C, 0xF9, 0xFE, 0xCD, 0x9B, 0xE5, 0x72, 0xB6, 0xD9, 0xEF, 0xF6, 0x4D, + 0xFF, 0xE4, 0xF1, 0xD9, 0xF9, 0xF9, 0x71, 0x80, 0xF1, 0xEA, 0xE6, 0xF6, + 0xCD, 0xDB, 0x77, 0x47, 0x8B, 0x19, 0x80, 0x71, 0x5D, 0xD7, 0x3E, 0x42, + 0xA9, 0x06, 0xA9, 0x2D, 0xD0, 0x8E, 0x71, 0x4C, 0x98, 0x18, 0x15, 0xE5, + 0x93, 0xF3, 0xF3, 0xF9, 0x74, 0xDC, 0xB6, 0x03, 0x80, 0xE8, 0xF1, 0xC3, + 0xF3, 0x5D, 0x2D, 0x21, 0xA4, 0x6F, 0xDE, 0x6D, 0xB4, 0x89, 0x8F, 0x1F, + 0x1C, 0xED, 0xF7, 0xB5, 0x92, 0x1A, 0xA2, 0xC8, 0x28, 0x7B, 0xB8, 0x38, + 0xFA, 0xFE, 0xF5, 0x3B, 0x8C, 0x00, 0xCF, 0xC4, 0xDB, 0xEB, 0x5B, 0x82, + 0xA8, 0x31, 0xB6, 0xEB, 0x5B, 0x08, 0x28, 0x04, 0xD1, 0x3A, 0xEB, 0x42, + 0x74, 0x3E, 0x5A, 0xA3, 0xA6, 0x23, 0x26, 0x65, 0xD7, 0x69, 0xE7, 0xAD, + 0x02, 0x50, 0x61, 0x8C, 0x38, 0xE3, 0xD7, 0xB7, 0xEB, 0xD9, 0x64, 0x3C, + 0x9B, 0x14, 0xF5, 0xBE, 0x56, 0x6A, 0x60, 0x84, 0x3E, 0x7E, 0x70, 0x7C, + 0x36, 0x9F, 0x1E, 0xCD, 0xE7, 0x20, 0x02, 0x67, 0xE3, 0x6E, 0x3F, 0xAC, + 0x37, 0xCD, 0xBB, 0xAB, 0x95, 0xF7, 0x60, 0x5C, 0x95, 0xEF, 0x2E, 0xB6, + 0xDF, 0xBE, 0xB8, 0xBE, 0xBA, 0x5D, 0x67, 0x9C, 0x69, 0x63, 0x01, 0xC2, + 0x83, 0xD4, 0x4A, 0x9A, 0x57, 0x3F, 0xDC, 0x02, 0x82, 0x9E, 0x3E, 0x3C, + 0xEE, 0xA5, 0x1D, 0x94, 0xC2, 0xC0, 0x20, 0xA0, 0xF2, 0x8A, 0x48, 0x3B, + 0x44, 0xA0, 0xA3, 0x57, 0x47, 0xF3, 0x1C, 0x41, 0xD7, 0x0D, 0x8D, 0x31, + 0x43, 0x2B, 0x9B, 0x22, 0x17, 0x54, 0x64, 0xA7, 0xCB, 0xA2, 0xEF, 0xF7, + 0xB9, 0x60, 0x85, 0xC8, 0x6F, 0xAF, 0xB7, 0x93, 0x6A, 0xBA, 0x5B, 0x77, + 0x28, 0x44, 0x12, 0x9D, 0x6D, 0x57, 0x23, 0xD2, 0x96, 0x78, 0xC8, 0x89, + 0xE5, 0x50, 0x93, 0x28, 0x8F, 0x8E, 0x4E, 0xB6, 0x75, 0xF7, 0xE0, 0xEC, + 0xF8, 0xE3, 0x0F, 0x8E, 0x01, 0x88, 0x42, 0xE0, 0x07, 0x67, 0xCB, 0x10, + 0xED, 0xE9, 0x71, 0x7E, 0xFE, 0x70, 0x94, 0x8F, 0xF0, 0x78, 0x91, 0x3D, + 0xFA, 0xF0, 0x38, 0xAB, 0xC4, 0xD1, 0xA3, 0xD9, 0x7C, 0x59, 0x4C, 0x4F, + 0xAA, 0xA3, 0x27, 0x8B, 0x41, 0x6D, 0x82, 0x5E, 0xCD, 0x2A, 0x49, 0x63, + 0x6D, 0xD5, 0xBE, 0xC8, 0x60, 0xC5, 0xC3, 0xA3, 0x59, 0xC8, 0x90, 0x56, + 0x7D, 0xCD, 0x43, 0x4D, 0x5C, 0xED, 0xE5, 0x6D, 0x46, 0x71, 0xC1, 0xE8, + 0x64, 0xF9, 0xD4, 0x93, 0x52, 0x2B, 0xE3, 0x01, 0xEC, 0x95, 0x0D, 0x11, + 0x02, 0x00, 0x04, 0xC3, 0x10, 0x21, 0xEC, 0x9B, 0xA8, 0x1B, 0x48, 0xF3, + 0xD4, 0x31, 0xA5, 0xCD, 0x3D, 0x88, 0xC0, 0xFB, 0x34, 0x4E, 0x82, 0x10, + 0x42, 0x29, 0x78, 0x0A, 0xA6, 0x41, 0x10, 0x08, 0x4E, 0x09, 0x81, 0x11, + 0x00, 0x63, 0x9C, 0xBF, 0xBF, 0x1E, 0x24, 0x66, 0xA7, 0x71, 0x2E, 0x91, + 0x94, 0xB4, 0x31, 0x00, 0xC2, 0x74, 0x05, 0x0E, 0x2E, 0xA4, 0xF8, 0x2A, + 0x88, 0x60, 0xAA, 0x26, 0x31, 0x46, 0x6D, 0xDC, 0xA3, 0x93, 0xC5, 0x67, + 0xCF, 0x1F, 0x52, 0xE8, 0xCB, 0x22, 0xDF, 0x36, 0xC3, 0x59, 0x6E, 0x5F, + 0xBF, 0xFA, 0xC6, 0x21, 0xF6, 0x87, 0xDF, 0xFD, 0xDD, 0xED, 0xF5, 0xFB, + 0x6A, 0x72, 0x04, 0x11, 0x8E, 0xDE, 0x23, 0x08, 0x29, 0x23, 0x00, 0x46, + 0x10, 0x0F, 0x71, 0x27, 0x87, 0xB0, 0x2A, 0x08, 0xD3, 0x11, 0x30, 0xFD, + 0x68, 0x9A, 0xBE, 0x69, 0x7A, 0xC6, 0x68, 0x9E, 0x09, 0x70, 0x20, 0x38, + 0xC5, 0x54, 0x65, 0x82, 0x0F, 0xA9, 0x1A, 0x3A, 0xE7, 0xAD, 0x0F, 0x10, + 0x22, 0x6B, 0x9D, 0xD2, 0xDA, 0x5A, 0x4F, 0x08, 0x85, 0x10, 0xF9, 0x10, + 0xA5, 0xD4, 0x07, 0x9C, 0x7E, 0x08, 0xE1, 0x3E, 0x5D, 0x14, 0x80, 0x14, + 0xF0, 0x07, 0x78, 0xC2, 0xF5, 0xDC, 0x23, 0xED, 0x84, 0xE0, 0xA3, 0x32, + 0x4F, 0x62, 0x31, 0x17, 0x3C, 0x46, 0xD8, 0x3A, 0x1B, 0x23, 0x50, 0xCA, + 0x44, 0x1F, 0x20, 0x8C, 0x5A, 0x5B, 0x78, 0xAF, 0x59, 0x4B, 0xD8, 0xE7, + 0x64, 0x98, 0xF3, 0xCE, 0xD9, 0x14, 0x49, 0x12, 0x40, 0x32, 0x39, 0x94, + 0x45, 0x46, 0x08, 0x02, 0x07, 0x42, 0x67, 0x52, 0xD2, 0xF9, 0xC4, 0x79, + 0x56, 0x4A, 0x31, 0xC6, 0x52, 0xD1, 0x56, 0xDA, 0x40, 0x08, 0x31, 0x4A, + 0x6B, 0xC3, 0x40, 0x08, 0xD1, 0xDA, 0x30, 0x4E, 0x27, 0xD3, 0x31, 0x84, + 0x10, 0x61, 0xE2, 0x63, 0x00, 0x31, 0xD1, 0xB7, 0x01, 0xC2, 0x18, 0x13, + 0x9C, 0x12, 0x3F, 0x7C, 0x08, 0x18, 0x63, 0xF8, 0xDF, 0xFD, 0x87, 0xFF, + 0xAD, 0xE9, 0x86, 0xE0, 0x3D, 0x02, 0xBE, 0xC2, 0xFA, 0x93, 0x27, 0x13, + 0x0A, 0xBA, 0xBE, 0xAD, 0x09, 0x25, 0xCB, 0xE5, 0xE2, 0xAF, 0x7F, 0xFB, + 0xED, 0xD7, 0xDF, 0xBD, 0x41, 0x80, 0xEC, 0xEB, 0x2D, 0x42, 0x30, 0x46, + 0xFC, 0xB3, 0xCF, 0x3E, 0x81, 0x30, 0x7C, 0xF8, 0xF4, 0xEC, 0xEC, 0x68, + 0x9C, 0x51, 0xE4, 0xBD, 0xBF, 0xDD, 0xEE, 0x20, 0x34, 0x43, 0xDF, 0x44, + 0x08, 0x08, 0x81, 0xDA, 0x81, 0xAA, 0x98, 0x18, 0x07, 0xEB, 0xBA, 0xDF, + 0xD7, 0xC3, 0xE9, 0xD9, 0x42, 0xAB, 0x5A, 0x2B, 0x1F, 0x02, 0xD7, 0x16, + 0x4F, 0xE7, 0xA2, 0xED, 0xFB, 0xC1, 0x58, 0x88, 0xB0, 0x10, 0x9C, 0x32, + 0x3C, 0x2A, 0x29, 0x03, 0x26, 0x5A, 0x70, 0xB7, 0x51, 0x18, 0xC5, 0x6E, + 0xD0, 0x1F, 0x7F, 0xB8, 0xDC, 0x6C, 0x6E, 0x7D, 0xCC, 0xFB, 0x81, 0x70, + 0xCA, 0xD5, 0xB0, 0x1B, 0x8D, 0x88, 0xB3, 0xE1, 0xC5, 0x9B, 0x8D, 0x1C, + 0xD4, 0xB3, 0xC7, 0x67, 0xFF, 0xE2, 0x8F, 0x3E, 0x0F, 0x01, 0xFD, 0xE6, + 0xAB, 0xD7, 0x5D, 0x2C, 0x9E, 0x3E, 0x79, 0xBC, 0xAF, 0xF7, 0x4D, 0xBB, + 0xDF, 0xAE, 0xEF, 0x00, 0xA2, 0x5A, 0xF6, 0xA3, 0x6A, 0xFC, 0xF8, 0xD9, + 0xA7, 0x94, 0xA2, 0xEB, 0x9B, 0xBB, 0x10, 0xDC, 0xDD, 0xDD, 0xFA, 0xF9, + 0x07, 0x4F, 0x9A, 0x7A, 0x73, 0x77, 0x7B, 0x97, 0xD3, 0x81, 0x50, 0xD2, + 0xD4, 0xFD, 0x64, 0x2C, 0xCA, 0x9C, 0x05, 0xE7, 0x39, 0xC3, 0x08, 0xC3, + 0x9C, 0x33, 0x86, 0xE3, 0x7A, 0xD7, 0x00, 0x84, 0x01, 0x88, 0x19, 0xA3, + 0x14, 0xFA, 0x46, 0x69, 0x84, 0xB1, 0x33, 0x32, 0xAF, 0x26, 0x45, 0xC1, + 0x87, 0xAE, 0x57, 0x16, 0xB8, 0x60, 0x62, 0xF0, 0x56, 0x7B, 0x08, 0x02, + 0xA1, 0x39, 0x42, 0x78, 0xD0, 0xED, 0xC3, 0x07, 0xC7, 0xD1, 0x85, 0xAB, + 0xDB, 0xF5, 0xB4, 0x18, 0xFD, 0xEC, 0xD3, 0xCF, 0x21, 0x74, 0x5D, 0xDF, + 0x0F, 0xDA, 0x79, 0x84, 0x7C, 0x44, 0xCE, 0x05, 0x00, 0x01, 0x85, 0x44, + 0x30, 0xCA, 0x48, 0xD8, 0x6F, 0xEB, 0xFD, 0x7E, 0x37, 0x1A, 0xE7, 0x1F, + 0x3E, 0x7F, 0x5E, 0xEF, 0xF6, 0xB7, 0xBB, 0xF5, 0xF1, 0x72, 0x8E, 0x08, + 0x1E, 0x5C, 0x78, 0xF3, 0xFA, 0xE2, 0x78, 0x36, 0xB5, 0x4A, 0x55, 0xE5, + 0xD8, 0xE9, 0x61, 0x36, 0x9D, 0x16, 0xC5, 0xE8, 0xED, 0xD5, 0x7B, 0xAD, + 0x7B, 0x46, 0x19, 0x88, 0xC8, 0x43, 0x68, 0xE5, 0x1E, 0x12, 0x96, 0x8B, + 0xF1, 0xF1, 0x72, 0x31, 0x0C, 0xB6, 0x2C, 0x29, 0x82, 0xA4, 0xEB, 0xFB, + 0x76, 0x50, 0x94, 0xE2, 0x51, 0x21, 0x86, 0xC1, 0x34, 0xDD, 0x70, 0x73, + 0xB3, 0xEB, 0xA5, 0x1E, 0xA4, 0xD4, 0xCE, 0x5A, 0xE7, 0x3E, 0x7D, 0xFE, + 0x81, 0x56, 0xFA, 0xFD, 0xED, 0x06, 0x63, 0x7C, 0xB2, 0x9C, 0x64, 0x14, + 0x4C, 0x26, 0x73, 0x40, 0x88, 0xE0, 0xAC, 0x2A, 0xC4, 0xC5, 0xD5, 0xCE, + 0x7A, 0xFD, 0xE9, 0x07, 0x4B, 0xC6, 0xF9, 0xAE, 0x6B, 0x8A, 0x4C, 0x08, + 0x92, 0xBF, 0x7C, 0x7F, 0xE5, 0x9D, 0x39, 0x5D, 0x4E, 0x18, 0x23, 0xD1, + 0x75, 0x5D, 0xD7, 0x78, 0x17, 0x30, 0x21, 0x84, 0x33, 0x88, 0x58, 0x59, + 0x16, 0x10, 0xE1, 0x2C, 0xCB, 0xB4, 0x71, 0x7D, 0xA7, 0x66, 0x55, 0x65, + 0x6C, 0x70, 0xD6, 0x52, 0x2C, 0xAE, 0x56, 0xFB, 0xBF, 0xFB, 0xDD, 0x8B, + 0x61, 0xE8, 0x7F, 0xFA, 0xE9, 0x93, 0x8C, 0x45, 0xC1, 0xE2, 0x78, 0x3A, + 0x2D, 0xF2, 0xDC, 0x47, 0x5C, 0x66, 0x7C, 0x36, 0xCA, 0x99, 0xC8, 0x9B, + 0xED, 0x46, 0x1B, 0x73, 0x79, 0xF5, 0x6E, 0xBC, 0xAC, 0x10, 0xA7, 0xF5, + 0x60, 0x77, 0xDB, 0x66, 0x5B, 0x0F, 0xD2, 0x58, 0xE8, 0x23, 0x05, 0x71, + 0x3A, 0x2B, 0x37, 0x9B, 0x36, 0x02, 0x14, 0x22, 0xE8, 0x07, 0x83, 0x28, + 0x43, 0x08, 0x5B, 0xEB, 0xF2, 0x8C, 0x65, 0x4C, 0x30, 0x96, 0x95, 0x39, + 0xBD, 0xBA, 0x7C, 0xB7, 0x59, 0xAF, 0x04, 0x67, 0x0C, 0xE1, 0xF9, 0x6C, + 0xB6, 0x3C, 0x3A, 0xB7, 0x50, 0xC0, 0xE0, 0x1C, 0xC8, 0x7B, 0x13, 0x43, + 0x24, 0xB7, 0x8D, 0x5B, 0xF5, 0x9E, 0x46, 0x19, 0x74, 0x33, 0x80, 0x09, + 0x65, 0x9C, 0x12, 0x48, 0x31, 0x74, 0x3E, 0x26, 0x5B, 0x3E, 0x84, 0x48, + 0x70, 0x9A, 0x42, 0xB6, 0x32, 0x4E, 0xB5, 0xB1, 0xD6, 0xDA, 0x42, 0x30, + 0x17, 0x82, 0x0F, 0x81, 0x33, 0x2A, 0xB5, 0x8D, 0x11, 0x10, 0x0C, 0x29, + 0xC1, 0x52, 0x59, 0x1F, 0x62, 0x84, 0x20, 0xE7, 0x34, 0x19, 0xFE, 0x9B, + 0x5E, 0x4A, 0xA5, 0x38, 0x63, 0x4A, 0x4A, 0x80, 0x70, 0xE2, 0x32, 0xDF, + 0x1B, 0xBC, 0xD5, 0xB4, 0xE0, 0x7F, 0xFC, 0xD9, 0x23, 0x0A, 0xD4, 0x97, + 0xDF, 0xBF, 0x95, 0x8E, 0x00, 0xC4, 0x97, 0xE1, 0xF6, 0x76, 0x73, 0x37, + 0x3E, 0x7B, 0xF6, 0xE2, 0xE5, 0xAB, 0xF7, 0xEF, 0x5E, 0x62, 0x3E, 0x7A, + 0xF6, 0x93, 0x3F, 0x43, 0x30, 0x6A, 0x6D, 0x9D, 0xF7, 0x49, 0x74, 0x66, + 0x8C, 0x4D, 0xD7, 0xCF, 0x18, 0xE2, 0x81, 0x7A, 0x96, 0xD8, 0x26, 0x87, + 0x34, 0x78, 0x87, 0x20, 0x7C, 0xF8, 0xE0, 0xF8, 0xF4, 0x74, 0x19, 0x62, + 0x70, 0xCE, 0x0F, 0x83, 0x22, 0x24, 0x89, 0xDB, 0x08, 0x21, 0x89, 0x00, + 0xEE, 0x63, 0x8C, 0x5A, 0xEB, 0xF5, 0x7A, 0x8B, 0x31, 0x61, 0x82, 0x1B, + 0x6D, 0x9B, 0xA6, 0x91, 0x52, 0x1F, 0xCE, 0x93, 0xA9, 0x78, 0x01, 0x90, + 0xBC, 0x69, 0x00, 0x00, 0x8A, 0x11, 0x00, 0x20, 0x44, 0x18, 0xEE, 0xD5, + 0xB6, 0xA3, 0xB2, 0x08, 0x49, 0x63, 0x06, 0x22, 0xC2, 0xD8, 0x1F, 0x62, + 0x1F, 0x12, 0xD2, 0x03, 0x52, 0x82, 0x53, 0x3A, 0x2F, 0x42, 0x08, 0x23, + 0xC4, 0x29, 0x46, 0x08, 0xA6, 0xBF, 0xA8, 0xD1, 0x86, 0x60, 0x6C, 0xAC, + 0x8D, 0xF7, 0x59, 0x9C, 0xC9, 0x62, 0x98, 0xD6, 0x8E, 0x69, 0x15, 0x98, + 0x92, 0xF1, 0xE2, 0xFD, 0xA9, 0x37, 0x55, 0xB7, 0xF4, 0x8E, 0x71, 0xCE, + 0x82, 0xC3, 0xB6, 0x8E, 0x48, 0x6D, 0x04, 0xE7, 0x55, 0x55, 0xFA, 0x10, + 0x8C, 0xB3, 0xCE, 0xDA, 0xE0, 0xBC, 0x73, 0x0E, 0x63, 0x2A, 0x84, 0x20, + 0x34, 0x21, 0x4F, 0xBC, 0xB1, 0x16, 0x63, 0x0C, 0xFF, 0xFB, 0xFF, 0xF0, + 0x1F, 0x21, 0x00, 0x5E, 0x37, 0x19, 0x27, 0x30, 0xB8, 0x9F, 0x3C, 0x11, + 0xC1, 0x0D, 0x4D, 0xDD, 0xF8, 0x00, 0x29, 0x2F, 0x5F, 0xBE, 0xBD, 0xD9, + 0x77, 0x9D, 0x52, 0xEA, 0x6C, 0x59, 0x2E, 0x17, 0x39, 0x25, 0xA5, 0x73, + 0x9E, 0xB3, 0x50, 0x15, 0x23, 0xEB, 0xC3, 0x6A, 0xB3, 0xDB, 0xD7, 0x3B, + 0x69, 0x35, 0x63, 0xC4, 0x19, 0xCD, 0x68, 0xAC, 0x3B, 0x05, 0x10, 0x7F, + 0x78, 0x3A, 0x57, 0x26, 0x5C, 0xDF, 0xDC, 0xCD, 0xC6, 0xA3, 0xF9, 0x38, + 0x77, 0x11, 0xB4, 0xAD, 0x1F, 0x4C, 0x56, 0x15, 0x65, 0xAF, 0xD6, 0x97, + 0x77, 0x35, 0x80, 0x18, 0x61, 0x0C, 0x22, 0x60, 0x8C, 0x64, 0x45, 0xB6, + 0x9C, 0xE6, 0x28, 0x28, 0x14, 0xB5, 0xF5, 0xB0, 0xAE, 0x9B, 0x47, 0xE7, + 0x79, 0xDD, 0x74, 0x93, 0xE9, 0x98, 0xC1, 0x7C, 0x54, 0xCD, 0x94, 0x96, + 0x77, 0xAB, 0xD5, 0x7E, 0xEF, 0x01, 0x10, 0x9C, 0xE0, 0x3F, 0xFF, 0x67, + 0x5F, 0xD8, 0xA0, 0x3A, 0xE9, 0xDF, 0xDD, 0xAA, 0x17, 0xAF, 0xDF, 0xCF, + 0x66, 0x33, 0x02, 0xFA, 0x93, 0x69, 0xD6, 0xA9, 0x7E, 0xBD, 0x33, 0xD7, + 0xDB, 0x20, 0xB5, 0xF9, 0xE8, 0xE3, 0x9F, 0x6C, 0x36, 0xEB, 0x8B, 0xF7, + 0xAF, 0xBF, 0xF9, 0xFA, 0xB7, 0xA7, 0x47, 0x8B, 0x3F, 0xF9, 0xA3, 0x5F, + 0xD2, 0x72, 0xBE, 0xBD, 0x7B, 0x05, 0x5C, 0xB3, 0x58, 0xCC, 0x4F, 0xE6, + 0x0B, 0xE7, 0x6D, 0x91, 0x53, 0x10, 0x83, 0x77, 0x7E, 0x54, 0x8D, 0x87, + 0x7E, 0xB8, 0x7C, 0x7F, 0x29, 0x32, 0xBE, 0x6D, 0x6A, 0x13, 0x70, 0x74, + 0x06, 0x44, 0x2F, 0x5D, 0xFC, 0xEC, 0xF3, 0xA7, 0xCD, 0xBA, 0x61, 0xBC, + 0xC8, 0x73, 0x3E, 0x9F, 0xE6, 0x90, 0xE2, 0x77, 0x97, 0x57, 0x9B, 0x5D, + 0xBB, 0xDD, 0xB4, 0x79, 0xC6, 0x95, 0x76, 0x4A, 0xC9, 0xE5, 0x72, 0x32, + 0x9D, 0x8C, 0xBC, 0x73, 0x1F, 0x3C, 0x3C, 0xCB, 0x59, 0xDE, 0xF4, 0xFA, + 0xC5, 0xDB, 0x77, 0x5D, 0x67, 0x84, 0xC8, 0x11, 0x41, 0x11, 0x40, 0x4E, + 0xF1, 0x74, 0x5C, 0xCC, 0xAA, 0x8A, 0x20, 0x04, 0x40, 0x84, 0x00, 0x1C, + 0xCD, 0x4B, 0x46, 0x40, 0xA7, 0x2D, 0xA2, 0xA8, 0xEE, 0x87, 0xBA, 0x19, + 0x30, 0xA6, 0xC9, 0x34, 0x33, 0xCA, 0x33, 0x1A, 0x03, 0x88, 0xB0, 0xEF, + 0xDA, 0xD1, 0x68, 0x0C, 0x22, 0xFC, 0xFE, 0xE2, 0x1D, 0x27, 0x80, 0x20, + 0x42, 0x09, 0x05, 0xD0, 0x29, 0x35, 0x4C, 0x46, 0x33, 0x17, 0xA0, 0x94, + 0xCA, 0x3B, 0x44, 0x39, 0xDB, 0xED, 0x5A, 0x1F, 0x70, 0x84, 0x04, 0x02, + 0xB0, 0x9C, 0x95, 0xE3, 0x32, 0xCB, 0x04, 0x45, 0x30, 0xBA, 0x68, 0xA5, + 0x52, 0x7F, 0xF8, 0xEA, 0xED, 0x5F, 0xFF, 0xE6, 0xDB, 0x7F, 0xFF, 0x97, + 0xFF, 0xAA, 0xC8, 0xB3, 0xBA, 0xEF, 0xBB, 0x5E, 0x8E, 0xCA, 0xF2, 0xE1, + 0xF1, 0x52, 0x3A, 0xF8, 0x9B, 0xAF, 0x7E, 0xC8, 0x8B, 0xC3, 0xF7, 0xD9, + 0xE7, 0xCF, 0xCF, 0xAC, 0xE9, 0x8B, 0x92, 0x9F, 0x1C, 0x97, 0x31, 0x44, + 0x6B, 0x71, 0xF4, 0xA0, 0xCA, 0x98, 0x10, 0xB8, 0x6E, 0x37, 0x83, 0x6C, + 0x3D, 0x00, 0x9C, 0x31, 0xC1, 0x73, 0xC2, 0x33, 0x6B, 0x02, 0xF4, 0xF6, + 0xEA, 0x76, 0xB7, 0x6F, 0xFA, 0x56, 0x6A, 0x00, 0x60, 0x2E, 0x44, 0x55, + 0xE6, 0xD6, 0xD8, 0x71, 0x55, 0x0A, 0x91, 0xDD, 0x6D, 0x76, 0x38, 0x7A, + 0xE7, 0x83, 0x77, 0x7E, 0x3E, 0xCB, 0x03, 0x70, 0x4A, 0x69, 0xC6, 0x08, + 0x21, 0x74, 0x54, 0x54, 0x10, 0xA3, 0x4E, 0xEA, 0x10, 0xD0, 0x30, 0xB4, + 0x10, 0x63, 0x44, 0xC9, 0xAE, 0xE9, 0x69, 0x04, 0x55, 0x95, 0xDB, 0xE8, + 0x05, 0xA5, 0x08, 0xC2, 0xB6, 0xEB, 0x36, 0xBB, 0x9E, 0x09, 0x6E, 0xAC, + 0xD9, 0x6D, 0x9B, 0xAE, 0xB7, 0x83, 0xD4, 0x79, 0x91, 0x53, 0xCE, 0xAD, + 0x71, 0xCB, 0xC5, 0xC4, 0x68, 0x2B, 0x04, 0x2D, 0x4B, 0xEA, 0xAD, 0xE2, + 0x98, 0x5E, 0x5D, 0xDF, 0x4A, 0x27, 0x09, 0xF4, 0x93, 0x7C, 0x7A, 0x32, + 0x9B, 0x4B, 0xA7, 0x38, 0x2D, 0x42, 0xE4, 0xB4, 0x1A, 0xC9, 0x61, 0xB5, + 0x97, 0xB1, 0x1C, 0x9D, 0x44, 0x52, 0x60, 0x9C, 0x2B, 0x69, 0xB4, 0xD1, + 0x63, 0xD2, 0xE7, 0x45, 0x71, 0xB5, 0x55, 0x00, 0x31, 0xCE, 0xF1, 0x38, + 0x83, 0x39, 0xF7, 0xCE, 0x29, 0x91, 0x55, 0xAD, 0xE2, 0xB9, 0xE0, 0x75, + 0xEF, 0x36, 0xAD, 0xAD, 0x0A, 0x92, 0x31, 0xBA, 0x6B, 0x55, 0x3F, 0x98, + 0x9C, 0x22, 0xE3, 0x03, 0x67, 0xDC, 0x7B, 0x1F, 0x01, 0x88, 0x00, 0x6D, + 0x9A, 0x5E, 0xC9, 0xE1, 0xB3, 0x27, 0x27, 0xB7, 0xBB, 0x6E, 0xB5, 0xEF, + 0x26, 0x39, 0x8F, 0x00, 0x0E, 0xC6, 0x13, 0x82, 0x73, 0x4E, 0x04, 0x25, + 0x9F, 0x2E, 0xF1, 0xFB, 0xBB, 0xBB, 0xA3, 0xE3, 0x65, 0xB7, 0xDF, 0xAD, + 0x76, 0x9D, 0x37, 0x9A, 0x31, 0x72, 0xF4, 0xE8, 0x69, 0x96, 0x91, 0x77, + 0xEF, 0xAF, 0xEF, 0x36, 0xC3, 0x74, 0x71, 0xD6, 0x4A, 0x9B, 0x12, 0x73, + 0xDD, 0x61, 0xC2, 0x4A, 0x99, 0x8F, 0x87, 0x36, 0x10, 0x02, 0x98, 0x76, + 0xE7, 0x10, 0x22, 0x4A, 0xA9, 0xB1, 0x16, 0x46, 0x08, 0x43, 0x1C, 0x4D, + 0xAA, 0xC5, 0x72, 0x5A, 0x95, 0x79, 0xD7, 0xF5, 0x29, 0x10, 0x37, 0x19, + 0x80, 0x7C, 0x08, 0xDA, 0xF9, 0xE0, 0x7D, 0xDB, 0xB6, 0x77, 0xAB, 0xCD, + 0x64, 0x32, 0xD1, 0xCA, 0xF6, 0xFD, 0xD0, 0x4B, 0x99, 0xA6, 0x67, 0x04, + 0x81, 0xBF, 0x17, 0x6D, 0x24, 0x0D, 0x98, 0xBF, 0x0F, 0x24, 0x06, 0xF7, + 0x42, 0xF4, 0x22, 0x13, 0x94, 0x33, 0xEF, 0x5C, 0x92, 0x89, 0xC4, 0x7B, + 0xCF, 0x69, 0x6A, 0x33, 0x05, 0xA7, 0xC9, 0xEA, 0x60, 0x6D, 0x92, 0xE9, + 0xA1, 0x8C, 0xD1, 0x10, 0x93, 0xDB, 0x07, 0xC2, 0x08, 0x7C, 0x08, 0xD6, + 0x58, 0x21, 0x38, 0x26, 0xD8, 0xFB, 0x80, 0x11, 0x1E, 0x8D, 0x4A, 0x6B, + 0x8C, 0xF5, 0x2E, 0x85, 0x07, 0xA6, 0xF8, 0xD5, 0x54, 0x97, 0x95, 0x32, + 0x18, 0xE3, 0x2C, 0xE3, 0x29, 0xDE, 0x25, 0x69, 0xE1, 0xEE, 0xCD, 0x5E, + 0x50, 0x08, 0x9E, 0xE7, 0x79, 0xB2, 0x6D, 0xA4, 0x56, 0x8E, 0x12, 0x9A, + 0x54, 0x26, 0x79, 0x96, 0x61, 0x0C, 0x5D, 0x08, 0xA9, 0x9E, 0xC2, 0xFF, + 0xF1, 0x7F, 0xFA, 0x5F, 0x7D, 0x80, 0x24, 0x0E, 0xFB, 0xDD, 0x5D, 0x96, + 0x4F, 0x4A, 0xB8, 0x7E, 0xF9, 0xFA, 0x65, 0xB0, 0x11, 0x63, 0xBA, 0x38, + 0x3E, 0x2F, 0x8B, 0x5C, 0x9B, 0x1A, 0x12, 0xCC, 0x29, 0x1D, 0xE4, 0x3E, + 0x78, 0x00, 0x22, 0xC0, 0x10, 0xFA, 0xE0, 0x28, 0x23, 0xB7, 0xAB, 0x3A, + 0x13, 0x8C, 0x32, 0xB6, 0xAF, 0x9B, 0xE5, 0x6C, 0x66, 0x9C, 0xDD, 0x37, + 0xAD, 0x10, 0xF0, 0x64, 0x39, 0x33, 0xC6, 0x82, 0x18, 0x18, 0x65, 0x75, + 0xAB, 0xB4, 0x85, 0xBB, 0x5D, 0x0F, 0x62, 0x2E, 0x72, 0xEA, 0x81, 0x69, + 0xFB, 0x20, 0x44, 0xE6, 0x43, 0x94, 0x6A, 0x10, 0x5C, 0x10, 0x4C, 0x18, + 0xC3, 0x45, 0xC1, 0xFB, 0x6E, 0xDB, 0x76, 0xE6, 0xE3, 0xA7, 0x0B, 0x6B, + 0x6B, 0xAD, 0x95, 0xB1, 0x78, 0x94, 0x67, 0x45, 0xC9, 0x08, 0x23, 0xD3, + 0x62, 0x42, 0x71, 0x56, 0x14, 0xA3, 0xEB, 0xDB, 0x7A, 0x54, 0x08, 0xC2, + 0x00, 0x0C, 0x7E, 0xDB, 0xCA, 0x49, 0x95, 0xED, 0xB7, 0x2D, 0xE6, 0x78, + 0x94, 0xF3, 0x5E, 0xE9, 0xDE, 0x98, 0xD5, 0xBA, 0xDF, 0xD5, 0x52, 0x88, + 0x62, 0x3F, 0xC0, 0x5F, 0xFD, 0xEA, 0xAF, 0x27, 0x55, 0xF6, 0xDF, 0xFE, + 0xE5, 0x2F, 0x21, 0x34, 0x10, 0x16, 0x93, 0xE5, 0x83, 0xFD, 0xE6, 0x7D, + 0x59, 0x10, 0x74, 0x88, 0x66, 0xC0, 0x55, 0x31, 0x61, 0x9C, 0x3A, 0x17, + 0xDE, 0xBE, 0xB9, 0x42, 0x30, 0x5C, 0xAE, 0x37, 0xED, 0x20, 0x19, 0xC9, + 0x1E, 0x3F, 0x9C, 0x7B, 0x08, 0x76, 0xB5, 0xE4, 0x94, 0xBF, 0xF8, 0xFE, + 0xA6, 0xCC, 0xD9, 0x93, 0xF3, 0xA3, 0x10, 0x83, 0x87, 0xFE, 0xDD, 0xD5, + 0x45, 0x55, 0x8D, 0x41, 0x0C, 0x10, 0x86, 0x5E, 0xAA, 0xE8, 0xBD, 0xC8, + 0x04, 0x44, 0xE4, 0xC1, 0xD1, 0x94, 0x11, 0x62, 0x02, 0xB8, 0x5A, 0x6D, + 0x82, 0x45, 0x8C, 0x8A, 0x2C, 0xA3, 0x79, 0xC6, 0x40, 0x04, 0x08, 0x46, + 0x0C, 0x91, 0x94, 0x4E, 0x6A, 0x53, 0x55, 0x85, 0x96, 0x32, 0xCF, 0x19, + 0x27, 0xF8, 0xEE, 0x6E, 0xCF, 0x0B, 0xB1, 0xDE, 0xB6, 0x01, 0x00, 0xCA, + 0x30, 0x63, 0x84, 0x31, 0x8A, 0x11, 0x2C, 0x05, 0x3F, 0x59, 0x4E, 0x8B, + 0x8C, 0x0D, 0x83, 0x7C, 0x73, 0x71, 0xF1, 0xC3, 0xE5, 0x75, 0x2E, 0xC8, + 0x6C, 0x34, 0x51, 0x46, 0xFA, 0x60, 0x9C, 0x77, 0x39, 0x2F, 0x9C, 0xF5, + 0x18, 0xC3, 0x18, 0x90, 0x75, 0xF0, 0xF1, 0x83, 0x93, 0xA3, 0xC5, 0xC9, + 0xAF, 0xBF, 0x7C, 0x71, 0x7B, 0xB7, 0x79, 0x78, 0x76, 0xCA, 0x28, 0x8D, + 0x31, 0x8C, 0xCA, 0xEC, 0xE4, 0x78, 0x22, 0x07, 0x15, 0x82, 0x07, 0x04, + 0x30, 0x44, 0x87, 0xC1, 0xDD, 0xAE, 0x37, 0x4A, 0x99, 0xC5, 0x6C, 0x7E, + 0x7E, 0xBE, 0xE8, 0x8D, 0x6E, 0x7A, 0xD9, 0xB6, 0xF6, 0xCB, 0xAF, 0x7F, + 0x28, 0x8A, 0xD1, 0xD1, 0x7C, 0x1E, 0x5C, 0x33, 0x99, 0x89, 0xC5, 0xAC, + 0x58, 0x4E, 0xF2, 0xD1, 0x48, 0xB8, 0x00, 0x9D, 0x03, 0x7D, 0xE3, 0xCA, + 0x02, 0xF1, 0x0C, 0xDD, 0xDD, 0xED, 0x94, 0xB3, 0x20, 0x84, 0xD9, 0x74, + 0x64, 0xA4, 0xDB, 0xAE, 0x3B, 0x6D, 0x02, 0xC2, 0xB0, 0x9A, 0x64, 0x59, + 0xCE, 0x04, 0xE3, 0xFD, 0x60, 0xA5, 0xF3, 0xAB, 0xDB, 0x5D, 0x37, 0xD8, + 0xE7, 0x8F, 0x4F, 0x8E, 0xC7, 0xE5, 0x6F, 0x7F, 0xF7, 0xCD, 0x72, 0x36, + 0x45, 0x34, 0xBE, 0xBF, 0xBE, 0xA1, 0x84, 0x3F, 0x7B, 0x7A, 0xAA, 0x8C, + 0xBD, 0x5E, 0xED, 0x3C, 0x44, 0x6D, 0x67, 0x12, 0xF0, 0xA3, 0x64, 0xF4, + 0xE3, 0x8F, 0x4F, 0xB4, 0xF7, 0x08, 0xC3, 0x00, 0x22, 0xC5, 0xF8, 0xEA, + 0xFD, 0x6A, 0xB7, 0xEB, 0x21, 0xC2, 0x08, 0x63, 0x1F, 0x41, 0xBD, 0x6F, + 0x27, 0x93, 0xEA, 0xDD, 0xC5, 0x4A, 0x19, 0x57, 0x96, 0x39, 0x88, 0x20, + 0xE9, 0xB7, 0xF7, 0xFB, 0x8E, 0x52, 0x3A, 0x9B, 0x54, 0xA3, 0x8A, 0x0B, + 0x8E, 0x36, 0xDB, 0xCD, 0xCD, 0x7A, 0x45, 0x08, 0xA4, 0x84, 0x53, 0x44, + 0xCB, 0x9C, 0x16, 0x59, 0xB5, 0xDB, 0x75, 0xB9, 0xA0, 0xD6, 0x6B, 0x1F, + 0x81, 0x10, 0xEC, 0xC1, 0xE9, 0xD1, 0x6C, 0xB1, 0x10, 0x2C, 0xE3, 0x04, + 0x4C, 0x73, 0xDC, 0xD4, 0x5D, 0x00, 0x58, 0xDB, 0x00, 0x10, 0xF0, 0x56, + 0x46, 0xE8, 0x45, 0xC1, 0xA5, 0x72, 0x22, 0x2F, 0x30, 0x80, 0xBD, 0xCD, + 0x78, 0x7E, 0xF2, 0xF0, 0xC1, 0x91, 0xB6, 0x6E, 0xB5, 0x6E, 0x56, 0x5B, + 0x3D, 0xAF, 0xC4, 0x6A, 0x2F, 0x09, 0x81, 0xB3, 0x92, 0xEC, 0x5A, 0x0D, + 0x20, 0x72, 0x01, 0x30, 0x0C, 0x07, 0xE3, 0xDF, 0xAF, 0x3B, 0x8E, 0xE1, + 0xB4, 0xA0, 0xDE, 0xC7, 0xEB, 0x5D, 0x97, 0x0B, 0x72, 0x34, 0x1D, 0x0D, + 0x52, 0x3D, 0xCE, 0x6A, 0x20, 0xE8, 0xA8, 0x9C, 0x7C, 0xFD, 0xED, 0x9B, + 0xB7, 0xD7, 0x77, 0xB3, 0xD9, 0x1C, 0x61, 0xCA, 0x39, 0x3A, 0x3A, 0xCE, + 0x37, 0x7B, 0x19, 0x62, 0x91, 0x89, 0xF2, 0xF5, 0x4A, 0x5B, 0x63, 0x63, + 0x8C, 0x11, 0x00, 0x6D, 0x1D, 0x67, 0xC4, 0x47, 0xE0, 0xAD, 0x83, 0xE8, + 0xE0, 0xCB, 0x61, 0x94, 0xA6, 0x10, 0xCA, 0xD4, 0xAA, 0xA0, 0x84, 0x01, + 0x80, 0x10, 0x12, 0x3C, 0x9D, 0x54, 0x8B, 0xD9, 0x24, 0xCF, 0xB9, 0x36, + 0x8E, 0x11, 0x02, 0x10, 0xB2, 0xDE, 0xC5, 0x08, 0xFB, 0xBE, 0xDF, 0xEF, + 0xEB, 0x10, 0x22, 0xC2, 0x74, 0xB7, 0xAB, 0xBD, 0x73, 0x01, 0x80, 0x10, + 0x01, 0x02, 0x00, 0x43, 0xE8, 0x41, 0xDA, 0xFA, 0x25, 0x87, 0x76, 0x8A, + 0xA1, 0x82, 0x00, 0x44, 0x84, 0x20, 0xC2, 0x58, 0x30, 0xC6, 0x29, 0xD5, + 0xCE, 0xFD, 0x98, 0xA6, 0x7A, 0x70, 0x0B, 0x20, 0x04, 0x21, 0x92, 0x2A, + 0x49, 0x5E, 0x41, 0xBA, 0xB7, 0xA6, 0x23, 0x03, 0x46, 0x80, 0x53, 0xD6, + 0x0F, 0x03, 0x88, 0x31, 0xC1, 0x72, 0x31, 0x4E, 0xB8, 0x1C, 0x94, 0xA4, + 0xB6, 0xA3, 0x51, 0x89, 0x20, 0xB0, 0xD6, 0x28, 0xA9, 0x7D, 0x08, 0x8C, + 0x51, 0x42, 0x48, 0x72, 0x74, 0x25, 0x59, 0x3F, 0xE7, 0x3C, 0xD5, 0x29, + 0x74, 0xEF, 0x19, 0x00, 0x00, 0x58, 0x6B, 0x19, 0xA5, 0x94, 0x0B, 0x84, + 0xF1, 0xD0, 0x77, 0xC3, 0x20, 0x01, 0x88, 0x20, 0x02, 0x17, 0x22, 0x88, + 0x20, 0xCF, 0x33, 0x6D, 0x0C, 0x63, 0x34, 0x86, 0xE0, 0xBC, 0x27, 0xBE, + 0xDF, 0x60, 0x5A, 0x58, 0xDB, 0x76, 0xF5, 0xF6, 0xEA, 0xFD, 0x65, 0x56, + 0x90, 0xAC, 0x9A, 0x2E, 0xA7, 0x05, 0x23, 0x78, 0xDD, 0xF8, 0x6F, 0x7E, + 0xFF, 0x1D, 0xA7, 0xBE, 0xEF, 0xE4, 0x64, 0x36, 0x67, 0x0C, 0x7E, 0xFF, + 0xFD, 0xDB, 0x4F, 0x3F, 0x7C, 0x04, 0x20, 0xF2, 0x20, 0x56, 0x79, 0x78, + 0x78, 0x7E, 0x54, 0x56, 0x13, 0x39, 0xB4, 0x65, 0xC9, 0xA4, 0x85, 0xDA, + 0x84, 0xA2, 0xAC, 0x9C, 0x1B, 0x76, 0x8D, 0x72, 0xCE, 0x5A, 0x17, 0x33, + 0x0E, 0x06, 0x0D, 0x0B, 0x4E, 0x9C, 0xF7, 0xC3, 0xD0, 0x60, 0xCE, 0xA5, + 0x45, 0xDB, 0x6D, 0x9F, 0x65, 0x46, 0x1B, 0x23, 0x32, 0x01, 0x33, 0xEC, + 0x23, 0x68, 0x9A, 0x8E, 0x10, 0x64, 0x3C, 0xB9, 0xBC, 0xBA, 0xA6, 0x20, + 0xB4, 0x43, 0x7B, 0x7C, 0x54, 0x9C, 0x2C, 0xC7, 0xBB, 0x5D, 0xED, 0x11, + 0x1A, 0x47, 0xCA, 0x47, 0x59, 0x8C, 0xD4, 0xA8, 0xD8, 0x75, 0x9A, 0x51, + 0xB6, 0xBB, 0xDD, 0x6F, 0x76, 0xED, 0xC3, 0xF3, 0x69, 0x2F, 0x25, 0x84, + 0x78, 0xE8, 0xD5, 0xCB, 0x37, 0xEF, 0x95, 0xF1, 0xFD, 0xA0, 0x4A, 0xC1, + 0x3F, 0x7D, 0xF2, 0x40, 0x07, 0xFA, 0xFB, 0xFF, 0xF2, 0x65, 0x95, 0x8B, + 0xC7, 0xA7, 0xD3, 0xB7, 0x57, 0x97, 0x11, 0x01, 0x60, 0x6F, 0xA6, 0xF5, + 0x40, 0xB2, 0xFC, 0x76, 0x75, 0x25, 0x18, 0x3E, 0x5B, 0x4C, 0x17, 0x8B, + 0xA3, 0xCD, 0xB6, 0xEB, 0x6E, 0x9A, 0x88, 0xA0, 0xB2, 0xA0, 0x28, 0xB2, + 0x62, 0x32, 0xF3, 0xA8, 0x1D, 0x89, 0xD2, 0x39, 0xAA, 0xBD, 0xC1, 0x18, + 0xD7, 0xED, 0xD0, 0x19, 0x1D, 0x60, 0xD8, 0x34, 0x8D, 0x8F, 0x21, 0xCB, + 0xC5, 0x78, 0x3C, 0xD9, 0xEF, 0xFA, 0x18, 0x7D, 0x96, 0x73, 0x63, 0x3C, + 0x22, 0x08, 0x33, 0xE1, 0x9C, 0x7F, 0x77, 0xBD, 0xB5, 0xC6, 0x97, 0x65, + 0x56, 0xEF, 0x9B, 0xB2, 0x9C, 0xE4, 0x23, 0x6E, 0x7A, 0xB9, 0x53, 0xCA, + 0x68, 0x4F, 0x29, 0xB6, 0x2E, 0x80, 0x88, 0xB2, 0x9C, 0xD5, 0x7D, 0xBF, + 0xBA, 0xDB, 0x5A, 0x6D, 0xAB, 0xAA, 0x04, 0x11, 0xF8, 0x56, 0x39, 0x00, + 0x9B, 0xAE, 0x2D, 0x8B, 0x8C, 0x52, 0x0C, 0x62, 0x14, 0x99, 0xE8, 0x7B, + 0x7B, 0x71, 0xB5, 0x9A, 0x4D, 0xCA, 0x27, 0x67, 0x27, 0x4F, 0x1E, 0x3C, + 0x85, 0x40, 0xEC, 0xEB, 0xF5, 0x76, 0xD3, 0x52, 0x46, 0xA4, 0x76, 0x08, + 0x41, 0x5E, 0xE4, 0x0C, 0x19, 0x8C, 0x50, 0x3B, 0x58, 0xE3, 0x1D, 0xA1, + 0xEC, 0x76, 0xB5, 0x7D, 0x70, 0x94, 0x7F, 0xF4, 0x64, 0xBE, 0x98, 0xCD, + 0x8B, 0xBC, 0xF0, 0x3E, 0x58, 0xEB, 0x01, 0x08, 0xCE, 0x1A, 0x1F, 0xF1, + 0xC9, 0xD1, 0x24, 0x13, 0x6C, 0xBB, 0xA9, 0x1F, 0x3F, 0x9A, 0x32, 0xC1, + 0xDB, 0x6E, 0x00, 0xD8, 0x3B, 0xEA, 0xE6, 0x02, 0x3F, 0x7F, 0xB6, 0x7C, + 0xFA, 0xE8, 0x58, 0x05, 0x98, 0xE7, 0x86, 0xF3, 0x05, 0xA2, 0x04, 0x82, + 0x38, 0x29, 0x38, 0x02, 0x51, 0xB6, 0x3D, 0xA0, 0xF8, 0xD5, 0xBB, 0x0B, + 0xE7, 0xC1, 0x6C, 0x52, 0x46, 0xE7, 0x8C, 0xD7, 0x93, 0x71, 0xF6, 0xFA, + 0xC5, 0xED, 0x68, 0x5C, 0x1D, 0x9F, 0xCE, 0xB5, 0xB6, 0x79, 0x29, 0x94, + 0x54, 0xC6, 0x58, 0x6F, 0x43, 0xDD, 0x69, 0x69, 0xF4, 0x47, 0x1F, 0x9E, + 0xDC, 0x6C, 0xFB, 0x77, 0x37, 0xEB, 0xDD, 0x76, 0xFF, 0xD3, 0x2F, 0x9E, + 0x1A, 0x65, 0x2E, 0x57, 0x77, 0x67, 0x67, 0x73, 0x4E, 0x32, 0x63, 0xC2, + 0x9B, 0x8B, 0xD5, 0xA6, 0xED, 0xA4, 0x32, 0x6D, 0xDB, 0x67, 0x5C, 0x60, + 0x4C, 0xFF, 0xF8, 0x4F, 0xFF, 0x24, 0x27, 0x61, 0xBD, 0xBA, 0x33, 0x31, + 0x50, 0x86, 0x17, 0xB3, 0xF2, 0x17, 0x3F, 0x7D, 0x1C, 0x3D, 0xDC, 0x6D, + 0x07, 0xE3, 0x1C, 0x02, 0x18, 0x00, 0xD4, 0x4B, 0xF3, 0xF8, 0x64, 0xF9, + 0xD5, 0x77, 0xEF, 0x56, 0x75, 0x4F, 0x29, 0x35, 0xCE, 0xDA, 0xA6, 0x65, + 0x8C, 0x15, 0x19, 0xE5, 0x38, 0x8E, 0x32, 0x54, 0x95, 0xE2, 0xB3, 0x67, + 0x5F, 0x40, 0x10, 0x6C, 0x08, 0x83, 0x72, 0x46, 0xF9, 0x94, 0xFC, 0x52, + 0xE6, 0xDB, 0x7F, 0xFC, 0xEA, 0xA5, 0xF3, 0x41, 0x49, 0x6B, 0xBD, 0x6F, + 0x3B, 0xFF, 0x29, 0xA4, 0x77, 0xAB, 0x6F, 0x21, 0xF0, 0x8F, 0x4E, 0x4F, + 0x8F, 0x97, 0xCB, 0x8C, 0xE7, 0x46, 0x35, 0x30, 0xD2, 0x41, 0x21, 0x42, + 0x31, 0x8E, 0x99, 0xB7, 0xED, 0xD0, 0x75, 0x52, 0x6B, 0x00, 0xC1, 0x3C, + 0xB3, 0xB1, 0x0F, 0x7A, 0xD0, 0x58, 0x77, 0x67, 0x93, 0x62, 0x31, 0xCE, + 0xA7, 0x65, 0xCE, 0xC3, 0xBE, 0xAE, 0xAF, 0x66, 0x34, 0x32, 0x8A, 0xAB, + 0xBC, 0xF2, 0x20, 0xFB, 0xFE, 0x5A, 0x3D, 0x5E, 0x66, 0x67, 0x53, 0x81, + 0x60, 0x90, 0xC6, 0xCC, 0xC6, 0x82, 0x11, 0x02, 0x00, 0x5A, 0x16, 0xFE, + 0xC3, 0xD3, 0x23, 0x91, 0x97, 0x3F, 0xBC, 0x5D, 0x4D, 0xC6, 0x19, 0x21, + 0x73, 0x6B, 0x62, 0x9E, 0x7B, 0x8A, 0xED, 0xFE, 0x76, 0x0B, 0x11, 0xFC, + 0xC9, 0x47, 0xCB, 0xBE, 0x87, 0xD0, 0xF9, 0x00, 0x62, 0x5E, 0x8E, 0xD7, + 0x7B, 0xAF, 0x8C, 0x5B, 0xEF, 0x7A, 0x41, 0x50, 0x60, 0xB8, 0x95, 0x16, + 0x02, 0x90, 0x30, 0x73, 0x18, 0x63, 0xE7, 0x0C, 0x22, 0xD8, 0x07, 0x1F, + 0x03, 0x60, 0x98, 0x20, 0x8C, 0x22, 0x08, 0xF5, 0x76, 0x6F, 0x07, 0x79, + 0x7A, 0xBA, 0xAC, 0x26, 0x63, 0xE7, 0x7C, 0x0C, 0x01, 0x42, 0xA4, 0xB5, + 0x36, 0xDA, 0x0C, 0x83, 0x14, 0x3C, 0xDB, 0xED, 0x6A, 0xE3, 0xEC, 0xC1, + 0x85, 0x16, 0x0F, 0x53, 0x2A, 0x48, 0xF1, 0x63, 0x21, 0x26, 0x41, 0x49, + 0xE2, 0x33, 0xA6, 0xC9, 0x31, 0x79, 0x9E, 0x1A, 0xD3, 0x87, 0x18, 0x18, + 0x65, 0xF0, 0x90, 0x9B, 0x95, 0x02, 0x56, 0x1C, 0x25, 0x24, 0x04, 0xEF, + 0x03, 0x38, 0x80, 0xDA, 0x11, 0x02, 0x30, 0x42, 0x08, 0x8D, 0x75, 0xCE, + 0x0E, 0x82, 0x12, 0xA9, 0x8C, 0x0D, 0x16, 0x61, 0x8C, 0x30, 0xF2, 0xDE, + 0x11, 0x02, 0xF3, 0x3C, 0x53, 0x4A, 0x87, 0x54, 0x44, 0x21, 0xA2, 0x8C, + 0x02, 0x6B, 0x05, 0x17, 0x08, 0x23, 0x6B, 0x2D, 0x00, 0x20, 0xCB, 0x33, + 0x8C, 0x50, 0x0A, 0x79, 0xC8, 0xF3, 0x5C, 0x4A, 0x75, 0x7F, 0xF0, 0xC5, + 0x08, 0x21, 0x17, 0x02, 0x0A, 0xEE, 0xFE, 0x8C, 0x10, 0x11, 0x22, 0x8C, + 0x73, 0xA5, 0x15, 0x88, 0x51, 0x0F, 0x03, 0x26, 0xC4, 0x6B, 0x03, 0x11, + 0x0A, 0xD6, 0xC3, 0xFF, 0xFD, 0x3F, 0xFE, 0xCF, 0xAB, 0xED, 0xB0, 0xAB, + 0xF7, 0xCE, 0x9B, 0x22, 0xCF, 0x10, 0x02, 0x0F, 0x1E, 0x9E, 0xDC, 0xDD, + 0xDC, 0x6C, 0x36, 0xFB, 0xBA, 0xF5, 0x08, 0x44, 0xE9, 0xA1, 0xE0, 0xB9, + 0x8F, 0x10, 0x00, 0x85, 0x40, 0x3B, 0x5F, 0xCC, 0x82, 0x8B, 0x9D, 0x54, + 0xDA, 0xA8, 0xE5, 0xAC, 0xDC, 0xD6, 0x3D, 0x08, 0x00, 0x00, 0xDF, 0x0D, + 0x76, 0xBD, 0x56, 0x93, 0x49, 0xD9, 0xB6, 0xDD, 0xA8, 0x12, 0x3E, 0x18, + 0xAD, 0xFD, 0xB8, 0xE4, 0xCA, 0x04, 0x4A, 0x10, 0x44, 0xA8, 0x69, 0x34, + 0x00, 0x60, 0x5B, 0x0F, 0xBB, 0x7A, 0x60, 0x04, 0x87, 0x08, 0x27, 0xD3, + 0xE9, 0xA8, 0x2A, 0x43, 0x08, 0x20, 0x82, 0x5C, 0xE0, 0x07, 0x67, 0xCB, + 0xB6, 0x69, 0x67, 0x55, 0xC9, 0xB3, 0x7C, 0x3E, 0xCB, 0xCA, 0x9C, 0xE6, + 0x5C, 0x78, 0xEF, 0xDB, 0xB6, 0x43, 0x20, 0x16, 0x79, 0xB9, 0xDA, 0x76, + 0x5A, 0xBB, 0xB2, 0x2C, 0xDB, 0xA6, 0x63, 0x04, 0x07, 0x68, 0xEB, 0xAE, + 0x9B, 0x16, 0x23, 0xAD, 0xE5, 0xDB, 0x9B, 0x5B, 0xE7, 0xE3, 0xF1, 0x62, + 0xFA, 0x60, 0xB9, 0x68, 0x3B, 0xF9, 0xEE, 0x66, 0x7F, 0xD7, 0xF9, 0xED, + 0xF6, 0xAE, 0xDD, 0xDE, 0x7E, 0xF0, 0xF4, 0x98, 0x30, 0x94, 0x51, 0x3E, + 0x9D, 0x2C, 0xDA, 0x41, 0x5D, 0xDF, 0xDC, 0x6A, 0xA3, 0x7E, 0xF9, 0xF9, + 0xC7, 0x82, 0xE7, 0x5A, 0x69, 0x2E, 0x8A, 0xF5, 0xBE, 0x1D, 0x64, 0x17, + 0x82, 0x56, 0x2E, 0x00, 0x80, 0x96, 0xE3, 0x79, 0xD7, 0x75, 0xBB, 0xB6, + 0xC9, 0x32, 0x82, 0x31, 0x0A, 0x10, 0x6E, 0xB7, 0x6D, 0x74, 0xE1, 0x27, + 0x3F, 0x7D, 0xE6, 0xBD, 0xB7, 0xC6, 0x3A, 0x17, 0xBA, 0x41, 0x2A, 0x2D, + 0xEB, 0xBA, 0xC1, 0x18, 0x16, 0x55, 0x51, 0xE4, 0xB9, 0xEC, 0x8D, 0x96, + 0x66, 0x3C, 0x2A, 0x10, 0x0E, 0x10, 0x52, 0xA3, 0xDD, 0x6E, 0xDF, 0x12, + 0xCA, 0x22, 0x80, 0xD6, 0xDA, 0x6A, 0x54, 0xE5, 0xB9, 0xD8, 0x6F, 0x77, + 0x22, 0xE3, 0x52, 0x19, 0x04, 0xE0, 0x64, 0x54, 0x44, 0x00, 0xDB, 0xB6, + 0xA7, 0x9C, 0xBD, 0x7A, 0x73, 0x21, 0x38, 0x3F, 0x3D, 0x5D, 0x58, 0x63, + 0x36, 0xBB, 0xE6, 0xF4, 0x68, 0x91, 0x31, 0x94, 0x09, 0x56, 0x66, 0x6C, + 0x3E, 0x9D, 0xEF, 0xF6, 0xF2, 0x68, 0x96, 0xAD, 0x37, 0xBB, 0x76, 0x18, + 0xDA, 0x7E, 0x38, 0x3F, 0x3A, 0x1E, 0x55, 0xC5, 0xA8, 0x22, 0xA3, 0x51, + 0x7E, 0xB7, 0x6F, 0xBE, 0x7B, 0x75, 0x39, 0x1E, 0xE5, 0x1F, 0x3C, 0x3A, + 0xA7, 0x84, 0x12, 0x4A, 0xAB, 0xB2, 0x28, 0x84, 0x40, 0x11, 0xBD, 0x7E, + 0x7B, 0xCD, 0xA8, 0x8F, 0xC8, 0x01, 0xC4, 0x05, 0x63, 0x82, 0xD2, 0x7D, + 0xDD, 0x8E, 0xC7, 0x79, 0x04, 0xE1, 0x2D, 0x31, 0xC6, 0xEF, 0x00, 0x00, + 0x20, 0x00, 0x49, 0x44, 0x41, 0x54, 0xCD, 0xDB, 0xF7, 0xC6, 0xFA, 0x72, + 0x3C, 0x76, 0xD6, 0x4D, 0x67, 0xC7, 0x4A, 0xEB, 0xC5, 0x14, 0xB5, 0xBA, + 0xDF, 0xB5, 0xDA, 0x06, 0x30, 0x48, 0x83, 0x30, 0xC9, 0x32, 0x4E, 0x09, + 0xCE, 0x04, 0x75, 0xC6, 0x09, 0x00, 0x90, 0x8F, 0x2F, 0x7F, 0xB8, 0x59, + 0x6F, 0x5A, 0x91, 0x11, 0xE0, 0xC1, 0x67, 0x9F, 0x3F, 0xAE, 0x1B, 0xD9, + 0x4B, 0x35, 0x9F, 0x97, 0xED, 0x5E, 0x5E, 0x5C, 0xAD, 0x01, 0x44, 0x83, + 0x34, 0xC1, 0xF9, 0xF3, 0xB3, 0x85, 0x8C, 0xFE, 0xFC, 0x78, 0x81, 0x42, + 0x98, 0x8D, 0xF3, 0x51, 0x29, 0x10, 0x46, 0x52, 0x45, 0x08, 0x71, 0x08, + 0x5E, 0x5B, 0xCB, 0x38, 0x5A, 0xED, 0xF6, 0x77, 0xB7, 0x3B, 0x10, 0xF1, + 0x6C, 0x76, 0x34, 0xF4, 0xF2, 0xE5, 0xAB, 0xD7, 0x08, 0xBA, 0xB2, 0xAA, + 0x26, 0xA3, 0xEC, 0x5F, 0xFD, 0xC9, 0x87, 0xBD, 0x34, 0x9B, 0xFD, 0x20, + 0xA5, 0x25, 0x94, 0xC6, 0x10, 0xAD, 0xF5, 0x93, 0x69, 0x45, 0x31, 0x06, + 0x00, 0xB6, 0x52, 0xF7, 0xDA, 0x5C, 0x5F, 0xDF, 0x8D, 0x73, 0x0C, 0x20, + 0x9A, 0x4F, 0xC7, 0x3E, 0x58, 0xC6, 0x88, 0xE0, 0xD4, 0xB8, 0x78, 0xB7, + 0x6E, 0x94, 0xF1, 0x00, 0xA1, 0x61, 0xD0, 0x14, 0x33, 0xCE, 0x49, 0x55, + 0x08, 0x2D, 0xCD, 0xDD, 0x66, 0xFB, 0x9B, 0x2F, 0xBF, 0x93, 0xDA, 0xFC, + 0xF3, 0x5F, 0x7E, 0xCE, 0x09, 0xA2, 0x04, 0xCD, 0x16, 0x55, 0x80, 0xAE, + 0xEF, 0xBA, 0x49, 0x35, 0x2D, 0x45, 0x21, 0x08, 0x8F, 0x31, 0x84, 0x88, + 0x9C, 0x0D, 0x0E, 0x18, 0x82, 0x21, 0x40, 0x60, 0x3C, 0x29, 0x18, 0x45, + 0x75, 0x2D, 0x37, 0xAB, 0xC6, 0x33, 0x1C, 0x51, 0xA4, 0x84, 0x3E, 0x3E, + 0x5D, 0x76, 0xFB, 0x66, 0xD7, 0xF4, 0xC7, 0x27, 0x8B, 0xCD, 0x66, 0x3B, + 0xAB, 0xCA, 0xC9, 0xAC, 0x40, 0x98, 0x43, 0xC2, 0x80, 0x83, 0x4A, 0xB9, + 0xF1, 0x78, 0xDC, 0x0F, 0x92, 0x22, 0x34, 0x19, 0x95, 0x57, 0x37, 0x97, + 0x10, 0x84, 0xBE, 0x1F, 0xB6, 0xBB, 0xBD, 0x0F, 0xC0, 0x7B, 0x38, 0x19, + 0x4F, 0xFB, 0xA1, 0x0F, 0xCE, 0xAC, 0xEB, 0xDD, 0xD3, 0xA7, 0x4F, 0x8A, + 0x2C, 0xEF, 0xBB, 0x1E, 0x47, 0x47, 0x28, 0x1B, 0xCF, 0x47, 0xDB, 0x0E, + 0x78, 0x1D, 0x37, 0xB5, 0x15, 0x04, 0xAD, 0x15, 0xE8, 0x0D, 0x68, 0x1A, + 0xD5, 0x69, 0x77, 0x50, 0x9C, 0xC4, 0xE0, 0x43, 0x74, 0x3E, 0x44, 0x1F, + 0x29, 0xC2, 0x88, 0x00, 0x84, 0x10, 0x88, 0x30, 0x78, 0xCF, 0x28, 0x3D, + 0x3E, 0x3B, 0x9A, 0x4D, 0xC7, 0x21, 0x46, 0xEB, 0x43, 0x3F, 0xC8, 0xAE, + 0xEB, 0xD7, 0xEB, 0x5D, 0xCA, 0x73, 0xF0, 0x20, 0x02, 0x00, 0x7C, 0x08, + 0x14, 0xA2, 0xE4, 0xB0, 0xF5, 0x07, 0x93, 0x00, 0x70, 0xDE, 0x13, 0x8C, + 0x12, 0x10, 0x18, 0xC4, 0x98, 0x65, 0x59, 0xDA, 0x79, 0x25, 0x32, 0x7A, + 0x72, 0x0E, 0xA4, 0x7B, 0x28, 0x44, 0x49, 0x79, 0x4B, 0xB4, 0xF1, 0xDD, + 0xA0, 0x30, 0x46, 0x93, 0x82, 0x15, 0x9C, 0x00, 0x94, 0x2C, 0x04, 0x16, + 0x04, 0xCF, 0x09, 0xDE, 0x77, 0xCA, 0xC7, 0x43, 0x80, 0x58, 0x4A, 0xF0, + 0x4D, 0x37, 0xD3, 0x2C, 0x13, 0x65, 0x99, 0x19, 0x6D, 0xAC, 0x35, 0x29, + 0xFD, 0xAF, 0x28, 0xB2, 0x24, 0xF4, 0xE5, 0x9C, 0xA7, 0xBD, 0xBE, 0x77, + 0x16, 0x53, 0x4A, 0x09, 0x55, 0x5A, 0x32, 0xC6, 0xAA, 0xD1, 0xB8, 0x6D, + 0x3B, 0x63, 0x4C, 0xF0, 0x0E, 0xC4, 0x10, 0x23, 0x48, 0x18, 0x32, 0x91, + 0xE7, 0xCE, 0x59, 0xEF, 0x1C, 0x3A, 0x10, 0x95, 0x00, 0x02, 0x28, 0xC4, + 0x08, 0xFF, 0x97, 0xFF, 0xE1, 0xDF, 0x15, 0x22, 0xEB, 0xDA, 0xDA, 0x5A, + 0xF7, 0xD3, 0x8F, 0x1F, 0x42, 0x18, 0xAC, 0x07, 0xEB, 0x4D, 0xED, 0xBC, + 0xAD, 0x78, 0x55, 0xEF, 0x07, 0x8B, 0x8B, 0xD5, 0x00, 0x37, 0xAB, 0xCB, + 0x87, 0xE7, 0xB3, 0xAE, 0xAB, 0x31, 0x05, 0x30, 0xBA, 0x5E, 0x76, 0x9D, + 0xF2, 0xDE, 0xF9, 0x57, 0xAF, 0xEF, 0x3E, 0xFD, 0xF8, 0xA4, 0x6F, 0xBB, + 0xAE, 0x73, 0x22, 0xCF, 0xD3, 0xB8, 0x1A, 0xEC, 0x90, 0xE5, 0x24, 0x13, + 0x0C, 0xC3, 0x58, 0x8E, 0x46, 0x4D, 0xD7, 0x01, 0xE0, 0x33, 0x91, 0xBD, + 0x7D, 0xBF, 0x5E, 0xAD, 0xDA, 0xF9, 0x62, 0xDE, 0xB7, 0xCA, 0x59, 0x53, + 0xE6, 0x85, 0x72, 0xA1, 0x28, 0xB2, 0xD3, 0xE5, 0xF8, 0x8F, 0x3E, 0x7D, + 0x6A, 0x3D, 0x12, 0x39, 0x93, 0xCA, 0xD7, 0x8D, 0x0E, 0x21, 0x18, 0x63, + 0xB2, 0x9C, 0x5B, 0xA3, 0x19, 0x41, 0xD3, 0x11, 0x27, 0x8C, 0x18, 0x6B, + 0x28, 0x82, 0x39, 0xCB, 0x2F, 0x6F, 0x76, 0xAB, 0x6D, 0x2D, 0x72, 0xDC, + 0x0D, 0x83, 0x37, 0xE1, 0xFC, 0x64, 0x06, 0x00, 0xDC, 0x37, 0xDD, 0xF1, + 0x7C, 0xEA, 0x83, 0x7B, 0xFB, 0x7E, 0x23, 0xF2, 0x5C, 0x46, 0xFA, 0xFB, + 0x3F, 0xFC, 0x3E, 0xA3, 0xF0, 0xD9, 0xA3, 0x85, 0x32, 0x6A, 0x36, 0x9D, + 0xAE, 0xB7, 0x7B, 0xA3, 0x1D, 0x46, 0xF4, 0xE8, 0x68, 0x36, 0x1F, 0x8F, + 0xDF, 0xBD, 0xBF, 0x69, 0x9A, 0x6E, 0x32, 0x1D, 0x53, 0x21, 0x9C, 0xD7, + 0x82, 0xD3, 0x37, 0xEF, 0x57, 0x9B, 0x7D, 0x37, 0x1D, 0x4D, 0x31, 0xF2, + 0x01, 0x84, 0xD9, 0x78, 0x64, 0x9D, 0xF6, 0xC1, 0x51, 0x46, 0x07, 0x69, + 0x05, 0xE1, 0x22, 0x23, 0xD2, 0xF4, 0x31, 0x22, 0x63, 0x4C, 0x35, 0x2E, + 0xB7, 0xBB, 0xFD, 0x68, 0x54, 0xED, 0xB6, 0xB5, 0x92, 0xBA, 0x2A, 0x0B, + 0x8A, 0x71, 0x55, 0x16, 0x56, 0x9B, 0xA6, 0xED, 0x9B, 0x5E, 0x36, 0xBD, + 0x12, 0x5C, 0x50, 0xC6, 0xAD, 0xD1, 0xB3, 0xD9, 0x58, 0x70, 0x96, 0xE7, + 0x99, 0x56, 0x3A, 0x99, 0x75, 0x65, 0x3F, 0x64, 0x99, 0x88, 0x10, 0x69, + 0xAD, 0xEA, 0x56, 0x3A, 0xE7, 0x8A, 0x9C, 0xC5, 0x18, 0x07, 0x29, 0xC7, + 0xD5, 0x68, 0x36, 0xAB, 0x50, 0xF0, 0x8C, 0x60, 0xC6, 0xD9, 0x20, 0xED, + 0xB4, 0x1C, 0xCF, 0xA6, 0xD5, 0x7A, 0xBF, 0x26, 0x31, 0x0A, 0x26, 0x08, + 0x45, 0x8B, 0x45, 0xB6, 0xDF, 0x77, 0xD5, 0xB8, 0x02, 0x11, 0x84, 0x80, + 0x8B, 0xA2, 0xF0, 0x11, 0x48, 0xE5, 0xAF, 0xEF, 0xB6, 0x01, 0xC4, 0xA3, + 0xC9, 0x64, 0x9C, 0x13, 0xE7, 0xD5, 0xFB, 0xEB, 0xCD, 0x78, 0x54, 0x94, + 0x05, 0x13, 0x9C, 0x31, 0x4A, 0xA7, 0x55, 0x51, 0xD7, 0x1D, 0x20, 0x31, + 0xCB, 0x59, 0xD7, 0x6B, 0x69, 0xA2, 0x76, 0xDC, 0xCB, 0xBB, 0xA1, 0x53, + 0xBB, 0xBA, 0x0F, 0x38, 0x9E, 0x3E, 0x39, 0xDD, 0xEE, 0xDA, 0xB6, 0x93, + 0x2C, 0xCB, 0x11, 0x26, 0x55, 0xC1, 0x26, 0x15, 0xAF, 0x72, 0x3E, 0xCE, + 0xB2, 0xEB, 0x77, 0xB7, 0x4D, 0xD3, 0x2F, 0x8F, 0xA6, 0xC7, 0x27, 0xF3, + 0xAB, 0xAB, 0xF5, 0xA0, 0xAC, 0xB6, 0xEE, 0xEE, 0x7A, 0x43, 0x10, 0xA9, + 0x07, 0xF5, 0xEC, 0xC9, 0x93, 0x46, 0x1A, 0xAB, 0x2D, 0x8C, 0x91, 0x50, + 0xFC, 0x8B, 0xCF, 0x3E, 0xB8, 0x5B, 0x6F, 0x09, 0x8C, 0x59, 0x96, 0xFF, + 0xF0, 0xF6, 0xBA, 0x28, 0x44, 0x96, 0xD1, 0xE3, 0xA3, 0xE9, 0x76, 0xDF, + 0x7A, 0xFF, 0xFF, 0xF1, 0xF4, 0x26, 0x4B, 0x97, 0x65, 0xE7, 0x79, 0xDE, + 0xEA, 0xD7, 0xDA, 0xFD, 0x3E, 0xFD, 0xDF, 0x66, 0xF3, 0x57, 0x56, 0x5F, + 0x60, 0x15, 0x08, 0x90, 0x94, 0x44, 0x5B, 0x94, 0xC2, 0x52, 0xC8, 0x23, + 0x47, 0x28, 0x3C, 0xD3, 0xC0, 0xE1, 0x91, 0x07, 0x1E, 0x38, 0x7C, 0x05, + 0xBE, 0x28, 0x0F, 0x1C, 0xF6, 0xC8, 0xA6, 0x1D, 0xA2, 0x25, 0x8B, 0x00, + 0x01, 0x02, 0x20, 0x50, 0xC8, 0xCA, 0xCA, 0xFC, 0xFB, 0xD3, 0x9F, 0xDD, + 0xAE, 0xBD, 0x57, 0xEF, 0x41, 0x32, 0x74, 0x0B, 0xDF, 0xF4, 0x7B, 0x9E, + 0xF7, 0xF9, 0xC7, 0x4F, 0xFF, 0x87, 0xBB, 0xED, 0x30, 0xBA, 0xA7, 0xCD, + 0xC1, 0x07, 0x7B, 0x36, 0x13, 0x21, 0xB0, 0x3F, 0xFF, 0xC9, 0x8D, 0x0B, + 0xFA, 0x97, 0x7F, 0xF8, 0x50, 0xB7, 0x43, 0xD3, 0x8C, 0x8C, 0xF2, 0x49, + 0x11, 0x47, 0x42, 0x04, 0x04, 0x07, 0xA5, 0x93, 0x38, 0x5E, 0xAD, 0xE6, + 0x46, 0xEB, 0xD5, 0x54, 0x78, 0xEF, 0x1E, 0xD7, 0x6B, 0x11, 0x25, 0xDE, + 0x81, 0xB6, 0xEB, 0x02, 0x84, 0x5D, 0x3F, 0x36, 0xED, 0x40, 0x08, 0x0D, + 0x3E, 0x10, 0x4A, 0x83, 0x07, 0x21, 0x00, 0xC6, 0xF0, 0xA4, 0xC8, 0x63, + 0x4E, 0xF7, 0x87, 0x9D, 0x07, 0x7A, 0x36, 0x9B, 0x28, 0x63, 0xBD, 0x81, + 0x3C, 0x66, 0x49, 0x19, 0x7B, 0xE3, 0x59, 0x00, 0x00, 0x40, 0xA3, 0x4C, + 0x2C, 0x18, 0xA1, 0x88, 0x61, 0xD4, 0x76, 0xB2, 0xAA, 0x07, 0x42, 0x05, + 0xA1, 0xD8, 0x38, 0x75, 0x3C, 0x1D, 0xD2, 0x38, 0xEB, 0x8C, 0x66, 0x9C, + 0x21, 0x02, 0xCB, 0x2C, 0x5E, 0x95, 0xF9, 0xE5, 0xD9, 0x52, 0x6A, 0xF5, + 0xF8, 0xB4, 0x4F, 0xB2, 0x58, 0x2B, 0x35, 0x6A, 0x95, 0x16, 0x59, 0x70, + 0x2E, 0x63, 0x7C, 0x56, 0x2E, 0xD5, 0xA0, 0xAD, 0xB3, 0xBD, 0x1C, 0x4E, + 0x4D, 0x9B, 0x08, 0xA6, 0xF5, 0x78, 0xA8, 0xAA, 0xB2, 0x9C, 0x8D, 0xE3, + 0xB8, 0xD9, 0xEC, 0xE3, 0x38, 0x8D, 0x39, 0x3B, 0xB4, 0xC7, 0x00, 0xF8, + 0xA1, 0x0E, 0xA3, 0xB6, 0xAB, 0x59, 0x96, 0x27, 0xE2, 0xC3, 0xED, 0x13, + 0x40, 0x20, 0x89, 0x05, 0x46, 0x78, 0x3E, 0x2F, 0xB3, 0x2C, 0xD1, 0x1A, + 0x38, 0x07, 0x46, 0x0B, 0xD7, 0x95, 0xC7, 0x98, 0x29, 0x07, 0x94, 0xB1, + 0x10, 0x40, 0xEB, 0x5C, 0x16, 0x73, 0x08, 0xB1, 0xF5, 0xC1, 0xAA, 0xCE, + 0x38, 0x60, 0x02, 0x29, 0x33, 0x11, 0x27, 0x49, 0x92, 0x17, 0x84, 0x92, + 0xC3, 0xE1, 0x78, 0x38, 0xD4, 0xC6, 0x98, 0x44, 0xD0, 0x76, 0xD0, 0xE6, + 0x63, 0x87, 0xE6, 0x63, 0x2A, 0xE5, 0x23, 0xA0, 0x06, 0x01, 0x25, 0x84, + 0x10, 0xA4, 0x94, 0x71, 0xE1, 0x1F, 0xFB, 0x71, 0x94, 0x52, 0xC1, 0x79, + 0x00, 0x80, 0x60, 0xFC, 0x9F, 0x47, 0x07, 0xFE, 0xF3, 0xA6, 0x53, 0x00, + 0x00, 0x05, 0x47, 0x08, 0x2E, 0xB9, 0x22, 0x24, 0x00, 0x0F, 0x32, 0xE6, + 0x03, 0x50, 0xAD, 0x16, 0xBD, 0x89, 0x61, 0x40, 0xBD, 0xD4, 0x1E, 0x00, + 0xED, 0x5C, 0xC4, 0xC0, 0x34, 0xFD, 0x38, 0xCF, 0x0B, 0x01, 0x80, 0xBD, + 0x02, 0xCD, 0x80, 0x31, 0x26, 0x79, 0x9E, 0x20, 0x08, 0x3E, 0x4A, 0x44, + 0xD6, 0x58, 0xC6, 0x89, 0x10, 0x02, 0x42, 0xE4, 0x9D, 0xA3, 0x8C, 0x5A, + 0x6B, 0x3F, 0xA2, 0xC8, 0xDE, 0x79, 0x88, 0x90, 0xB1, 0x1F, 0xB7, 0x91, + 0xB1, 0x77, 0xDE, 0xBB, 0x8F, 0x56, 0x86, 0x73, 0xCE, 0x0D, 0x83, 0x56, + 0xA3, 0x4E, 0x12, 0x11, 0xC7, 0x0C, 0x06, 0xAB, 0x6D, 0x80, 0x88, 0x76, + 0x9D, 0xC4, 0x08, 0xE1, 0x3F, 0xF9, 0xE6, 0xF3, 0x80, 0x80, 0xF5, 0xE6, + 0x62, 0x31, 0xA9, 0x4E, 0x87, 0xA6, 0x6B, 0xDA, 0xBA, 0x15, 0x49, 0xDC, + 0xFB, 0xA0, 0x8D, 0x31, 0xD0, 0x31, 0xCE, 0x66, 0x65, 0xF1, 0x72, 0x95, + 0x08, 0x4A, 0x56, 0xCB, 0x45, 0x1C, 0x89, 0xBC, 0x48, 0x85, 0x10, 0xC1, + 0xFB, 0xC3, 0xFE, 0x44, 0x39, 0x27, 0x14, 0x22, 0x8C, 0x8B, 0x9C, 0x67, + 0x99, 0xA8, 0x9B, 0x81, 0x61, 0x20, 0x04, 0xC9, 0xF2, 0x54, 0x30, 0x64, + 0x9C, 0x1B, 0x94, 0x21, 0x88, 0xAC, 0x37, 0xC7, 0xCD, 0xBE, 0x09, 0x00, + 0x24, 0x49, 0x34, 0xC8, 0x71, 0x39, 0xCB, 0x2E, 0xCE, 0x16, 0x67, 0xB3, + 0x72, 0x5A, 0xA4, 0x9F, 0xBE, 0xB8, 0x7C, 0x71, 0xB6, 0x6C, 0xDA, 0xE1, + 0x79, 0x7B, 0xEC, 0x7A, 0x69, 0xAD, 0xC9, 0x53, 0x1A, 0x80, 0xA9, 0xDB, + 0x36, 0x8A, 0x99, 0xB1, 0xEE, 0xDD, 0xFB, 0x67, 0x1F, 0xA0, 0x0D, 0xA1, + 0x1F, 0x14, 0x22, 0x68, 0x73, 0xD8, 0x54, 0x5D, 0x73, 0x7E, 0x36, 0x7D, + 0xF3, 0xFA, 0x22, 0xCF, 0xD9, 0x34, 0x8F, 0x39, 0xA7, 0x51, 0xCC, 0x38, + 0xA3, 0x5A, 0xE9, 0xE0, 0x5D, 0x96, 0x45, 0x79, 0x16, 0x29, 0x35, 0x08, + 0xCE, 0x3E, 0xBF, 0xB9, 0x2A, 0xB3, 0x24, 0x00, 0xD0, 0xC9, 0xEE, 0x50, + 0x57, 0x01, 0xC1, 0xD7, 0x57, 0x0B, 0xCE, 0x89, 0x52, 0x4E, 0x69, 0xAD, + 0x9D, 0xC3, 0x04, 0x63, 0x82, 0xEA, 0xB6, 0x8A, 0x22, 0x11, 0x20, 0x7D, + 0xF7, 0xE1, 0x01, 0xA0, 0x40, 0x31, 0x44, 0x04, 0x6D, 0xB6, 0x07, 0x29, + 0xA5, 0x31, 0x16, 0x20, 0xB4, 0xDF, 0xD7, 0x87, 0x63, 0x0B, 0x60, 0x38, + 0x35, 0xAD, 0x1C, 0xF4, 0xA9, 0x6A, 0x21, 0x04, 0x8B, 0xE5, 0xDC, 0x07, + 0x28, 0xA5, 0xE9, 0x87, 0x91, 0x12, 0xC8, 0x30, 0x56, 0x83, 0x12, 0x9C, + 0x3D, 0xEF, 0xAB, 0xE7, 0x7D, 0x15, 0x31, 0x0E, 0x01, 0x50, 0xDA, 0xC8, + 0x61, 0xD4, 0xDA, 0xAD, 0xD7, 0xC7, 0x88, 0xF3, 0xAE, 0x97, 0xC3, 0xA8, + 0xD4, 0xA8, 0xD7, 0xDB, 0x83, 0x31, 0x96, 0x32, 0xB6, 0xDD, 0x1F, 0xA7, + 0x65, 0x3C, 0x9D, 0x24, 0x75, 0xDD, 0x6D, 0xF6, 0x55, 0x00, 0xA1, 0xAE, + 0xDB, 0xD3, 0xA9, 0x19, 0x47, 0x43, 0x19, 0xC9, 0xF3, 0x98, 0x52, 0xE2, + 0xAD, 0x1B, 0xC6, 0x31, 0x89, 0x39, 0xE7, 0x10, 0x61, 0x40, 0x31, 0xC0, + 0x18, 0xB6, 0x8D, 0x9C, 0xE4, 0xE9, 0xD9, 0x6C, 0x8A, 0x00, 0xD9, 0x1E, + 0x3A, 0x1E, 0x47, 0x83, 0x32, 0x71, 0xC4, 0x66, 0x65, 0xBC, 0xDB, 0xAD, + 0x27, 0x79, 0x92, 0xA4, 0x45, 0x1C, 0xA5, 0x69, 0x1E, 0x07, 0x04, 0x86, + 0x71, 0x44, 0x14, 0x42, 0x02, 0x03, 0x85, 0xD6, 0x1B, 0x08, 0x5C, 0x26, + 0xF0, 0x74, 0xBE, 0xEA, 0x5B, 0xD0, 0x1C, 0x76, 0xBB, 0x43, 0x63, 0x3C, + 0x28, 0xF3, 0xC2, 0x07, 0xDF, 0x0F, 0xA3, 0xF7, 0xC0, 0x59, 0xA3, 0xB5, + 0xD1, 0x72, 0x7C, 0x73, 0xB1, 0x88, 0x63, 0x71, 0x6C, 0x46, 0x11, 0x45, + 0xE7, 0xCB, 0x22, 0x2F, 0xA2, 0xEA, 0xD4, 0x34, 0xA7, 0x2E, 0x8E, 0xC4, + 0xDD, 0x87, 0xCD, 0xC7, 0x12, 0x0C, 0x23, 0x70, 0xB5, 0x98, 0xFC, 0xFE, + 0x87, 0xDB, 0xF3, 0x45, 0x5E, 0xA4, 0xA1, 0x48, 0xA9, 0xD2, 0xEA, 0xED, + 0xFB, 0xC7, 0x2F, 0xDE, 0xBC, 0xEA, 0x07, 0xFB, 0xE1, 0x61, 0x33, 0xCD, + 0xA3, 0xAE, 0x97, 0xA7, 0xB6, 0xAF, 0x5A, 0x59, 0x77, 0x83, 0xF5, 0xF0, + 0xD4, 0x0C, 0x93, 0x32, 0x7B, 0xF7, 0xE3, 0x8F, 0xC7, 0xAA, 0xC9, 0x92, + 0x08, 0x23, 0xBF, 0xD9, 0xB7, 0x45, 0x11, 0x3F, 0xAE, 0xF7, 0xFD, 0xA8, + 0x6C, 0xF0, 0x1F, 0xEE, 0xD6, 0xC7, 0xBA, 0x9D, 0x4E, 0xA6, 0x52, 0x8E, + 0x55, 0xDD, 0x61, 0x4C, 0x20, 0xC0, 0x75, 0xD3, 0x8D, 0xC3, 0x70, 0xAC, + 0xBA, 0xDF, 0xBE, 0xBD, 0x3F, 0xB6, 0xA3, 0x76, 0x00, 0x01, 0xA8, 0x8C, + 0x97, 0xA3, 0x1E, 0x95, 0x81, 0x18, 0x13, 0x4C, 0x3E, 0x36, 0x99, 0xE2, + 0x28, 0xC2, 0x84, 0xF8, 0x10, 0xBA, 0xAE, 0xC3, 0x84, 0xA6, 0x91, 0xB8, + 0x79, 0x75, 0x9E, 0xA4, 0x3C, 0x8D, 0x85, 0xB1, 0xC1, 0x5A, 0x57, 0x57, + 0x7D, 0xDD, 0x0C, 0xDB, 0x5D, 0x3D, 0x2A, 0x03, 0x21, 0xD1, 0x06, 0xC4, + 0x51, 0xC4, 0x38, 0x9B, 0x94, 0x79, 0xC4, 0x45, 0x92, 0x88, 0x8F, 0x32, + 0x50, 0x22, 0xA8, 0x56, 0xC3, 0xA8, 0xC6, 0x32, 0xCD, 0xE6, 0x79, 0x66, + 0x47, 0x07, 0x01, 0x7D, 0x78, 0xDA, 0xDF, 0xDE, 0x6D, 0xDF, 0xBE, 0x7D, + 0x7C, 0x5A, 0x57, 0x9B, 0x6D, 0xF3, 0xBC, 0x3E, 0xC8, 0x41, 0x13, 0x4C, + 0xE3, 0x34, 0xD2, 0x4E, 0x3F, 0x6D, 0xF7, 0x4F, 0x87, 0xE3, 0xC3, 0xF3, + 0x4E, 0x2B, 0xCF, 0x45, 0x3C, 0x2A, 0xA0, 0x34, 0xAC, 0x9B, 0x31, 0x80, + 0xD0, 0x74, 0xB2, 0xC8, 0xA2, 0xE5, 0x7C, 0xBA, 0x9A, 0xCD, 0x1E, 0x37, + 0xFB, 0x34, 0x4B, 0x8E, 0x55, 0xDD, 0x76, 0xB2, 0xE9, 0x3B, 0xA9, 0x07, + 0x00, 0xBD, 0x1A, 0xAD, 0x36, 0x6E, 0xBD, 0x3D, 0x3E, 0xAF, 0xB7, 0x75, + 0x5D, 0x6D, 0x77, 0xBB, 0x3C, 0x86, 0xAF, 0x57, 0xE2, 0x7A, 0x9E, 0xCC, + 0x8A, 0x28, 0x8B, 0xA0, 0x20, 0x36, 0x63, 0x7D, 0x91, 0x38, 0x4A, 0x8C, + 0x20, 0x88, 0x04, 0x5D, 0xA4, 0x29, 0xC2, 0x54, 0x10, 0x20, 0xE5, 0xD0, + 0xB4, 0x7D, 0x70, 0xD6, 0x2A, 0xAD, 0x95, 0xF6, 0x21, 0x20, 0x04, 0xEB, + 0x41, 0x79, 0xEF, 0x39, 0xA5, 0x18, 0x42, 0x4A, 0x08, 0xC5, 0x88, 0x52, + 0x22, 0x28, 0xA5, 0x04, 0x07, 0x1F, 0xDC, 0x3F, 0x36, 0xB4, 0x7C, 0x00, + 0x30, 0x12, 0x82, 0x62, 0xFC, 0x31, 0xD3, 0xFB, 0xD1, 0x1B, 0x67, 0x94, + 0x7E, 0x44, 0x85, 0x29, 0x26, 0x11, 0x0E, 0xDA, 0xFA, 0x65, 0x6C, 0x63, + 0xFB, 0xDC, 0xD5, 0x1B, 0xE2, 0xE5, 0xA9, 0x3E, 0xAC, 0xB7, 0x3B, 0x37, + 0x36, 0x45, 0x0A, 0x38, 0x26, 0x00, 0x50, 0x88, 0x91, 0x73, 0x6E, 0xC9, + 0x5B, 0xB9, 0x7B, 0x7F, 0xDC, 0x3F, 0x3B, 0x53, 0xC9, 0xFE, 0x40, 0x42, + 0x1F, 0x0B, 0x06, 0x49, 0xDC, 0xF5, 0xC3, 0xC7, 0xD0, 0x17, 0x0C, 0x9A, + 0xA0, 0x10, 0x02, 0x34, 0x46, 0x07, 0x48, 0x30, 0x21, 0x3E, 0x00, 0x8C, + 0xA0, 0x36, 0xCE, 0x18, 0xF3, 0x91, 0xEC, 0x1F, 0x95, 0x82, 0xFF, 0xB8, + 0x85, 0x62, 0xAD, 0x36, 0x10, 0x04, 0x84, 0x21, 0x67, 0x1C, 0x13, 0x98, + 0xA6, 0x09, 0x41, 0x3E, 0x78, 0x03, 0x20, 0x87, 0x08, 0x7F, 0xE4, 0x53, + 0x84, 0xE0, 0xF0, 0x7F, 0xF8, 0xEF, 0xFE, 0x5B, 0xE5, 0x8D, 0x52, 0xC3, + 0x24, 0x8B, 0x47, 0x25, 0x47, 0x63, 0x01, 0xC0, 0xBD, 0xF6, 0xEB, 0xFD, + 0x71, 0x31, 0x9B, 0x86, 0xE0, 0x09, 0xC6, 0x99, 0x38, 0x63, 0xAE, 0xE5, + 0x04, 0xDA, 0xE0, 0x21, 0x05, 0x52, 0x39, 0x6D, 0x6D, 0xC4, 0x99, 0x1E, + 0xC7, 0xFB, 0xA7, 0xDD, 0x6C, 0x9A, 0x47, 0x82, 0x61, 0xE8, 0x29, 0xA3, + 0x20, 0x20, 0x35, 0x1A, 0x44, 0x10, 0x44, 0x50, 0xCA, 0x0E, 0x42, 0x22, + 0x84, 0x30, 0xD6, 0x57, 0x75, 0x0B, 0x20, 0x40, 0xD0, 0x77, 0xFD, 0x98, + 0x25, 0x62, 0x3E, 0x9B, 0xCC, 0xF2, 0x92, 0x40, 0xE2, 0xAC, 0x33, 0xC6, + 0x37, 0xED, 0x50, 0x77, 0x7D, 0x08, 0xFE, 0x6C, 0x35, 0x59, 0x2E, 0x52, + 0x1F, 0x3C, 0x20, 0x1F, 0x61, 0x44, 0x68, 0x6D, 0xF0, 0x21, 0xEC, 0x76, + 0xDD, 0xFE, 0xD8, 0x45, 0x31, 0x8F, 0x22, 0xDF, 0xB5, 0x1B, 0x84, 0xD8, + 0xCB, 0x8B, 0xCB, 0x24, 0x4E, 0x76, 0xFB, 0xE3, 0x20, 0xA5, 0x31, 0x76, + 0x3A, 0x9F, 0xF4, 0xBD, 0x9C, 0x97, 0xF9, 0x72, 0x31, 0x35, 0xDA, 0x20, + 0x4C, 0xBC, 0x07, 0x83, 0x1C, 0xD5, 0xA8, 0x37, 0xBB, 0x63, 0xD3, 0xB4, + 0xBB, 0xBA, 0xE1, 0x22, 0x9D, 0xCF, 0x26, 0x7D, 0xDF, 0x63, 0x84, 0x05, + 0xE7, 0x00, 0x06, 0x6B, 0x83, 0xB5, 0xCA, 0xD8, 0x71, 0x34, 0xA3, 0x1C, + 0x4C, 0x2B, 0xFD, 0xF3, 0xE6, 0xD4, 0xB6, 0xCD, 0x24, 0x4F, 0x30, 0x82, + 0x93, 0x32, 0xD9, 0x9F, 0xBA, 0x38, 0x12, 0x4A, 0x6B, 0x6D, 0xA0, 0x52, + 0x2A, 0x89, 0x28, 0x8F, 0x84, 0x73, 0xBE, 0xEB, 0xDB, 0x24, 0x89, 0xB2, + 0x38, 0x36, 0xD6, 0x31, 0x4E, 0x5E, 0x5D, 0xCD, 0xBE, 0xBA, 0xB9, 0x2C, + 0xB3, 0x54, 0x8E, 0x36, 0xCB, 0xB2, 0xBF, 0xFD, 0xD5, 0xF7, 0xFF, 0xEF, + 0x2F, 0xFF, 0x58, 0xE6, 0x99, 0xEC, 0x3A, 0xCE, 0x71, 0x59, 0x64, 0x67, + 0xCB, 0xD2, 0x07, 0x03, 0x3C, 0x22, 0x94, 0x6C, 0xF6, 0xD5, 0xFB, 0xDB, + 0xCD, 0xAC, 0x2C, 0x8B, 0x32, 0xFE, 0xE6, 0xEB, 0xEB, 0xFD, 0xFE, 0xF4, + 0xC9, 0xEB, 0x15, 0x46, 0x64, 0x7B, 0xE8, 0x5C, 0xF0, 0x83, 0x1C, 0x9D, + 0xF1, 0x08, 0xC1, 0xE3, 0xB1, 0x93, 0xFD, 0x38, 0x9D, 0xA4, 0x2C, 0xE2, + 0x4D, 0xDB, 0x51, 0xCC, 0xCE, 0x57, 0xB3, 0x58, 0x90, 0xAE, 0x6B, 0x04, + 0xA3, 0xAF, 0x5F, 0x5E, 0xE7, 0x91, 0x18, 0x07, 0xA9, 0x94, 0x69, 0x3B, + 0x87, 0x18, 0x6F, 0x47, 0x23, 0x47, 0x17, 0xC7, 0x8C, 0x11, 0xD3, 0xF7, + 0x43, 0x99, 0xAF, 0xAA, 0xBA, 0x7B, 0x77, 0x7B, 0xCF, 0x39, 0x2C, 0x4A, + 0x36, 0x9B, 0xA7, 0x08, 0x84, 0xFB, 0xDB, 0x0D, 0x0E, 0xE0, 0x9B, 0x2F, + 0x5F, 0x72, 0x46, 0xA1, 0x83, 0x12, 0x2D, 0x7E, 0xFB, 0xF7, 0xFF, 0x00, + 0xBD, 0xD2, 0x7A, 0xA8, 0x3B, 0xD9, 0x49, 0x95, 0xC4, 0xBC, 0x57, 0x03, + 0x22, 0x98, 0x73, 0xE6, 0x82, 0xFF, 0xF4, 0xD5, 0xD5, 0x3C, 0x9B, 0xFC, + 0x70, 0xBB, 0xA6, 0x11, 0x9E, 0xCE, 0xB2, 0x69, 0xCE, 0x13, 0x41, 0xAA, + 0xC3, 0xDE, 0xE8, 0x90, 0xC4, 0xF9, 0x20, 0xC7, 0x38, 0xE1, 0xDE, 0xD9, + 0x3C, 0x8F, 0x9D, 0x0E, 0x52, 0x5B, 0xA5, 0xDA, 0x61, 0xEC, 0x23, 0x11, + 0xBB, 0x00, 0xD3, 0x74, 0xB9, 0xDD, 0x56, 0xFD, 0xA0, 0x39, 0x23, 0x89, + 0x20, 0x84, 0xF1, 0xA7, 0x43, 0xD5, 0xCB, 0xE1, 0xF5, 0xD5, 0x4A, 0xD9, + 0xF0, 0xB8, 0x3E, 0x4E, 0xF2, 0x38, 0x4D, 0xE8, 0x87, 0x0F, 0x4F, 0x7D, + 0x2B, 0xCF, 0x96, 0xD9, 0xF9, 0xE5, 0xA2, 0xCC, 0xE3, 0xCD, 0xB6, 0x56, + 0x4A, 0xBF, 0xBD, 0x7B, 0xFE, 0xE3, 0xED, 0x61, 0x90, 0xB2, 0xCC, 0xF3, + 0x4F, 0x5E, 0x5E, 0xFC, 0xE1, 0xED, 0x8F, 0x82, 0x8B, 0x57, 0xD7, 0x97, + 0x6D, 0xDB, 0xBC, 0xBA, 0xBE, 0xE8, 0x07, 0x59, 0xF5, 0x5D, 0x9A, 0x24, + 0x04, 0xC1, 0x51, 0x0E, 0x69, 0x96, 0x9F, 0xAA, 0x7A, 0x18, 0xC7, 0x28, + 0x89, 0xBC, 0x0F, 0x82, 0x73, 0x08, 0xA0, 0x35, 0x56, 0x44, 0x62, 0x18, + 0x47, 0x4A, 0x70, 0x99, 0x67, 0xC0, 0xFB, 0x2C, 0x15, 0x01, 0xFA, 0x3F, + 0xBC, 0xBD, 0x3F, 0x5B, 0x4D, 0xE7, 0x93, 0xAC, 0x28, 0xF3, 0xB6, 0x92, + 0xC1, 0x78, 0x67, 0xB5, 0xB6, 0x61, 0x32, 0x99, 0xDD, 0x3E, 0x6E, 0x11, + 0x41, 0x8C, 0xA1, 0x58, 0x50, 0xA5, 0xF4, 0xEE, 0x70, 0xFA, 0xEC, 0xF3, + 0xAB, 0x2C, 0x13, 0xCE, 0x58, 0x0A, 0xB1, 0x56, 0x76, 0xB3, 0x3E, 0xF5, + 0xA3, 0x25, 0x94, 0xE9, 0x41, 0x21, 0x14, 0xEE, 0x9E, 0x9E, 0x3D, 0x46, + 0x84, 0xA0, 0x9F, 0xFD, 0xEC, 0x53, 0xCE, 0xB9, 0xA0, 0xCC, 0x58, 0xD7, + 0xF7, 0x63, 0x91, 0x27, 0x84, 0x11, 0x6B, 0x1D, 0x08, 0x10, 0x23, 0xE4, + 0x03, 0x50, 0x83, 0x3A, 0x9D, 0xDA, 0xAA, 0x92, 0x9C, 0xB1, 0xCF, 0x3E, + 0x39, 0x4F, 0xD3, 0x28, 0x78, 0x2F, 0xC7, 0x51, 0x19, 0x1D, 0x02, 0xDA, + 0x1E, 0xAA, 0xA6, 0xED, 0x8A, 0x49, 0xEE, 0x3C, 0x90, 0xF5, 0xF0, 0xFA, + 0xFA, 0xBC, 0x69, 0xDA, 0xAE, 0x6B, 0xE3, 0x58, 0xB4, 0xED, 0x48, 0x48, + 0x38, 0x5B, 0x64, 0x2F, 0xAF, 0xAE, 0x3A, 0x39, 0x4A, 0xE5, 0xB4, 0x0D, + 0xBF, 0xFE, 0xDD, 0xF7, 0xC3, 0x68, 0xFA, 0xB1, 0xBF, 0xBA, 0xBC, 0x7C, + 0xF5, 0xE2, 0x6B, 0xC1, 0xE2, 0x3C, 0x21, 0x52, 0x8E, 0x00, 0xD1, 0x38, + 0xCB, 0x29, 0x41, 0xBD, 0xD4, 0x0F, 0xBB, 0xAE, 0x6D, 0xBB, 0x56, 0x0E, + 0x0A, 0x30, 0x8C, 0x49, 0x44, 0x7C, 0x16, 0xC7, 0xDA, 0x58, 0x8A, 0xA0, + 0x10, 0x54, 0x1B, 0x0B, 0x11, 0x62, 0x8C, 0x1D, 0x1A, 0xB9, 0xAD, 0x3A, + 0x6D, 0x5D, 0x1E, 0x8B, 0x00, 0xE0, 0xC7, 0xA9, 0x45, 0xEF, 0x1C, 0xC4, + 0x84, 0x52, 0xE2, 0x3D, 0x30, 0x6A, 0x5C, 0x4C, 0x32, 0x4E, 0xD0, 0x38, + 0x0E, 0x08, 0xB9, 0x05, 0xEF, 0x7F, 0xF3, 0xBB, 0x5F, 0x2B, 0xE3, 0xF3, + 0x2C, 0x01, 0x08, 0x0C, 0xDA, 0x12, 0x4C, 0x21, 0x08, 0xD6, 0xD9, 0xE5, + 0xF9, 0x37, 0x1E, 0xA5, 0x2C, 0x48, 0x33, 0x1C, 0x1F, 0x1E, 0xEE, 0x94, + 0x73, 0x8B, 0xB3, 0xF2, 0x70, 0xAC, 0x19, 0x25, 0xD3, 0x32, 0x8B, 0xF2, + 0xAB, 0x6C, 0xF2, 0x7A, 0xD4, 0x1A, 0x43, 0xDF, 0x1C, 0x1F, 0x09, 0xCF, + 0x18, 0xF6, 0x45, 0x12, 0x46, 0x1B, 0x9C, 0x77, 0x30, 0x00, 0x4A, 0x79, + 0x3D, 0xD0, 0x46, 0x9A, 0x58, 0xB0, 0x51, 0x1B, 0xE7, 0x3D, 0x25, 0x14, + 0xF8, 0x40, 0x31, 0x54, 0xDA, 0xE6, 0x69, 0x64, 0x8C, 0x8E, 0x38, 0x81, + 0x98, 0x6A, 0x07, 0xED, 0x50, 0x19, 0x3B, 0x7A, 0x94, 0x32, 0x4A, 0x80, + 0x0F, 0x52, 0x9B, 0x28, 0x8A, 0xE0, 0xBF, 0xFD, 0xB7, 0xFF, 0xA6, 0xED, + 0x07, 0x04, 0xBD, 0x35, 0x23, 0x61, 0xF4, 0xC3, 0xFD, 0x73, 0x08, 0x80, + 0x31, 0xDE, 0x77, 0x5D, 0x14, 0xC7, 0x09, 0x67, 0x11, 0x67, 0x71, 0x7A, + 0x2E, 0x90, 0x62, 0x0C, 0x41, 0x10, 0x10, 0x25, 0x9D, 0xD4, 0x1E, 0xF8, + 0x2C, 0x89, 0xCE, 0xE7, 0x65, 0xC4, 0x89, 0x37, 0x61, 0x1C, 0x0D, 0xA5, + 0x08, 0x04, 0xF7, 0xE1, 0x6E, 0xC7, 0x38, 0x17, 0x82, 0x64, 0x69, 0x2C, + 0x07, 0x67, 0x9D, 0xC5, 0x08, 0x6A, 0xE7, 0x06, 0xA9, 0x8C, 0xB7, 0xCE, + 0x99, 0xA2, 0xC8, 0x9A, 0xAE, 0x4D, 0x85, 0xD8, 0xEC, 0x8E, 0x45, 0x9C, + 0x2E, 0xCA, 0x12, 0x11, 0x1A, 0x09, 0xF1, 0xC3, 0xFB, 0x87, 0xB2, 0x48, + 0x16, 0xF3, 0x6C, 0x90, 0xA3, 0x76, 0x76, 0x18, 0x75, 0x2F, 0x47, 0x00, + 0x91, 0x75, 0x7E, 0xB5, 0x28, 0x39, 0xA7, 0x5A, 0xF9, 0x0F, 0xF7, 0x7B, + 0xA5, 0x0D, 0x02, 0xA3, 0x1A, 0x87, 0x2C, 0xCF, 0x39, 0x67, 0x59, 0x12, + 0x89, 0x88, 0x00, 0x08, 0xE7, 0xAB, 0xB9, 0x51, 0x9A, 0x53, 0x0C, 0x03, + 0x30, 0xCE, 0x0F, 0x83, 0x72, 0xC6, 0x23, 0x8C, 0x38, 0x44, 0x93, 0x22, + 0x35, 0x56, 0x0F, 0x63, 0xD8, 0x9F, 0x7A, 0x08, 0x11, 0x8F, 0xC8, 0x74, + 0x99, 0x69, 0xA3, 0xA8, 0xA0, 0x9C, 0xF1, 0xF5, 0xE3, 0x6E, 0x50, 0xF2, + 0xF9, 0x79, 0x57, 0xD7, 0xBD, 0xB6, 0x76, 0x77, 0x18, 0x4E, 0xA7, 0x7E, + 0x39, 0x2F, 0xCE, 0x26, 0x31, 0xC2, 0xFE, 0x0F, 0x3F, 0x3E, 0x43, 0x84, + 0x94, 0x32, 0x94, 0x90, 0x34, 0x89, 0xB6, 0xFB, 0x26, 0xCB, 0x13, 0x35, + 0x2A, 0x84, 0x01, 0x65, 0x84, 0x22, 0xCA, 0x44, 0xF4, 0xF3, 0x9F, 0xBC, + 0xFE, 0xF6, 0xD3, 0x2B, 0x6D, 0x5D, 0xD3, 0x0F, 0xA3, 0xF1, 0x18, 0x63, + 0x04, 0x11, 0xA6, 0x28, 0x4F, 0x44, 0x77, 0x38, 0x06, 0x67, 0xA3, 0x38, + 0x3E, 0x36, 0x15, 0xC2, 0x10, 0x04, 0xC8, 0x04, 0x77, 0xDE, 0xEF, 0xD6, + 0xD5, 0x72, 0x39, 0x3D, 0x3F, 0x9F, 0x75, 0xAD, 0xD4, 0xCE, 0x4A, 0xA9, + 0xBB, 0x6E, 0x0C, 0x00, 0x88, 0x48, 0x20, 0x08, 0x97, 0x8B, 0x3C, 0x4B, + 0xC5, 0xA8, 0x4C, 0x55, 0xC9, 0xDD, 0xB1, 0x76, 0x2E, 0x18, 0xE7, 0x0F, + 0x4D, 0xB7, 0x9C, 0xCD, 0x31, 0x70, 0x0C, 0x81, 0x44, 0xF0, 0x17, 0x97, + 0x67, 0x79, 0xC4, 0x87, 0x41, 0x05, 0x1F, 0x08, 0x66, 0x84, 0xB1, 0x5E, + 0x8E, 0xB5, 0x54, 0x00, 0x82, 0xB3, 0x55, 0x01, 0x10, 0x7B, 0xDE, 0x54, + 0xEB, 0xCD, 0xF3, 0xDD, 0xDD, 0xE3, 0xE7, 0x6F, 0xCE, 0x31, 0x42, 0xDB, + 0xFD, 0xE9, 0x69, 0xB3, 0x07, 0x16, 0xBE, 0x7E, 0x71, 0x7E, 0xBE, 0x9A, + 0x55, 0x95, 0x44, 0x54, 0xC0, 0xE2, 0xEA, 0x6F, 0xFE, 0xFA, 0xFF, 0x18, + 0xC6, 0x61, 0x18, 0x95, 0x1C, 0x86, 0x7E, 0x18, 0x63, 0xCE, 0x13, 0xC1, + 0x85, 0x60, 0x75, 0xDB, 0xBD, 0x7A, 0xB9, 0xFA, 0xC9, 0x97, 0x5F, 0x10, + 0x2C, 0x3E, 0x3C, 0x6C, 0x10, 0x06, 0x10, 0xF8, 0xBC, 0x4C, 0xE6, 0x93, + 0x48, 0x10, 0x40, 0x39, 0x62, 0x3C, 0xEE, 0x8E, 0xBD, 0xB1, 0x0A, 0x01, + 0x47, 0x18, 0x6D, 0x6B, 0x19, 0x67, 0x02, 0x78, 0x9F, 0xA4, 0x59, 0x1A, + 0x73, 0x00, 0xE9, 0xED, 0xDD, 0xEE, 0xFE, 0xEE, 0x99, 0x47, 0x11, 0xA3, + 0x78, 0x31, 0x2B, 0xA7, 0xCB, 0xE5, 0xFF, 0xF3, 0x9F, 0x7E, 0xF3, 0x93, + 0xCF, 0x6F, 0xF4, 0xA8, 0x4E, 0xBD, 0xC6, 0x18, 0x9D, 0x4E, 0xD5, 0xA4, + 0xCC, 0x38, 0x85, 0x20, 0xD8, 0xBC, 0xC8, 0x7A, 0x39, 0xA6, 0x89, 0x40, + 0x00, 0x1C, 0xF7, 0xB5, 0x23, 0xEC, 0x3F, 0xFC, 0xDD, 0xEF, 0x8D, 0x75, + 0xB2, 0x1F, 0x97, 0xB3, 0x62, 0xB3, 0x3F, 0x71, 0x4A, 0x62, 0x21, 0xBC, + 0xB3, 0xDF, 0x7C, 0xF1, 0x29, 0xC2, 0x68, 0xBD, 0x3F, 0xCA, 0x61, 0xC8, + 0xB3, 0x58, 0x76, 0x12, 0x20, 0x32, 0x8C, 0x43, 0x1C, 0x89, 0x71, 0x1C, + 0x99, 0x10, 0x9C, 0x52, 0x3D, 0xEA, 0x61, 0x1C, 0x93, 0x24, 0x06, 0x10, + 0x02, 0x10, 0x9C, 0xB5, 0x91, 0xE0, 0x45, 0x96, 0x44, 0x82, 0x57, 0x4D, + 0xFF, 0xC7, 0xF7, 0xF7, 0xE7, 0x67, 0xB3, 0xC5, 0x24, 0xCF, 0x04, 0xDB, + 0x6D, 0x4E, 0x49, 0x12, 0x5D, 0x5E, 0xAC, 0x10, 0x66, 0xC6, 0x5A, 0x2E, + 0x68, 0x08, 0xD0, 0x78, 0x87, 0x60, 0xB8, 0xBB, 0x7F, 0x2E, 0xCB, 0x2C, + 0x89, 0x88, 0xD2, 0xCE, 0x59, 0x7B, 0xB1, 0x9A, 0xB4, 0x9D, 0xEC, 0xA4, + 0x8E, 0x05, 0x1B, 0x46, 0x73, 0xB1, 0x98, 0x3C, 0x3C, 0x6F, 0x44, 0xC4, + 0x10, 0x41, 0xD3, 0xD5, 0x44, 0x8F, 0xE6, 0x69, 0x7D, 0x34, 0xD6, 0xF7, + 0x83, 0x72, 0xD6, 0x15, 0x45, 0xE6, 0x21, 0xC8, 0xD3, 0x88, 0x53, 0x0A, + 0x21, 0x98, 0x4D, 0x53, 0xAD, 0xB5, 0xE9, 0xF4, 0xD0, 0x29, 0xA9, 0xBC, + 0xB6, 0xEA, 0x69, 0xBD, 0xA3, 0x14, 0x5F, 0x5F, 0x2E, 0xC6, 0xD1, 0x6C, + 0x0E, 0x95, 0x32, 0x16, 0x00, 0xAC, 0x4D, 0xC8, 0x12, 0x11, 0x45, 0xAC, + 0xA9, 0xFB, 0xF9, 0x24, 0x27, 0x18, 0x25, 0x11, 0xF7, 0xCE, 0x4C, 0xCA, + 0x14, 0x43, 0xD0, 0x0D, 0x46, 0xEB, 0xA1, 0x69, 0x1A, 0xE9, 0xE0, 0x74, + 0xB2, 0x18, 0x4C, 0x88, 0x23, 0xF2, 0xE2, 0x6C, 0x99, 0xC7, 0xC9, 0xB4, + 0xCC, 0x31, 0x62, 0x59, 0x9E, 0x01, 0x08, 0x46, 0xED, 0xAD, 0xB1, 0x45, + 0x91, 0xEF, 0x8E, 0xF5, 0xED, 0x87, 0x5B, 0x63, 0x41, 0xDD, 0x75, 0x08, + 0xE0, 0x97, 0xD7, 0x17, 0x45, 0xCA, 0x41, 0xF0, 0x79, 0x9E, 0xDC, 0x3F, + 0x1F, 0x31, 0x65, 0x87, 0xD6, 0x3E, 0x6E, 0x0E, 0xBB, 0x46, 0x05, 0xC4, + 0xCE, 0xA6, 0xF9, 0xB1, 0xE9, 0x3E, 0xE6, 0x54, 0x4F, 0xED, 0x18, 0x30, + 0x59, 0x4D, 0x53, 0x67, 0x6D, 0x44, 0xC2, 0x3C, 0x81, 0x8C, 0xD1, 0x34, + 0x42, 0x11, 0xB5, 0x3F, 0xFC, 0xF8, 0xE1, 0xFD, 0xC3, 0x6D, 0x91, 0x72, + 0xE7, 0x81, 0x09, 0xF8, 0xF9, 0xD0, 0xF8, 0x00, 0x9F, 0x37, 0x07, 0xAB, + 0xC7, 0x2F, 0x3E, 0xFB, 0xA2, 0x2C, 0xA6, 0xCF, 0xEB, 0x8D, 0xD6, 0x6E, + 0x18, 0x7A, 0x84, 0x01, 0xC6, 0x68, 0x34, 0x3A, 0x8A, 0x04, 0x84, 0x28, + 0xCB, 0xE2, 0xE5, 0xE2, 0x02, 0x89, 0x95, 0x53, 0x0D, 0x27, 0x8C, 0x53, + 0x63, 0xD5, 0x7A, 0xD4, 0xAA, 0x6E, 0x65, 0xDD, 0x0E, 0x08, 0x11, 0x00, + 0xA1, 0x88, 0x52, 0x11, 0x4D, 0x07, 0x30, 0x95, 0xCA, 0x25, 0x82, 0xC2, + 0x10, 0x38, 0x76, 0x49, 0x24, 0x66, 0x93, 0xE4, 0xE5, 0x12, 0x29, 0x47, + 0xA5, 0x94, 0x7F, 0xF8, 0xE1, 0x51, 0x6A, 0x5A, 0xC4, 0x16, 0xD2, 0x44, + 0x24, 0xF3, 0x5E, 0x0E, 0x75, 0x3B, 0x44, 0x51, 0x94, 0x46, 0x18, 0xFE, + 0xFC, 0xCF, 0xBF, 0x0B, 0x08, 0x75, 0x4D, 0x13, 0x51, 0x2A, 0x65, 0x27, + 0xE5, 0xB8, 0x9C, 0xCF, 0x23, 0xC1, 0x11, 0xC6, 0x56, 0x99, 0xB3, 0xC5, + 0x12, 0x63, 0x38, 0x5A, 0xBC, 0x9C, 0x26, 0x71, 0x44, 0x95, 0xD3, 0x7F, + 0xFC, 0x70, 0x8F, 0x09, 0xD5, 0x5A, 0x7E, 0x72, 0x7D, 0x99, 0xF2, 0x58, + 0x49, 0xA3, 0xAD, 0x3F, 0xD6, 0xBD, 0x10, 0xFC, 0x6C, 0x9E, 0xA7, 0x82, + 0x6A, 0x67, 0x05, 0xA7, 0xC6, 0xB8, 0xAA, 0x91, 0x75, 0xD3, 0xED, 0x4F, + 0xAD, 0xB5, 0xDE, 0x68, 0x7B, 0xAC, 0x4F, 0x3C, 0x22, 0xDA, 0x29, 0x84, + 0xE1, 0x2C, 0x4F, 0xA6, 0x93, 0xC9, 0x17, 0xAF, 0x5E, 0x7B, 0xFF, 0x51, + 0xE2, 0xB5, 0x00, 0x05, 0x11, 0x63, 0x6B, 0x7D, 0x7D, 0xEA, 0x8A, 0x22, + 0xB2, 0xC6, 0x40, 0x80, 0x9C, 0x0F, 0x75, 0x3D, 0x54, 0xD5, 0xE9, 0xEA, + 0x72, 0x9E, 0xE5, 0x93, 0x87, 0x75, 0xF5, 0xBC, 0x3E, 0x8E, 0xCA, 0x6E, + 0x77, 0xFB, 0xB3, 0x59, 0xF1, 0xF5, 0xD7, 0xAF, 0xE3, 0x9C, 0x4B, 0xA5, + 0xFB, 0xD1, 0x38, 0xEB, 0x77, 0x9B, 0x0A, 0x41, 0xA0, 0xB4, 0xF5, 0xCE, + 0xD6, 0x4D, 0xAB, 0x46, 0x53, 0x94, 0x79, 0x19, 0x47, 0xCB, 0x79, 0x91, + 0xA5, 0x11, 0x40, 0x60, 0x5E, 0x66, 0xD3, 0x49, 0xDA, 0xF6, 0x32, 0x4E, + 0xB9, 0xD4, 0xBA, 0xEE, 0x47, 0x17, 0x42, 0x00, 0xC8, 0x18, 0x57, 0xD5, + 0x75, 0xCA, 0x10, 0xF4, 0xAE, 0xEB, 0x47, 0x88, 0x70, 0x59, 0x64, 0x59, + 0xC4, 0x21, 0x44, 0x4D, 0x3B, 0xF4, 0xDD, 0x58, 0xD7, 0x1D, 0x61, 0xE8, + 0xFD, 0xFB, 0x35, 0xC1, 0x34, 0xCF, 0xA3, 0x5F, 0xFF, 0xFE, 0xC7, 0x6E, + 0x50, 0x6D, 0x37, 0x2C, 0x17, 0x53, 0x41, 0xE9, 0xBF, 0xF8, 0x8B, 0x3F, + 0x01, 0x1E, 0xF4, 0x5A, 0x59, 0x08, 0x9A, 0xA6, 0x1F, 0x07, 0xB9, 0x9C, + 0x15, 0x79, 0x1E, 0x41, 0xEB, 0x4F, 0xFB, 0x06, 0x11, 0xB4, 0x3B, 0xD6, + 0x88, 0xC0, 0x8F, 0xAE, 0x06, 0x40, 0x70, 0x1C, 0x4C, 0x91, 0x46, 0x8C, + 0x33, 0xA3, 0x20, 0x21, 0x42, 0x8E, 0x63, 0x24, 0x20, 0x82, 0x20, 0x00, + 0xD8, 0x4B, 0x13, 0x00, 0x8A, 0x04, 0xB3, 0xD6, 0x2D, 0x96, 0xF9, 0x64, + 0x92, 0xF4, 0xBD, 0xDC, 0x3C, 0xEF, 0x43, 0x40, 0x1E, 0xC0, 0xAB, 0xC5, + 0xA2, 0x48, 0x53, 0x6B, 0xEC, 0xD9, 0xBC, 0x48, 0x23, 0xB1, 0x3E, 0x54, + 0xAD, 0x54, 0x21, 0xF8, 0x4E, 0x0E, 0x49, 0x92, 0x5A, 0xEF, 0x86, 0xC1, + 0x18, 0xEF, 0xAE, 0x2F, 0x66, 0x45, 0xC6, 0x29, 0x05, 0xCF, 0xEB, 0xED, + 0xDB, 0xB7, 0x77, 0x10, 0x82, 0xB6, 0x55, 0xCA, 0x04, 0x00, 0xDD, 0x77, + 0x5F, 0x7E, 0x29, 0x47, 0x93, 0xE7, 0xB9, 0xD1, 0x83, 0x34, 0xCE, 0x8B, + 0xE9, 0xFF, 0xFE, 0xBF, 0xFD, 0xAF, 0x55, 0x2B, 0xBF, 0xFC, 0xE4, 0x05, + 0x41, 0x3E, 0x8D, 0x23, 0x63, 0xDD, 0x38, 0x8E, 0x1E, 0x00, 0xCA, 0xC9, + 0x67, 0x37, 0xAF, 0x8C, 0x01, 0x94, 0x26, 0x8D, 0x6C, 0x29, 0xA7, 0x5A, + 0x83, 0x32, 0xA7, 0x67, 0x8B, 0xD4, 0x6A, 0xED, 0xAD, 0x09, 0xD8, 0x1F, + 0xAB, 0x8A, 0x00, 0x7F, 0xB6, 0x98, 0xFE, 0xF0, 0xE1, 0xF6, 0xEA, 0xEC, + 0x62, 0x94, 0x6A, 0x75, 0x3E, 0xDF, 0x1D, 0x76, 0xF3, 0xE5, 0x59, 0x92, + 0x65, 0x77, 0x3F, 0x3E, 0x8E, 0xBD, 0x3D, 0x54, 0x83, 0x20, 0xFE, 0xE5, + 0xE5, 0xE5, 0xDB, 0xA7, 0x6D, 0x37, 0xA8, 0x7F, 0xF7, 0xDF, 0xFC, 0xCB, + 0x7F, 0x78, 0xFB, 0x50, 0x4B, 0xFD, 0xB4, 0x5E, 0x73, 0x4E, 0x31, 0x46, + 0x22, 0xA2, 0x51, 0x44, 0x8C, 0xF6, 0x3F, 0xBE, 0xDF, 0xBC, 0x38, 0x9F, + 0xA5, 0x82, 0x22, 0x42, 0xF7, 0x8D, 0xB4, 0xDE, 0x88, 0x48, 0x74, 0xED, + 0x30, 0xC9, 0x62, 0x42, 0xC9, 0xEF, 0xFE, 0xF0, 0x63, 0xDD, 0x4A, 0x35, + 0xA8, 0xD5, 0x7C, 0x3A, 0x6A, 0x9D, 0x97, 0x19, 0x40, 0xC8, 0x1A, 0x35, + 0xB6, 0xF2, 0xD4, 0x74, 0x88, 0xE0, 0x8F, 0x5E, 0xD7, 0xD9, 0xE5, 0x2A, + 0x68, 0xCB, 0x29, 0x0F, 0x20, 0x08, 0x46, 0xE5, 0x30, 0x0E, 0x6A, 0x0C, + 0xC1, 0x73, 0xC6, 0x28, 0xC6, 0x93, 0x3C, 0x4B, 0xD3, 0xE4, 0x97, 0xBF, + 0x7B, 0xDB, 0x0F, 0xC3, 0x6A, 0x96, 0xBF, 0xB9, 0xBA, 0x2A, 0xF3, 0x82, + 0x09, 0x5A, 0xB7, 0xD2, 0x03, 0x50, 0xB7, 0x52, 0x1B, 0x97, 0xA5, 0x09, + 0x41, 0x60, 0x92, 0x27, 0x93, 0x3C, 0xF1, 0x2E, 0x68, 0x2D, 0xBB, 0x5E, + 0x11, 0x0C, 0xD3, 0x94, 0x6B, 0xE7, 0x42, 0x08, 0xC6, 0x2A, 0xC6, 0x85, + 0x1A, 0xEC, 0xD9, 0xA2, 0x70, 0xC1, 0x41, 0x8A, 0xBA, 0x76, 0x30, 0xC6, + 0x1A, 0x00, 0x1E, 0x9E, 0x77, 0xDA, 0x85, 0xBE, 0x57, 0xCF, 0x0F, 0xDB, + 0x72, 0x9A, 0x62, 0x8C, 0x27, 0x65, 0xDE, 0x37, 0xFD, 0x7C, 0x5E, 0x9E, + 0xAF, 0x26, 0xC1, 0x5A, 0x02, 0xE0, 0xD5, 0xF9, 0xEA, 0xFD, 0xE3, 0xA6, + 0xEB, 0xCD, 0x38, 0x0C, 0x94, 0x40, 0x42, 0x48, 0x39, 0xCD, 0x95, 0x55, + 0xE3, 0x68, 0xB4, 0xF6, 0x6D, 0x37, 0xEC, 0x76, 0x95, 0xD2, 0xA6, 0x97, + 0xEA, 0x93, 0x97, 0x57, 0xCE, 0x99, 0xAB, 0xB3, 0xF2, 0xE5, 0xF9, 0x2C, + 0x8E, 0xE2, 0x63, 0xAD, 0x8C, 0x1E, 0x00, 0xC2, 0x71, 0x1C, 0xE5, 0xF9, + 0xE4, 0x69, 0xB7, 0xF5, 0xCE, 0x7A, 0x67, 0xC7, 0x71, 0xE4, 0x9C, 0x97, + 0x65, 0xAE, 0x75, 0xA8, 0xAA, 0xFE, 0x6E, 0x53, 0x03, 0x80, 0x6E, 0xCE, + 0x8B, 0xCD, 0xF1, 0x04, 0x00, 0xB8, 0x5F, 0x1F, 0x3E, 0xDC, 0xDF, 0x7E, + 0xFB, 0xC5, 0xAB, 0xFF, 0xF2, 0xBB, 0x2F, 0x18, 0x65, 0xCA, 0xFB, 0xE5, + 0x7C, 0x7E, 0xAC, 0xE5, 0xBF, 0xFF, 0xD5, 0xAF, 0xD3, 0x28, 0xCA, 0xCA, + 0x73, 0x07, 0x85, 0x96, 0x4D, 0x96, 0xE5, 0xB5, 0xB4, 0x5A, 0xF6, 0x7E, + 0xD8, 0x13, 0x3E, 0x29, 0x17, 0xD7, 0x2C, 0xF4, 0x18, 0x0E, 0x84, 0x38, + 0x63, 0xB4, 0xE0, 0x68, 0x51, 0xE4, 0xC7, 0xBA, 0x73, 0xC1, 0x6F, 0x0F, + 0xDB, 0xBE, 0xEB, 0x76, 0xA7, 0xAE, 0x53, 0x5E, 0x3B, 0xF8, 0x31, 0x74, + 0xCD, 0x29, 0x9D, 0x4E, 0xCB, 0x32, 0xCF, 0xEE, 0xEF, 0x77, 0xFD, 0x30, + 0xA4, 0x49, 0x32, 0xC9, 0xF3, 0xE7, 0xF5, 0xC6, 0x03, 0x5F, 0x4C, 0x8A, + 0xC3, 0xA1, 0xC9, 0x52, 0x8A, 0x80, 0xFE, 0x67, 0xFF, 0xE4, 0xAF, 0xBC, + 0xB1, 0x69, 0x12, 0x3F, 0x3D, 0xBD, 0xFF, 0xF0, 0xF0, 0xB0, 0x3B, 0xF6, + 0x10, 0xA1, 0x00, 0x61, 0xDF, 0x8F, 0x59, 0x9E, 0x83, 0xE0, 0x03, 0x08, + 0x6F, 0x3E, 0xFD, 0xFA, 0xEA, 0xE2, 0xE6, 0xD0, 0x18, 0x02, 0xF5, 0x79, + 0xA1, 0xDE, 0x5C, 0x4F, 0x04, 0xB1, 0xCF, 0xBB, 0xE7, 0xBA, 0xF7, 0x88, + 0x24, 0xA3, 0xFA, 0x98, 0x92, 0xF0, 0x67, 0x17, 0x6F, 0xA4, 0x54, 0x3F, + 0xDC, 0x77, 0x82, 0xF3, 0x17, 0xAB, 0xB2, 0xEF, 0x3B, 0xF8, 0xAF, 0xFF, + 0xD5, 0x3F, 0xDF, 0x57, 0x35, 0x84, 0x62, 0x35, 0xC9, 0xEB, 0xC3, 0x36, + 0x8D, 0x93, 0x3C, 0x2F, 0x10, 0x0C, 0x08, 0x41, 0xEF, 0x82, 0x94, 0xE3, + 0x74, 0xB9, 0xC2, 0xF1, 0x74, 0x38, 0xBC, 0x2F, 0xF2, 0x5C, 0x3B, 0xB3, + 0x3D, 0xEC, 0x57, 0xCB, 0x99, 0x77, 0xC8, 0x68, 0xD5, 0x36, 0x03, 0xC5, + 0xEC, 0xD4, 0xF4, 0x65, 0x91, 0x41, 0x84, 0x47, 0x35, 0x2A, 0x35, 0x00, + 0xE0, 0x05, 0xA7, 0x59, 0x1C, 0x61, 0x04, 0xCE, 0x57, 0xB3, 0xE7, 0x6D, + 0x75, 0xF7, 0xB8, 0xF5, 0x0E, 0x3C, 0x6D, 0xD7, 0x69, 0x1A, 0x13, 0xC6, + 0xB2, 0x84, 0x7C, 0xF6, 0xE2, 0x7C, 0x3E, 0x5B, 0x1A, 0x1B, 0x92, 0x18, + 0x3A, 0xD5, 0x31, 0x2E, 0x06, 0xD5, 0xEF, 0x8E, 0x2D, 0x04, 0x64, 0x3E, + 0xCB, 0xD3, 0x88, 0x8F, 0x63, 0x17, 0x8B, 0xD8, 0x7A, 0xD4, 0xF7, 0x6D, + 0xD7, 0x55, 0xCB, 0xD5, 0x42, 0x69, 0x56, 0xB7, 0x3D, 0x40, 0xE4, 0x57, + 0xBF, 0x7B, 0x9C, 0x96, 0xF1, 0xA7, 0xAF, 0xA7, 0x88, 0x60, 0xA9, 0x74, + 0xD5, 0xEB, 0xCD, 0xB6, 0xF2, 0xC1, 0xCB, 0x5E, 0x39, 0xEB, 0x02, 0x08, + 0x38, 0x84, 0xBB, 0xFB, 0x35, 0xA6, 0x2C, 0x89, 0xC5, 0xC5, 0x62, 0x4A, + 0x30, 0xF6, 0xC1, 0x71, 0x4E, 0x08, 0xC2, 0x1E, 0x02, 0x67, 0xFC, 0x72, + 0x91, 0x8B, 0x48, 0x4C, 0xCB, 0xD4, 0x79, 0x3F, 0x2A, 0x87, 0x00, 0x98, + 0xCD, 0x12, 0xCE, 0x91, 0x1A, 0x95, 0xD1, 0xD6, 0x58, 0xB3, 0xDE, 0xD6, + 0x75, 0x33, 0x14, 0x79, 0xEC, 0x8C, 0x67, 0x94, 0x26, 0x82, 0xBB, 0xE0, + 0xD2, 0x88, 0x71, 0xC2, 0xE3, 0x98, 0x01, 0xE8, 0xD6, 0xFB, 0xA3, 0x86, + 0x50, 0xDB, 0x81, 0x63, 0x42, 0x80, 0x30, 0x2E, 0x78, 0x08, 0x7A, 0xA9, + 0xFA, 0x6E, 0xE0, 0x14, 0x9F, 0xAD, 0xCA, 0xAA, 0x3A, 0xC4, 0x54, 0x9C, + 0x2A, 0xE9, 0x82, 0xEB, 0x86, 0x91, 0x30, 0xB4, 0xDB, 0x57, 0x8C, 0xB3, + 0xAE, 0x1B, 0xBC, 0x87, 0x00, 0x02, 0x3D, 0x9A, 0x53, 0xAD, 0x56, 0xAB, + 0xE5, 0x97, 0x9F, 0x9E, 0x71, 0x0E, 0x08, 0x42, 0x94, 0xD2, 0xB7, 0x3F, + 0xEE, 0x7E, 0x78, 0xFF, 0x94, 0x25, 0xF1, 0x7C, 0x5A, 0x50, 0x4A, 0x29, + 0x85, 0xDF, 0x7D, 0xF3, 0xFA, 0x74, 0xAC, 0x31, 0xC4, 0xB3, 0xB2, 0x04, + 0x1E, 0xBC, 0xFD, 0xF0, 0x94, 0x46, 0x7C, 0x3E, 0x2D, 0x0E, 0x75, 0xD7, + 0xC9, 0xB1, 0x69, 0x65, 0x40, 0xC8, 0x79, 0x87, 0x10, 0xE9, 0xE4, 0xB8, + 0x39, 0xD4, 0x65, 0x1E, 0xE7, 0x31, 0x8D, 0x18, 0x7A, 0xF3, 0xFA, 0xE2, + 0x70, 0x38, 0xFD, 0xDD, 0x6F, 0xBE, 0xE7, 0x04, 0x7F, 0x76, 0xF3, 0xE2, + 0xD8, 0x0C, 0x87, 0x53, 0xF5, 0x27, 0x5F, 0x7D, 0x3D, 0x9B, 0x09, 0x44, + 0xF0, 0xED, 0x87, 0x47, 0x91, 0x4E, 0x0C, 0x2D, 0x86, 0xEA, 0x07, 0xAD, + 0x34, 0xF6, 0x70, 0x3E, 0x2F, 0x39, 0x27, 0xCE, 0x7B, 0x63, 0x8C, 0x54, + 0xF6, 0xE1, 0xF9, 0x84, 0x00, 0x79, 0x71, 0x75, 0xF1, 0xF8, 0xB4, 0x8B, + 0x12, 0x06, 0xA9, 0x30, 0x46, 0x5D, 0x9C, 0xE7, 0x0C, 0xB3, 0x51, 0xE9, + 0xE0, 0x40, 0x12, 0xF3, 0x77, 0xEF, 0x7F, 0x18, 0x86, 0x66, 0x39, 0x9F, + 0x18, 0xA3, 0xE7, 0xF9, 0x0C, 0x7B, 0x18, 0xA0, 0xA9, 0x95, 0xE3, 0x31, + 0x4F, 0xA2, 0x08, 0x04, 0x30, 0x99, 0x2D, 0xF7, 0xBB, 0xAD, 0x6E, 0x87, + 0x71, 0xF4, 0x3F, 0xDC, 0x6F, 0x7E, 0xF6, 0xED, 0x57, 0x65, 0x9E, 0x9E, + 0xBA, 0xF1, 0x87, 0xBB, 0xC7, 0xC3, 0xE1, 0xB4, 0x9C, 0x97, 0x91, 0x40, + 0xCE, 0x39, 0x84, 0x09, 0x67, 0x7C, 0x1C, 0xE5, 0xBC, 0xC8, 0x28, 0x66, + 0xCD, 0xA0, 0x87, 0x71, 0x7C, 0xFF, 0xB0, 0xC9, 0x92, 0xF4, 0xE7, 0xDF, + 0x7E, 0x4A, 0x08, 0xEE, 0x65, 0x1F, 0x20, 0x54, 0xC6, 0x7D, 0x78, 0xFF, + 0x78, 0x38, 0x55, 0x87, 0xAA, 0xBD, 0xBA, 0x98, 0x23, 0x84, 0xB5, 0x36, + 0xC0, 0xBA, 0x43, 0xD5, 0x5A, 0xEF, 0x28, 0xA7, 0xD3, 0xF9, 0x04, 0x04, + 0x40, 0x00, 0xEC, 0x5A, 0x99, 0xC6, 0x11, 0x44, 0xB0, 0x69, 0xFA, 0x32, + 0x4F, 0x95, 0xB5, 0x1E, 0x06, 0x8A, 0xB0, 0x77, 0xBE, 0xC8, 0xD3, 0x41, + 0xE9, 0x87, 0xE7, 0xFD, 0x27, 0xD7, 0x97, 0xCB, 0xE9, 0x74, 0x7B, 0x3C, + 0x26, 0x59, 0xFC, 0xB4, 0x39, 0x3D, 0xAE, 0xF7, 0x08, 0x63, 0xA5, 0xB5, + 0xE0, 0x3C, 0x13, 0xEC, 0xAB, 0x37, 0xAF, 0xBD, 0xD3, 0x6D, 0xD7, 0x0D, + 0xE3, 0x18, 0x3C, 0x40, 0x18, 0x9D, 0x9F, 0xCD, 0x9A, 0x56, 0x17, 0x45, + 0x01, 0x83, 0xF4, 0xC1, 0x37, 0x9D, 0x86, 0x88, 0x58, 0xAB, 0xCE, 0x2F, + 0xA7, 0xA7, 0x7D, 0x17, 0x82, 0xCF, 0xCA, 0xB8, 0x6E, 0x7A, 0x00, 0xF1, + 0xB1, 0x6E, 0xAB, 0x53, 0x33, 0x99, 0xE6, 0xD6, 0x39, 0x6F, 0x0C, 0x67, + 0x2C, 0x12, 0x22, 0x89, 0x19, 0x82, 0x70, 0x90, 0xEA, 0xFC, 0x6C, 0x56, + 0xE6, 0xC9, 0x72, 0x36, 0x7B, 0x7F, 0xF7, 0x8C, 0x02, 0x78, 0x71, 0x7D, + 0xEE, 0x80, 0xD5, 0x5A, 0xF5, 0xD2, 0x3A, 0xEB, 0xDF, 0xBE, 0xBB, 0xD7, + 0xD6, 0x0E, 0xC3, 0xF8, 0xE5, 0xA7, 0xAF, 0xE2, 0x34, 0x92, 0x43, 0x6D, + 0x95, 0xEE, 0x3A, 0x35, 0x2B, 0x8A, 0x34, 0x11, 0x71, 0x92, 0x9F, 0x9D, + 0x9D, 0x99, 0x51, 0xFE, 0xF1, 0xDD, 0xED, 0xDB, 0x0F, 0xCF, 0x75, 0x3B, + 0x70, 0x8E, 0x09, 0x46, 0x21, 0xF8, 0x2C, 0x8F, 0x04, 0xE3, 0x82, 0xC7, + 0x98, 0xD0, 0xF9, 0x2C, 0x97, 0x7D, 0xF7, 0xE3, 0xED, 0xD3, 0x30, 0xBA, + 0xCD, 0xA1, 0x69, 0x46, 0xF5, 0xE9, 0x8B, 0xE9, 0xD7, 0x37, 0x17, 0x4F, + 0xEB, 0x43, 0x51, 0x14, 0x9D, 0xC6, 0xFB, 0xAA, 0x6D, 0xBA, 0xF5, 0x72, + 0x96, 0x46, 0xF9, 0x05, 0x01, 0x08, 0x3B, 0x9B, 0x67, 0x09, 0xA6, 0xCC, + 0x5B, 0xD3, 0xB5, 0xBD, 0xB1, 0x76, 0x77, 0x38, 0x5A, 0x63, 0x8B, 0x34, + 0x72, 0xD8, 0x2C, 0xA7, 0xD9, 0x17, 0x37, 0x57, 0xF7, 0x8F, 0x07, 0x6D, + 0x00, 0x67, 0xA4, 0xEB, 0xFB, 0x6E, 0x30, 0x87, 0xA6, 0xB3, 0xC6, 0x49, + 0xA5, 0xFB, 0x61, 0x4C, 0x22, 0x5E, 0xD5, 0xF5, 0xD9, 0xF9, 0x82, 0x50, + 0x7C, 0x7F, 0xB7, 0x57, 0xC6, 0x10, 0x88, 0x20, 0x80, 0xC6, 0x3A, 0xCE, + 0x99, 0x73, 0x0E, 0x53, 0x86, 0x91, 0x4F, 0x13, 0xF1, 0xE6, 0x93, 0x4F, + 0x57, 0x93, 0x62, 0x94, 0xF5, 0x8F, 0xB7, 0xB7, 0x77, 0xCF, 0xA7, 0xBA, + 0x1B, 0xFA, 0x5E, 0x2E, 0x66, 0xE5, 0xC5, 0x72, 0xF1, 0xE3, 0xC3, 0x96, + 0x32, 0xE2, 0x43, 0xF8, 0xE4, 0xD5, 0xD5, 0x5F, 0xFE, 0xFC, 0x2F, 0x18, + 0xA5, 0xCB, 0x69, 0xC6, 0x51, 0x7D, 0x7B, 0xFB, 0xF6, 0xC7, 0x0F, 0xDB, + 0xE7, 0xE3, 0x09, 0x11, 0x5A, 0xE6, 0x2B, 0x88, 0x08, 0x00, 0x56, 0xC4, + 0xB1, 0x1C, 0xD5, 0x72, 0x36, 0xE7, 0xAC, 0xB0, 0x66, 0x64, 0x04, 0x17, + 0x69, 0x0E, 0xFF, 0xEC, 0xBB, 0x6F, 0xF6, 0x75, 0xFB, 0xC5, 0x17, 0xDF, + 0xCA, 0xE3, 0x63, 0x96, 0xA4, 0xC1, 0xFB, 0x24, 0x4B, 0x9F, 0x9E, 0x37, + 0x54, 0x90, 0xA7, 0xA7, 0xCD, 0xAB, 0xEB, 0x97, 0x17, 0xAF, 0xBF, 0x7A, + 0xF7, 0xF6, 0x1F, 0xBC, 0x96, 0x9C, 0xD2, 0x49, 0x11, 0x71, 0x8A, 0x3C, + 0x20, 0xCA, 0x20, 0xE7, 0xF5, 0xE5, 0x2A, 0x47, 0x18, 0xED, 0x0E, 0x9D, + 0x32, 0x6E, 0x7F, 0xEC, 0x5C, 0xD0, 0x71, 0x4C, 0x26, 0x93, 0x7C, 0xBB, + 0x6F, 0x82, 0x0B, 0x4D, 0xDD, 0x08, 0xCE, 0xBE, 0x78, 0xFD, 0x8A, 0x53, + 0xF2, 0x9B, 0x3F, 0xDE, 0x3E, 0x6E, 0xF7, 0xFF, 0xF4, 0x4F, 0xBF, 0xBD, + 0xBA, 0x58, 0x4C, 0x33, 0x66, 0xCD, 0xB0, 0x3F, 0x9E, 0x1C, 0x40, 0x65, + 0x59, 0x3A, 0x6B, 0x39, 0x47, 0x4A, 0x8F, 0x01, 0x20, 0x18, 0x2C, 0x0C, + 0xEE, 0x74, 0xAC, 0x43, 0x50, 0x45, 0x9E, 0xD9, 0x80, 0xDA, 0xEE, 0x84, + 0x11, 0x9C, 0xCF, 0x2F, 0x7B, 0xA9, 0x95, 0xF6, 0x71, 0x1A, 0x65, 0x19, + 0x2F, 0x52, 0x61, 0x1C, 0xF8, 0xFE, 0xED, 0x43, 0xDF, 0xEB, 0x40, 0xC9, + 0xD3, 0xFA, 0xB8, 0xDB, 0x1E, 0x03, 0xC0, 0x22, 0x8A, 0x40, 0x70, 0x6A, + 0x1C, 0x9E, 0xD6, 0x07, 0x8C, 0xA8, 0x52, 0xF2, 0xE5, 0xC5, 0xD9, 0xD5, + 0xD5, 0xC2, 0x5A, 0x2B, 0x38, 0x1D, 0xB5, 0xED, 0xFA, 0x11, 0x00, 0xE0, + 0xAC, 0x7B, 0x79, 0x79, 0xB1, 0x98, 0x4D, 0x0F, 0xC7, 0x26, 0xCB, 0x73, + 0x82, 0x3C, 0x46, 0xA0, 0xEA, 0x46, 0x65, 0xCC, 0xD9, 0x22, 0x67, 0x18, + 0x40, 0x6F, 0x76, 0xFB, 0x2A, 0xC9, 0x84, 0xD3, 0x8E, 0x11, 0x9A, 0xA6, + 0xD1, 0x30, 0x8C, 0x8B, 0x45, 0x5E, 0x35, 0xBD, 0x1C, 0x4D, 0x92, 0x44, + 0x65, 0x11, 0x11, 0x81, 0xAB, 0xAE, 0x0F, 0x01, 0x74, 0x8D, 0x7C, 0x7C, + 0xD8, 0x2B, 0xE3, 0xF2, 0x2C, 0x61, 0x18, 0xCD, 0xCA, 0x5C, 0x59, 0xD7, + 0x75, 0xBD, 0xEC, 0x7A, 0x29, 0xC7, 0xBA, 0xED, 0xE2, 0x38, 0x3A, 0xD5, + 0x6D, 0xD5, 0xF6, 0x1F, 0x43, 0xA7, 0x04, 0x23, 0xCE, 0xC9, 0xC5, 0x22, + 0xFF, 0xE4, 0xF5, 0x3C, 0x4E, 0xE2, 0xF9, 0x62, 0xB1, 0x3B, 0xD5, 0x4F, + 0x9B, 0x13, 0x04, 0x70, 0x31, 0x9D, 0xFD, 0xF2, 0x57, 0xEF, 0x8C, 0x72, + 0x93, 0x2C, 0x0D, 0x00, 0xDC, 0x5C, 0x2F, 0xCF, 0x17, 0x93, 0xC3, 0xA9, + 0xAD, 0x3B, 0x29, 0xB8, 0x90, 0x83, 0xF5, 0x21, 0x24, 0x82, 0x75, 0x52, + 0x1E, 0x4E, 0xAD, 0x07, 0x21, 0x00, 0xF8, 0x51, 0x24, 0xAE, 0xEA, 0xEE, + 0xF6, 0x71, 0xF3, 0xE6, 0xE6, 0x7A, 0x5E, 0xC6, 0x4D, 0xDD, 0x31, 0x42, + 0x26, 0x79, 0x64, 0x8C, 0x9D, 0x96, 0xD9, 0xBC, 0x4C, 0x36, 0xC7, 0xBA, + 0x95, 0x03, 0xE3, 0x62, 0x39, 0x9B, 0x18, 0xDF, 0x5A, 0x6F, 0xBB, 0x7E, + 0x70, 0x28, 0x7B, 0xDC, 0x8C, 0x67, 0xE5, 0x38, 0xCB, 0x92, 0xC5, 0x74, + 0xB2, 0x3F, 0x35, 0xA3, 0x52, 0x72, 0xD0, 0x01, 0x80, 0xD3, 0xB1, 0xD9, + 0x6C, 0xDB, 0xC9, 0x6C, 0x36, 0x99, 0x66, 0xBB, 0xDD, 0x41, 0x7B, 0xDC, + 0xF5, 0x0E, 0x83, 0x21, 0x2B, 0x72, 0xA5, 0x54, 0x5E, 0xA4, 0x01, 0x62, + 0x02, 0xE1, 0xAC, 0x48, 0xFA, 0xA1, 0x7E, 0xFF, 0xFE, 0xDD, 0x27, 0x2F, + 0x5F, 0xAE, 0x26, 0x33, 0x33, 0x68, 0xE3, 0xFD, 0xA0, 0xE5, 0xC7, 0xE6, + 0xF6, 0xE8, 0xB5, 0xE0, 0x2C, 0xE1, 0x7C, 0x12, 0xCF, 0x7E, 0xF7, 0xFD, + 0xAD, 0x0D, 0xE0, 0xA7, 0x3F, 0xFD, 0xEC, 0x69, 0x5D, 0x1D, 0xAA, 0xF6, + 0xF1, 0x69, 0xF3, 0x17, 0x3F, 0x7D, 0xFD, 0xE6, 0x66, 0x36, 0x0C, 0x63, + 0xDF, 0xF6, 0xCE, 0x3B, 0x00, 0xC9, 0x7A, 0x7D, 0x3A, 0x9D, 0x1C, 0x00, + 0x98, 0x30, 0x3A, 0x8C, 0xEA, 0xC3, 0xD3, 0xF6, 0x93, 0x97, 0x97, 0x9C, + 0xD2, 0x00, 0x03, 0xA1, 0x04, 0x84, 0xB0, 0x98, 0x4F, 0x9E, 0x9E, 0x37, + 0xFF, 0xE7, 0xBF, 0xFF, 0xC5, 0xF5, 0xF5, 0x0A, 0x06, 0xEF, 0x4D, 0xB8, + 0xB9, 0x3A, 0x13, 0x82, 0xA5, 0x19, 0xDF, 0x9D, 0x6A, 0x63, 0x7C, 0x96, + 0xE7, 0xD9, 0x2C, 0x8F, 0x63, 0xF1, 0xFD, 0x1F, 0xEE, 0x18, 0x65, 0x87, + 0xDD, 0x3E, 0x62, 0x22, 0x04, 0x7F, 0xEA, 0xC7, 0xA6, 0xED, 0x10, 0x00, + 0x08, 0x42, 0x8A, 0x21, 0xC4, 0x28, 0x4F, 0x0B, 0x10, 0xA0, 0x1C, 0x07, + 0x4C, 0x69, 0x3F, 0xA8, 0xFD, 0xB1, 0xAD, 0xDB, 0x66, 0x36, 0x9D, 0x70, + 0x46, 0x31, 0x89, 0x38, 0x46, 0xD7, 0xAB, 0xE9, 0x76, 0xB7, 0x39, 0x9C, + 0xAA, 0x51, 0x6B, 0xC1, 0x79, 0x00, 0xF0, 0xC5, 0xD5, 0x25, 0x46, 0x38, + 0xCD, 0xCA, 0x79, 0x49, 0x1E, 0xD6, 0xFB, 0x71, 0xD4, 0xBB, 0xC3, 0x89, + 0x73, 0xFA, 0xE2, 0x7A, 0xF1, 0xF0, 0xB8, 0x25, 0x84, 0x20, 0x08, 0x45, + 0x14, 0x25, 0x49, 0x72, 0xFF, 0xF8, 0x14, 0x27, 0x91, 0x73, 0xBE, 0xAE, + 0x1B, 0x84, 0x30, 0xA1, 0x18, 0x06, 0x3F, 0x2D, 0xB3, 0x34, 0x89, 0xCB, + 0x34, 0x2D, 0x8A, 0x0C, 0x22, 0x8F, 0x31, 0x41, 0x08, 0x66, 0x89, 0xA8, + 0xAB, 0x9E, 0x47, 0x02, 0x23, 0xB0, 0xD9, 0x35, 0x08, 0x60, 0x6B, 0x2C, + 0xC6, 0x20, 0xE2, 0x98, 0x51, 0xAC, 0x9C, 0x81, 0x00, 0xB6, 0x9D, 0x1C, + 0x06, 0x95, 0xA5, 0x05, 0xE3, 0x91, 0xB6, 0x8E, 0x51, 0x9A, 0x08, 0x56, + 0xD5, 0x4D, 0xD3, 0xAB, 0xF5, 0x66, 0x1F, 0x9C, 0x71, 0xDE, 0x3B, 0xE7, + 0x18, 0x27, 0x71, 0xC4, 0xCF, 0xE6, 0xB3, 0xEF, 0xBE, 0x7D, 0xF3, 0xFA, + 0x66, 0xD9, 0xF7, 0x6A, 0xB7, 0xDE, 0xBF, 0x7B, 0xFF, 0xDC, 0x4B, 0x1B, + 0x90, 0x80, 0x98, 0x0B, 0xA2, 0x9D, 0xF3, 0xCE, 0x43, 0x65, 0xDD, 0xFA, + 0x78, 0x7C, 0x78, 0x7A, 0x3F, 0x8C, 0x43, 0x91, 0xC5, 0x01, 0xE0, 0xB3, + 0xC5, 0xC5, 0xCD, 0x8B, 0xD5, 0xFE, 0xD0, 0x2D, 0x26, 0x53, 0x82, 0x91, + 0x35, 0x12, 0x04, 0xDB, 0x76, 0x9A, 0x51, 0xFC, 0xF5, 0x17, 0xE7, 0x67, + 0xF3, 0x22, 0x12, 0xE2, 0x7E, 0xD3, 0x34, 0xED, 0x30, 0x0C, 0x6A, 0x7B, + 0xA8, 0x9F, 0x36, 0x95, 0xF7, 0x30, 0x58, 0x53, 0x4E, 0xA6, 0x16, 0x80, + 0xE3, 0xE9, 0xB8, 0xD9, 0x6C, 0xAD, 0x1F, 0x03, 0x04, 0xAF, 0xAE, 0x5F, + 0xCB, 0x61, 0x7C, 0x7C, 0x5A, 0x5F, 0x9D, 0x5F, 0xC4, 0x22, 0x9A, 0x4F, + 0xD2, 0x0F, 0xF7, 0x4F, 0xF7, 0xDB, 0x7D, 0x91, 0xC5, 0x71, 0x1C, 0x4F, + 0xA7, 0x53, 0x81, 0xA1, 0xD1, 0x2A, 0x8E, 0xE3, 0x87, 0xED, 0x7E, 0xD0, + 0xAE, 0x6D, 0xDA, 0x97, 0x57, 0x8B, 0x48, 0xC4, 0x3F, 0xDC, 0x3E, 0x43, + 0x48, 0x37, 0xDB, 0xED, 0xF9, 0x6A, 0x31, 0x9F, 0x94, 0x67, 0xF3, 0x29, + 0xA3, 0x18, 0x21, 0x60, 0x94, 0xAA, 0x8E, 0xA7, 0xC9, 0x6C, 0x8A, 0x09, + 0xD1, 0xCA, 0x42, 0x48, 0xB4, 0xD1, 0x72, 0x94, 0xA3, 0x72, 0xD3, 0xB2, + 0xC8, 0xB3, 0xCC, 0x68, 0x15, 0x73, 0xCA, 0x28, 0x86, 0x3F, 0xFB, 0xC9, + 0xD7, 0x5C, 0xC4, 0x67, 0x2F, 0x3E, 0x37, 0xA3, 0x54, 0x7D, 0x1D, 0x9C, + 0xC5, 0x18, 0x76, 0xB2, 0x75, 0xDE, 0x55, 0xA7, 0xFA, 0xE5, 0x27, 0x5F, + 0xEF, 0xF6, 0xFB, 0x9C, 0x0E, 0x84, 0x52, 0xC6, 0xA2, 0xD5, 0x2C, 0x1B, + 0xE4, 0xC0, 0x98, 0xE0, 0x9C, 0x23, 0xE4, 0x31, 0x45, 0xEB, 0x6D, 0x95, + 0x16, 0xB1, 0xB1, 0xB6, 0xE9, 0xC7, 0x38, 0x11, 0x08, 0x38, 0xEB, 0xFD, + 0xF6, 0xD0, 0x61, 0x1A, 0x1D, 0x9E, 0x36, 0x6A, 0xD4, 0x59, 0x9A, 0x2F, + 0xCA, 0x2C, 0x8E, 0xE3, 0x4A, 0xDA, 0x9B, 0x8B, 0x42, 0x30, 0xD8, 0x34, + 0xFD, 0xE6, 0xB0, 0xAD, 0x1B, 0x8D, 0x30, 0x0F, 0x90, 0x8A, 0x88, 0x22, + 0x1C, 0x8C, 0x35, 0x9C, 0xD1, 0xCB, 0xF3, 0x09, 0x0A, 0xBA, 0x6F, 0xEA, + 0x00, 0x82, 0x73, 0x46, 0x8D, 0x75, 0x12, 0x33, 0x4C, 0xB8, 0xB1, 0x7A, + 0xB5, 0xBA, 0x84, 0x48, 0x50, 0x86, 0xD2, 0x34, 0x23, 0x98, 0x62, 0x2A, + 0xEA, 0x46, 0x0E, 0x52, 0x52, 0x81, 0xD7, 0xFB, 0xAE, 0x1F, 0xD4, 0xDB, + 0xB7, 0x0F, 0xC7, 0x63, 0xBF, 0x5A, 0xCD, 0xD4, 0x28, 0x09, 0x81, 0x18, + 0x23, 0x42, 0x09, 0x08, 0x48, 0x50, 0x12, 0x0B, 0xA2, 0xB5, 0x6F, 0x3A, + 0xD9, 0x4B, 0xD5, 0xC9, 0x71, 0x31, 0x9B, 0x7F, 0xF9, 0xE6, 0x55, 0x5D, + 0x35, 0x45, 0x39, 0xE9, 0x47, 0xBD, 0x3F, 0x9E, 0xEA, 0xA6, 0xE1, 0x14, + 0x1B, 0x17, 0x12, 0x41, 0x23, 0x8A, 0x6F, 0xAE, 0x67, 0x79, 0x16, 0x05, + 0x60, 0x29, 0x44, 0x71, 0xC4, 0x20, 0x0C, 0x36, 0x58, 0xEB, 0xDD, 0xE3, + 0xFA, 0xD4, 0x4A, 0x13, 0x27, 0xE9, 0xE3, 0xE3, 0x46, 0x3B, 0x33, 0x99, + 0x15, 0x49, 0xC4, 0x63, 0x41, 0x01, 0x80, 0x4D, 0x37, 0x76, 0x5D, 0x27, + 0x18, 0xB9, 0x5C, 0xCE, 0xB8, 0x60, 0xB7, 0xF7, 0xDB, 0xBE, 0x1B, 0xF2, + 0x34, 0xDE, 0x6E, 0x4F, 0xD6, 0x3A, 0x63, 0xCD, 0xE6, 0xD4, 0x40, 0x08, + 0xFF, 0xE5, 0x5F, 0x7D, 0xE3, 0xB4, 0x79, 0xF9, 0x72, 0x91, 0xA5, 0xD1, + 0xC3, 0x87, 0xA7, 0xFB, 0xA7, 0x9D, 0xF2, 0x61, 0xBB, 0x6E, 0x11, 0xC6, + 0xCB, 0x79, 0x39, 0xCD, 0xF3, 0x80, 0xF0, 0xC5, 0x72, 0x12, 0xB4, 0xA7, + 0x44, 0x9C, 0x9A, 0xE1, 0x79, 0x77, 0x74, 0xCE, 0xC7, 0x91, 0x18, 0xB4, + 0xDD, 0xEE, 0x4F, 0xCB, 0xF9, 0xB4, 0x69, 0xDB, 0x10, 0x40, 0xF0, 0x8E, + 0x31, 0xDA, 0xF6, 0xC3, 0xA0, 0xD4, 0xC7, 0xC6, 0xC4, 0xC5, 0x6A, 0xF6, + 0x6F, 0xFE, 0xF9, 0xCF, 0xFF, 0xAF, 0xBF, 0xF9, 0x65, 0x2F, 0x35, 0xC2, + 0x38, 0x12, 0xDC, 0x3B, 0x27, 0x44, 0x24, 0x95, 0x12, 0x11, 0x1A, 0xB4, + 0x89, 0x84, 0x30, 0xA3, 0x6D, 0xFB, 0x2A, 0x38, 0x53, 0x96, 0xE9, 0x64, + 0xF9, 0xBA, 0x69, 0x36, 0x93, 0xD8, 0x67, 0x2C, 0x26, 0x98, 0x1C, 0x9B, + 0x56, 0x6B, 0x1B, 0x09, 0x61, 0x8C, 0xC5, 0x18, 0x61, 0x4C, 0x5A, 0xA9, + 0x4F, 0x4D, 0x5B, 0x4B, 0x30, 0x9D, 0xAF, 0x64, 0xB3, 0xBD, 0xBB, 0x7F, + 0x4A, 0xD3, 0xA4, 0x2C, 0xF3, 0xAB, 0x57, 0x97, 0x52, 0x4A, 0x88, 0x88, + 0x53, 0x6A, 0x9A, 0x27, 0xC0, 0xD9, 0xE3, 0x71, 0x73, 0xBE, 0x5C, 0x08, + 0xC6, 0x38, 0x67, 0xCE, 0x8C, 0xA3, 0xB2, 0x72, 0xEC, 0x4D, 0x70, 0x69, + 0xC4, 0x3F, 0x7F, 0xFD, 0x89, 0x77, 0xE1, 0x71, 0x77, 0x88, 0xD3, 0xE8, + 0xE2, 0xAC, 0x1C, 0x47, 0x65, 0x8D, 0x01, 0x01, 0xE8, 0x31, 0x40, 0x0A, + 0xFE, 0xF0, 0xFD, 0xC3, 0xEA, 0x2C, 0xB9, 0xBA, 0x9C, 0x06, 0x0F, 0xFA, + 0x46, 0xDD, 0x3F, 0xB4, 0x6D, 0xA7, 0x27, 0xD3, 0xC9, 0x60, 0xAC, 0xF3, + 0x2E, 0x4D, 0x22, 0x6B, 0x4C, 0x08, 0xBE, 0x1D, 0xB4, 0x94, 0x43, 0x08, + 0x30, 0x49, 0xE2, 0x0F, 0xF7, 0xF7, 0xAF, 0x2F, 0x16, 0x82, 0x92, 0x24, + 0x8A, 0x83, 0x0F, 0x98, 0x82, 0x28, 0x65, 0xB2, 0x1F, 0x05, 0x13, 0x08, + 0x11, 0x0F, 0x03, 0xE2, 0xCC, 0x07, 0x14, 0x30, 0x7A, 0xFF, 0xEE, 0x6E, + 0x59, 0x96, 0xB7, 0xF7, 0xEB, 0x63, 0xA3, 0x9C, 0xD5, 0x18, 0x05, 0x39, + 0x8E, 0xCE, 0xDA, 0x69, 0x91, 0xB7, 0x52, 0x79, 0x00, 0xDB, 0xAE, 0x2F, + 0x8A, 0xF2, 0x79, 0xBB, 0xFB, 0x58, 0x4E, 0xCA, 0xF3, 0x32, 0x8E, 0x62, + 0x42, 0x69, 0x9E, 0xC4, 0xDE, 0xC8, 0xFD, 0xE1, 0xA0, 0x8C, 0x1D, 0xD5, + 0x38, 0x9D, 0xCE, 0xA2, 0x28, 0xB9, 0x5C, 0x2E, 0x7D, 0x00, 0x91, 0x88, + 0x28, 0x72, 0x87, 0xBA, 0x36, 0xD6, 0x20, 0x1C, 0x28, 0xC6, 0xFB, 0x63, + 0x95, 0x66, 0xB1, 0x33, 0xA6, 0x6D, 0x07, 0x07, 0x50, 0x96, 0xA6, 0x7D, + 0xDF, 0x52, 0xCE, 0x62, 0x1E, 0xD5, 0x75, 0x73, 0xAC, 0xAA, 0xEB, 0x57, + 0x97, 0x9C, 0x93, 0xA1, 0x6E, 0xF3, 0x24, 0x16, 0x9C, 0xE5, 0x79, 0x5E, + 0x37, 0xDD, 0x38, 0xAA, 0xB2, 0xCC, 0x38, 0xC7, 0xF3, 0x69, 0x99, 0x26, + 0xE9, 0xC3, 0x7A, 0x83, 0x08, 0x16, 0x8C, 0x39, 0xEB, 0x87, 0x4E, 0xA5, + 0x51, 0x22, 0x65, 0xA3, 0x3D, 0x42, 0x84, 0xE4, 0x19, 0x47, 0x20, 0x18, + 0x8F, 0x4F, 0xB5, 0x1E, 0x46, 0x9B, 0xA6, 0xB1, 0xB3, 0xA6, 0xEF, 0xDB, + 0xC9, 0x74, 0xEA, 0xB4, 0xF4, 0x56, 0x1F, 0xAB, 0xE6, 0x54, 0x55, 0x51, + 0xCC, 0xD4, 0xA8, 0x92, 0x28, 0x7A, 0x71, 0xB5, 0xFA, 0xF2, 0xD3, 0xCB, + 0xC5, 0xBC, 0xA8, 0x1B, 0xA9, 0x95, 0xC5, 0x58, 0x38, 0x13, 0xEA, 0x5E, + 0x87, 0xE0, 0xDB, 0x7E, 0x50, 0xC6, 0x4D, 0x8A, 0xC4, 0x7A, 0xDF, 0x74, + 0x5D, 0xDB, 0x9C, 0x42, 0xC0, 0x5D, 0xDF, 0x30, 0x0A, 0x9B, 0xAE, 0xBB, + 0x3C, 0x3F, 0xBF, 0x98, 0xA6, 0x18, 0xFB, 0x38, 0x49, 0x1C, 0xC0, 0xC6, + 0xDB, 0x59, 0x0A, 0xB1, 0xE9, 0x0F, 0xA7, 0xCE, 0x41, 0x12, 0xC5, 0xF1, + 0xD9, 0xE5, 0xD5, 0xA1, 0x71, 0xBF, 0xFE, 0xED, 0x7B, 0x4E, 0x19, 0x0E, + 0x1E, 0x40, 0x40, 0xB9, 0x78, 0xDA, 0x35, 0x55, 0xD3, 0x2D, 0x67, 0xD3, + 0xE3, 0x61, 0x9D, 0x97, 0xE9, 0x67, 0xAF, 0xAF, 0xB9, 0xA0, 0xCA, 0xFA, + 0x61, 0x0C, 0xD7, 0xB3, 0x58, 0x60, 0x74, 0x68, 0xC6, 0xF5, 0xF6, 0x88, + 0x19, 0x3E, 0xD4, 0x55, 0x9E, 0x15, 0x4D, 0x37, 0x26, 0x71, 0x02, 0x00, + 0xD8, 0x56, 0xAD, 0xF5, 0x80, 0x21, 0x38, 0x2F, 0x63, 0xED, 0x40, 0x92, + 0x14, 0x94, 0x45, 0x4A, 0xAB, 0xAE, 0x6E, 0xAC, 0x19, 0x30, 0x46, 0x6A, + 0xD4, 0x18, 0x51, 0x67, 0xC7, 0x3C, 0x4B, 0xAC, 0xB5, 0xBB, 0xC3, 0x91, + 0xB2, 0x08, 0x41, 0xD4, 0x76, 0x6D, 0xD3, 0xB6, 0x65, 0x39, 0xEB, 0x65, + 0x1F, 0x31, 0x92, 0x44, 0xD1, 0xF6, 0x78, 0xA8, 0xDB, 0x16, 0xFF, 0xFC, + 0xBB, 0xAF, 0xB2, 0x98, 0xBB, 0xA1, 0xD6, 0x6A, 0x54, 0xDA, 0x88, 0x24, + 0x4A, 0xF2, 0x34, 0x4B, 0x29, 0x67, 0xFE, 0xE6, 0xE6, 0x05, 0xE6, 0x42, + 0xB6, 0xFB, 0x44, 0xA0, 0xAB, 0xF3, 0x89, 0x56, 0xAE, 0x48, 0x92, 0x38, + 0x62, 0x55, 0x2D, 0xD7, 0xBB, 0x0A, 0x23, 0xDC, 0x74, 0xE3, 0xFD, 0xFD, + 0x56, 0x2B, 0x27, 0x18, 0x4B, 0x22, 0xE4, 0x83, 0x1D, 0x8D, 0xAF, 0xAA, + 0xC6, 0xFB, 0x00, 0x41, 0x38, 0x5B, 0xCD, 0xA9, 0x07, 0xF3, 0x69, 0x31, + 0x2B, 0xB3, 0x8B, 0xE5, 0x64, 0x56, 0xE6, 0x0C, 0xFB, 0x71, 0xB4, 0x4F, + 0xDB, 0xD3, 0x2F, 0x7F, 0xFB, 0x16, 0x23, 0xF2, 0xF5, 0x97, 0x6F, 0xA2, + 0x88, 0xC5, 0x82, 0x47, 0x9C, 0x4F, 0xB2, 0x4C, 0x50, 0x8A, 0x20, 0xB2, + 0x56, 0x7B, 0x3F, 0x54, 0xED, 0x30, 0x0C, 0xE1, 0xCB, 0xAB, 0x09, 0x23, + 0xE0, 0xD4, 0x39, 0x11, 0xA5, 0x69, 0x59, 0x58, 0x2D, 0xD5, 0x60, 0x07, + 0xE9, 0x8B, 0x24, 0xFD, 0x70, 0xFF, 0xFC, 0xB4, 0x3E, 0xDC, 0xDE, 0xAD, + 0x1F, 0x9F, 0x4E, 0x84, 0x92, 0x28, 0x16, 0x71, 0xCC, 0x36, 0xCF, 0x9B, + 0x3C, 0x8B, 0xA7, 0xD3, 0xEC, 0x27, 0x5F, 0xDF, 0x5C, 0x5D, 0x2F, 0x19, + 0x67, 0x8C, 0x0B, 0xEB, 0x5C, 0x70, 0x4E, 0xCA, 0xF1, 0x71, 0xB3, 0x0F, + 0x10, 0x6F, 0xF7, 0xC7, 0x32, 0xCF, 0x07, 0xE5, 0x1E, 0xB7, 0x87, 0x00, + 0xC0, 0xDD, 0xE3, 0xD3, 0xEE, 0xB0, 0xE7, 0x9C, 0x69, 0xA3, 0x7B, 0x29, + 0x2F, 0x57, 0xD3, 0x2C, 0x61, 0xDE, 0xA1, 0xF5, 0xB6, 0xB5, 0xC6, 0x24, + 0x11, 0xD2, 0xC6, 0x6C, 0x0E, 0xF5, 0xDB, 0xF7, 0xEB, 0x61, 0x30, 0x8C, + 0xF1, 0xF3, 0xB3, 0x79, 0xF0, 0x7E, 0xB7, 0xAF, 0x82, 0xF7, 0x87, 0x63, + 0xDD, 0x74, 0xE3, 0x38, 0x2A, 0x0F, 0x40, 0x14, 0xF1, 0x45, 0x99, 0x4E, + 0x27, 0x69, 0x39, 0xCB, 0x29, 0xA3, 0xB3, 0x59, 0x51, 0xCE, 0xCA, 0x8B, + 0x8B, 0xE5, 0xE5, 0xC5, 0xE5, 0x72, 0x35, 0x7B, 0x71, 0xBD, 0xBC, 0xB9, + 0xB9, 0xFA, 0xFA, 0x9B, 0x4F, 0x16, 0x8B, 0x32, 0x8D, 0x93, 0xBE, 0xED, + 0xDA, 0xBE, 0xFF, 0xCD, 0xEF, 0x1E, 0xF4, 0x68, 0x29, 0xA7, 0x0F, 0xCF, + 0x8D, 0x55, 0x5A, 0xF7, 0xE3, 0xE1, 0xD0, 0x6E, 0x36, 0xC7, 0xAF, 0xDE, + 0xBC, 0xB0, 0xC6, 0xFD, 0xDD, 0xEF, 0x3F, 0xFC, 0x70, 0xF7, 0x6C, 0x6C, + 0xC0, 0x18, 0xE4, 0x59, 0x74, 0xFF, 0xB4, 0x01, 0x10, 0x3A, 0xEF, 0xDB, + 0xAE, 0x57, 0x46, 0xA7, 0x69, 0x3C, 0x2A, 0xCD, 0xA3, 0x14, 0x52, 0xE1, + 0x31, 0xD7, 0x4A, 0x7D, 0xF9, 0xFA, 0xF2, 0xD7, 0x7F, 0x78, 0xB7, 0xDE, + 0x9E, 0x8A, 0xA2, 0x00, 0x21, 0xAC, 0x16, 0xD3, 0x24, 0x4E, 0x9E, 0xF6, + 0x6D, 0x33, 0x58, 0xCE, 0x69, 0x51, 0xE6, 0xA7, 0xAA, 0xA3, 0x8C, 0x42, + 0x84, 0x7E, 0x80, 0xAC, 0x12, 0x22, 0x00, 0x00, 0x20, 0x00, 0x49, 0x44, + 0x41, 0x54, 0xF7, 0xFB, 0x77, 0x3F, 0xFB, 0xCB, 0xFF, 0x7A, 0x90, 0x32, + 0x47, 0x5B, 0x46, 0xF8, 0x7A, 0xD3, 0x54, 0x4D, 0xBF, 0xDE, 0x37, 0xFD, + 0xA0, 0xF2, 0x49, 0x52, 0xD7, 0xDD, 0x38, 0x9A, 0x41, 0x1B, 0x29, 0x25, + 0x89, 0x0A, 0x80, 0x58, 0x4E, 0x87, 0x00, 0xBC, 0xB2, 0x1E, 0x41, 0x90, + 0x94, 0x17, 0x34, 0xCA, 0xEB, 0xD3, 0x3E, 0x38, 0x9B, 0x24, 0xE2, 0x54, + 0xB5, 0x00, 0x40, 0x04, 0xC2, 0xA9, 0x3A, 0x79, 0x60, 0x11, 0x41, 0x9C, + 0x47, 0xC3, 0xA0, 0x42, 0x00, 0x2F, 0xAF, 0x5F, 0x50, 0x22, 0x0E, 0x55, + 0xD3, 0x8F, 0x3A, 0x4E, 0x12, 0x65, 0xFD, 0xE9, 0xA4, 0x8E, 0x27, 0xE5, + 0x3C, 0xA0, 0x98, 0x58, 0x1B, 0xD6, 0xBB, 0xEE, 0xDD, 0xED, 0x13, 0x15, + 0xAC, 0x93, 0xEE, 0xC3, 0x87, 0xAD, 0xB5, 0x61, 0x31, 0xCF, 0x29, 0x21, + 0xDB, 0x63, 0x1B, 0x40, 0x68, 0xDA, 0x6E, 0xBF, 0xAF, 0x20, 0x42, 0x79, + 0x96, 0x54, 0x75, 0xC7, 0x39, 0xD7, 0xDA, 0x10, 0x82, 0x30, 0x42, 0xF7, + 0x4F, 0x87, 0xB6, 0xD3, 0xDA, 0xD8, 0x5F, 0xFF, 0xE1, 0x7D, 0x37, 0xEA, + 0xE7, 0xCD, 0xE9, 0xC3, 0xDD, 0xB6, 0x1B, 0xB4, 0x75, 0x16, 0x01, 0x3C, + 0x0C, 0xD6, 0xFB, 0x00, 0xAC, 0x5B, 0x4C, 0xCB, 0x49, 0x99, 0xDD, 0xDD, + 0x6D, 0x28, 0xA6, 0x20, 0xF8, 0xAE, 0x97, 0xC3, 0xA8, 0xB9, 0xE0, 0x8C, + 0xB2, 0xBB, 0xC7, 0xCD, 0x7A, 0x77, 0x18, 0x95, 0x31, 0xD6, 0x22, 0x44, + 0xE4, 0x20, 0x01, 0x80, 0x94, 0x12, 0x35, 0xF6, 0x04, 0x63, 0x82, 0xD0, + 0x7E, 0xBF, 0x31, 0x2E, 0xB8, 0x00, 0xF2, 0x34, 0x66, 0x94, 0x77, 0x5D, + 0x57, 0x4C, 0xE6, 0x65, 0x39, 0x69, 0x9B, 0xD3, 0xDD, 0xC3, 0xFD, 0x76, + 0xB7, 0x07, 0x10, 0x47, 0xB1, 0xD8, 0xED, 0xAB, 0x56, 0x6A, 0xCC, 0x30, + 0x44, 0x81, 0x32, 0xC2, 0x62, 0xDA, 0xF6, 0x43, 0x00, 0x01, 0x13, 0x6C, + 0x3D, 0xE0, 0x9C, 0xF7, 0xBD, 0x0C, 0xCE, 0x2E, 0x56, 0x73, 0x29, 0x65, + 0x5B, 0x77, 0x3E, 0x84, 0x58, 0xF0, 0xD9, 0x34, 0xB9, 0xBE, 0x9C, 0x17, + 0x85, 0x48, 0xD3, 0x48, 0x30, 0xC6, 0x08, 0x2A, 0x8B, 0x54, 0x10, 0x36, + 0x8E, 0x8A, 0x46, 0x78, 0xB1, 0x48, 0xF3, 0x49, 0x44, 0x05, 0x0E, 0x30, + 0x64, 0x93, 0x08, 0x51, 0xC8, 0x63, 0x7E, 0xB1, 0x9C, 0x40, 0x68, 0x0F, + 0x87, 0xE3, 0x66, 0xB3, 0x89, 0x05, 0x86, 0x08, 0x59, 0x63, 0x39, 0x45, + 0x04, 0xE3, 0xC7, 0xE7, 0xCD, 0xA0, 0xD4, 0xB4, 0x88, 0x13, 0xC1, 0x3F, + 0xBB, 0xB9, 0xCA, 0x52, 0x56, 0xD7, 0xED, 0x7E, 0xDF, 0x3C, 0x6D, 0xF7, + 0x4A, 0x2B, 0xA5, 0x1D, 0xA5, 0xC4, 0x39, 0x87, 0x10, 0xEC, 0xBA, 0xBE, + 0x6B, 0x3B, 0x86, 0x41, 0xDB, 0x75, 0x21, 0x80, 0x37, 0x2F, 0x57, 0xE7, + 0x8B, 0xF2, 0x93, 0x97, 0x97, 0x69, 0x14, 0xBF, 0x3C, 0xBF, 0x3A, 0x9F, + 0x16, 0xC0, 0x39, 0x39, 0xDA, 0xBA, 0x19, 0x86, 0x71, 0x5C, 0x4C, 0x72, + 0xAD, 0xC6, 0x87, 0xC7, 0x83, 0x32, 0xD8, 0x07, 0x2C, 0x47, 0x23, 0x07, + 0x63, 0x1D, 0xE6, 0x34, 0x13, 0x34, 0x32, 0xD6, 0x7B, 0x80, 0xAC, 0xD1, + 0xC1, 0xD9, 0x24, 0x8A, 0x3E, 0xC2, 0x66, 0x59, 0x9C, 0x67, 0x29, 0x9D, + 0x4E, 0x12, 0xEF, 0xE0, 0xE1, 0xB0, 0xF7, 0x4E, 0x6B, 0x3D, 0x2E, 0x17, + 0xCB, 0x97, 0x97, 0xE7, 0x8B, 0x69, 0x19, 0x82, 0x7F, 0x7C, 0x5A, 0x1F, + 0x8F, 0x4D, 0x12, 0x45, 0x10, 0x62, 0x39, 0x28, 0x63, 0x83, 0x1A, 0x87, + 0xDB, 0xBB, 0x7B, 0x4E, 0xE8, 0xCD, 0xCB, 0xEB, 0x34, 0x61, 0x82, 0xE2, + 0x32, 0x15, 0x45, 0x9A, 0x21, 0x88, 0xE2, 0x24, 0x6B, 0xFB, 0xDE, 0x7B, + 0xA3, 0x8D, 0x7B, 0xDE, 0x1D, 0x62, 0x11, 0x2D, 0x26, 0x39, 0x82, 0x3E, + 0x89, 0x44, 0x24, 0xA2, 0xFD, 0xA9, 0x6E, 0xFB, 0xEE, 0x69, 0xBB, 0xDD, + 0x57, 0xA7, 0xF5, 0xFE, 0x00, 0x10, 0x86, 0xFF, 0xF3, 0xFF, 0xF8, 0xEF, + 0xCE, 0x57, 0xA5, 0x32, 0x76, 0xBD, 0xDD, 0x73, 0x42, 0x86, 0x61, 0x80, + 0x18, 0x2A, 0xE5, 0x10, 0x84, 0xDA, 0x38, 0x84, 0x08, 0x0A, 0x90, 0x40, + 0xC8, 0x90, 0x4D, 0x58, 0x98, 0x4D, 0x57, 0x00, 0x80, 0xE7, 0x5D, 0xE5, + 0x3C, 0x2E, 0xCB, 0x92, 0x12, 0x6C, 0xF4, 0x80, 0x08, 0xEB, 0xFB, 0xFE, + 0x54, 0x3D, 0xFE, 0xFD, 0x1F, 0xD7, 0x3A, 0x40, 0x80, 0x51, 0xB0, 0xE6, + 0x6C, 0x36, 0xFD, 0xF4, 0xE6, 0xE5, 0xD0, 0x28, 0xCE, 0x59, 0xC4, 0xE9, + 0x66, 0x77, 0x20, 0x14, 0x97, 0x65, 0x7A, 0xFF, 0x7C, 0x7C, 0x5A, 0x1F, + 0x5E, 0x5D, 0xA4, 0xD7, 0x17, 0x33, 0xED, 0x08, 0xA1, 0xA2, 0xED, 0xBD, + 0x87, 0x74, 0x7B, 0x38, 0x31, 0x04, 0x66, 0xB9, 0xE0, 0x1C, 0x19, 0x7D, + 0xA2, 0x34, 0x75, 0x3E, 0xC0, 0x30, 0x76, 0x5D, 0x2D, 0x15, 0x1E, 0xF4, + 0xD8, 0xC9, 0x1E, 0x7A, 0xC4, 0x68, 0x74, 0x76, 0x31, 0xEF, 0xA5, 0xED, + 0xFB, 0xA1, 0x28, 0x52, 0xAB, 0xFD, 0x62, 0x9A, 0x9C, 0x86, 0x61, 0x57, + 0xD5, 0x5A, 0xEB, 0xE3, 0xBE, 0x92, 0xFD, 0x88, 0x30, 0xBF, 0x38, 0x5B, + 0x60, 0x04, 0x8D, 0x33, 0xDE, 0xFB, 0xBA, 0x69, 0xCA, 0x24, 0x05, 0x10, + 0xAE, 0x0F, 0xD5, 0xE1, 0xD4, 0x4D, 0x8B, 0xFC, 0xCB, 0x37, 0x37, 0xC7, + 0xBA, 0xE3, 0x82, 0x1F, 0xAA, 0xF6, 0x78, 0x3C, 0xCE, 0x67, 0x93, 0x61, + 0x18, 0x29, 0xC1, 0xA3, 0xD2, 0x59, 0xC4, 0xCA, 0x24, 0x7A, 0xD8, 0x1E, + 0xCA, 0x2C, 0xF9, 0xE2, 0xE5, 0x62, 0x34, 0xAA, 0x1B, 0xAD, 0x1C, 0x24, + 0x44, 0x28, 0xCF, 0x72, 0xAD, 0x54, 0x96, 0x47, 0xFB, 0xFD, 0x09, 0x40, + 0x64, 0x9D, 0x3D, 0x54, 0x15, 0x44, 0x14, 0x43, 0x18, 0x20, 0x78, 0xF5, + 0xEA, 0xEC, 0x7A, 0x31, 0x0D, 0x20, 0xB4, 0x72, 0xE8, 0x3A, 0xED, 0x03, + 0xF2, 0xDE, 0x1B, 0xE7, 0xA2, 0x28, 0x26, 0x18, 0x1B, 0xE3, 0xBA, 0xBA, + 0xE5, 0x02, 0x83, 0x10, 0xB8, 0xA0, 0x45, 0x2E, 0xAC, 0xE9, 0x1F, 0x1F, + 0x0F, 0x0C, 0xD3, 0x43, 0xDB, 0x1D, 0x9B, 0x6E, 0x9E, 0x89, 0x2F, 0x5E, + 0x5D, 0xB4, 0xD2, 0x27, 0x22, 0x3E, 0x5B, 0xAC, 0xEE, 0xD7, 0xEB, 0x53, + 0x23, 0x47, 0xE3, 0x9D, 0x73, 0xCE, 0x59, 0xAD, 0x8D, 0xF5, 0x80, 0x51, + 0xBA, 0xDE, 0x1D, 0x2E, 0xCF, 0x96, 0x14, 0x03, 0xC6, 0xA3, 0xF3, 0x8B, + 0xCB, 0x5E, 0x0E, 0x8F, 0xDB, 0xD3, 0xC3, 0xF3, 0xFA, 0xB3, 0xAB, 0xE5, + 0xA2, 0x4C, 0xFF, 0xEF, 0xBF, 0xFD, 0xF5, 0xB4, 0x28, 0x00, 0x80, 0x9F, + 0xBF, 0x79, 0xBD, 0x9A, 0x17, 0x9D, 0x1A, 0xFE, 0xE3, 0xDF, 0xBD, 0x5B, + 0x2E, 0x8A, 0x38, 0x25, 0x01, 0x50, 0xD9, 0x8D, 0x8B, 0x92, 0x7F, 0xB8, + 0x7D, 0xE0, 0xD9, 0x62, 0xBE, 0xB8, 0xBC, 0xFD, 0xFD, 0x5F, 0xFF, 0xEB, + 0xBF, 0xFA, 0xE2, 0xF6, 0x41, 0x6A, 0xEF, 0x4F, 0xC7, 0xFE, 0xE2, 0xC5, + 0x65, 0x9E, 0x85, 0xBE, 0xE9, 0x07, 0xE9, 0xEB, 0x5A, 0xFB, 0xE0, 0xA2, + 0xA4, 0xD0, 0x16, 0x0E, 0xF5, 0x26, 0x49, 0xE3, 0xC7, 0x4D, 0x75, 0xAA, + 0x9A, 0xC5, 0x6C, 0x1E, 0x15, 0xB3, 0xB6, 0xDE, 0x31, 0x8A, 0x2F, 0xCE, + 0x17, 0x79, 0x9E, 0xEC, 0xAA, 0x36, 0xA6, 0x28, 0x66, 0x81, 0xA0, 0x00, + 0x11, 0xC4, 0x98, 0x95, 0x69, 0x3E, 0x2A, 0xD5, 0xF7, 0xC3, 0x74, 0x3A, + 0xF3, 0x0E, 0x9C, 0xAA, 0x46, 0x29, 0x1D, 0x20, 0xEC, 0xA4, 0xA6, 0x84, + 0x3B, 0xE7, 0xA8, 0xC0, 0x59, 0xC2, 0xA6, 0x45, 0xEA, 0x9C, 0xDF, 0x6D, + 0x77, 0x8F, 0x9B, 0xC3, 0xA0, 0xD4, 0x8B, 0xB3, 0x19, 0x40, 0x30, 0x66, + 0x78, 0x56, 0x4E, 0xAA, 0x4A, 0x8D, 0x56, 0x3F, 0x6D, 0xF6, 0x93, 0x22, + 0x87, 0x10, 0xCC, 0xCB, 0xDC, 0x05, 0x68, 0xAD, 0x2D, 0xCA, 0xD2, 0x9A, + 0xD1, 0x6A, 0xC5, 0x19, 0xEB, 0x95, 0xFD, 0xF1, 0xF6, 0x69, 0xB5, 0x9A, + 0xC6, 0xB1, 0xC8, 0x62, 0x91, 0x66, 0x6C, 0xD0, 0xF6, 0xB0, 0xAB, 0x17, + 0xB3, 0xC9, 0xF3, 0xBE, 0x62, 0x51, 0x6A, 0xE5, 0xF0, 0xA7, 0xDF, 0xDC, + 0x8C, 0xCE, 0xFE, 0xDD, 0xAF, 0xDE, 0x0D, 0x83, 0x52, 0xD6, 0x29, 0x35, + 0x4E, 0xA7, 0xB9, 0xE0, 0x94, 0x10, 0xFA, 0xB8, 0xDD, 0x37, 0x4D, 0xE7, + 0x5D, 0x88, 0x45, 0x74, 0xB7, 0xDE, 0xC9, 0x61, 0x9C, 0x4F, 0xA7, 0x10, + 0x41, 0x0C, 0x81, 0x20, 0xB8, 0xED, 0xDA, 0x7D, 0xD3, 0xCE, 0xA7, 0x93, + 0xB2, 0xC8, 0x39, 0x13, 0x71, 0x3A, 0xF9, 0xF0, 0xFE, 0xDD, 0x6C, 0x3A, + 0x3B, 0x5B, 0xCC, 0xB7, 0xDB, 0xED, 0x47, 0x4E, 0x68, 0xD4, 0xDA, 0xFB, + 0x90, 0xA5, 0x1C, 0x62, 0xD4, 0xC9, 0x61, 0x3E, 0xCB, 0x61, 0x70, 0x5C, + 0x70, 0x07, 0x90, 0xF3, 0x60, 0xEC, 0x07, 0x1F, 0x10, 0xE7, 0x74, 0xEC, + 0x3B, 0xE8, 0x5C, 0x39, 0xCF, 0xF5, 0x30, 0xD6, 0x75, 0xFF, 0xCF, 0xFE, + 0xFC, 0xAB, 0x59, 0x96, 0x4A, 0x39, 0x1C, 0x9A, 0xC1, 0x79, 0x4B, 0x09, + 0xD4, 0xCA, 0x00, 0x48, 0x8C, 0xC5, 0x3E, 0x20, 0xCA, 0x41, 0x14, 0x11, + 0x08, 0x3C, 0x12, 0xEC, 0x78, 0x68, 0xFB, 0x7E, 0x28, 0x26, 0x85, 0x1A, + 0x35, 0x40, 0x30, 0x66, 0x74, 0x39, 0x9B, 0x04, 0xEF, 0xBD, 0xF3, 0x8B, + 0x45, 0x99, 0xC4, 0x82, 0x13, 0xD1, 0x34, 0xED, 0x30, 0x8C, 0x7D, 0xD7, + 0x10, 0x4C, 0x63, 0xCE, 0xBA, 0xBE, 0xAB, 0xFB, 0xE6, 0x58, 0xB7, 0x11, + 0x17, 0x75, 0xDD, 0x9F, 0x9D, 0x2F, 0xD2, 0x34, 0x46, 0x18, 0x72, 0xC6, + 0x3E, 0xEE, 0x17, 0x20, 0x8C, 0x30, 0xC1, 0x46, 0xAB, 0x5E, 0xAA, 0xFA, + 0x20, 0x8D, 0x0A, 0xC6, 0x2B, 0xEB, 0x6C, 0x96, 0x44, 0x5F, 0x7C, 0xF6, + 0x5A, 0x20, 0xCC, 0x10, 0xEF, 0xA4, 0x62, 0x8C, 0x0C, 0xAA, 0x5F, 0xEF, + 0x8E, 0x1E, 0x84, 0xB6, 0x1B, 0xB2, 0x24, 0x22, 0x94, 0x34, 0x9D, 0x8C, + 0x38, 0x27, 0x84, 0x51, 0x22, 0x7C, 0xF0, 0xA3, 0x32, 0xDE, 0xDB, 0x22, + 0x67, 0x69, 0x9E, 0x58, 0x17, 0xA4, 0xB4, 0xBB, 0xFD, 0xC9, 0x6A, 0x47, + 0x88, 0x35, 0x76, 0xDC, 0x1F, 0x95, 0x36, 0x3E, 0x4F, 0xE9, 0xCD, 0xF5, + 0x72, 0x39, 0x9B, 0x36, 0xED, 0x30, 0x18, 0x8F, 0x31, 0xC3, 0x04, 0x1C, + 0x0E, 0x07, 0xAF, 0x8D, 0x32, 0xE6, 0x77, 0xEF, 0x1E, 0x10, 0x66, 0xD6, + 0xD9, 0xF7, 0xF7, 0x4F, 0x93, 0x3C, 0xFB, 0xFC, 0xE6, 0xE5, 0xFE, 0x74, + 0x48, 0xE2, 0x68, 0xBE, 0x58, 0x4C, 0xCB, 0x49, 0x2C, 0x92, 0x57, 0x2F, + 0x5F, 0x5B, 0x67, 0x0F, 0xA7, 0x1D, 0x42, 0x4C, 0x0E, 0x63, 0x7D, 0xB8, + 0xED, 0xDB, 0x26, 0x00, 0x96, 0xA5, 0x05, 0xA5, 0xFC, 0xEE, 0x79, 0x53, + 0x96, 0x85, 0xD1, 0x5A, 0x99, 0x51, 0x2B, 0xB3, 0x98, 0x9F, 0x93, 0x1F, + 0x7E, 0x7C, 0xD8, 0xEF, 0x4F, 0xB3, 0x79, 0x6C, 0x94, 0x6B, 0x1B, 0xBD, + 0xD9, 0x1E, 0xAD, 0x77, 0xC3, 0x68, 0x9A, 0x5A, 0x41, 0x04, 0x09, 0x42, + 0x11, 0x27, 0x08, 0xFA, 0xCF, 0x6F, 0x32, 0x42, 0x48, 0x33, 0x1C, 0x29, + 0x61, 0x59, 0x42, 0x93, 0x24, 0x21, 0x8C, 0xC4, 0x1C, 0x3B, 0x97, 0x36, + 0x7D, 0x7B, 0x52, 0xCF, 0x08, 0xF5, 0x9F, 0x7F, 0x7E, 0x65, 0x90, 0xB0, + 0x2E, 0x18, 0xA5, 0x5E, 0x2E, 0x16, 0xB2, 0x95, 0x2E, 0xF8, 0x6E, 0x90, + 0x6F, 0x3F, 0xEC, 0xA5, 0xD2, 0x11, 0x87, 0xBB, 0x8A, 0xF5, 0x83, 0x89, + 0x63, 0x3A, 0x2D, 0xCB, 0xC7, 0x67, 0xA9, 0x6D, 0x60, 0x91, 0xF9, 0xFB, + 0xB7, 0x0F, 0x5D, 0xD7, 0x5E, 0x9E, 0x9F, 0x67, 0x11, 0x47, 0x10, 0xC0, + 0x1E, 0x45, 0x2C, 0x43, 0x88, 0x1A, 0x2B, 0xA5, 0x54, 0x51, 0x54, 0xAE, + 0xF2, 0xB4, 0xD5, 0x68, 0x81, 0xD1, 0x0F, 0x6F, 0xFF, 0xB0, 0x5F, 0x1F, + 0xAF, 0xAF, 0x2F, 0x3C, 0x02, 0x01, 0x85, 0xA6, 0xAD, 0xCC, 0x18, 0x30, + 0x0A, 0xDD, 0x38, 0xBE, 0x58, 0x14, 0x5C, 0x70, 0xF0, 0xEA, 0xA2, 0x6B, + 0xC7, 0x63, 0x63, 0x22, 0x4E, 0xB3, 0x8C, 0x74, 0xCA, 0x3E, 0x3D, 0x1F, + 0xE6, 0x59, 0x91, 0xC6, 0x51, 0xD3, 0x36, 0xA3, 0x94, 0x82, 0xE0, 0xCF, + 0x5E, 0x5E, 0xA6, 0x69, 0x1A, 0x82, 0x1D, 0xC7, 0xD1, 0x59, 0x3B, 0x9F, + 0x4E, 0xBA, 0xB6, 0x61, 0x04, 0x71, 0x04, 0x10, 0xC7, 0x45, 0x84, 0xB5, + 0xEA, 0x9D, 0x51, 0xC3, 0x10, 0xFA, 0x21, 0xDF, 0x1E, 0x2B, 0x26, 0x18, + 0xE5, 0x6C, 0x52, 0xE6, 0xB2, 0x1F, 0xF3, 0x32, 0x39, 0x1D, 0xEB, 0x61, + 0xD4, 0x1F, 0x27, 0x6B, 0x40, 0x80, 0xC6, 0x98, 0xC1, 0x38, 0x82, 0xB1, + 0x55, 0x1A, 0x05, 0x72, 0xFF, 0xBC, 0x7B, 0xDA, 0x6C, 0xE3, 0x2C, 0xF1, + 0x1E, 0x30, 0x4A, 0xE5, 0xA8, 0x8D, 0xF3, 0xC3, 0xE0, 0x37, 0xBB, 0x6E, + 0x91, 0xE3, 0x9B, 0x17, 0x17, 0x51, 0x8C, 0xA3, 0x38, 0xA2, 0x44, 0x28, + 0x95, 0x5E, 0x2C, 0xE7, 0x10, 0x82, 0xBF, 0xFE, 0x9B, 0xDF, 0xD4, 0xC7, + 0xFA, 0xDB, 0xCF, 0x2F, 0x49, 0x84, 0x0B, 0x4C, 0x12, 0x2E, 0x6E, 0x1F, + 0x1F, 0xEF, 0x9E, 0x36, 0x84, 0x8A, 0x28, 0x8A, 0x4E, 0x7D, 0x6F, 0xAC, + 0x3D, 0xB6, 0x72, 0x31, 0x99, 0x18, 0xEB, 0x3E, 0xA2, 0x83, 0xC6, 0xC3, + 0xD5, 0x74, 0xFE, 0x8B, 0xBF, 0xFB, 0xD5, 0x30, 0x2A, 0xE7, 0xEC, 0x2C, + 0x4D, 0xFE, 0xF4, 0xAB, 0x4F, 0xFE, 0xC3, 0xAF, 0x7E, 0x5B, 0x4E, 0xE6, + 0x84, 0x90, 0x57, 0xAF, 0x2E, 0x38, 0x63, 0x6D, 0xD7, 0xBC, 0xF9, 0x3C, + 0xFE, 0xFE, 0x47, 0x4A, 0x29, 0x0A, 0xC0, 0x12, 0x86, 0x96, 0x0B, 0x66, + 0x7D, 0xB4, 0xBA, 0xBA, 0xF9, 0xEE, 0x4F, 0x96, 0xBF, 0xF8, 0xDB, 0x5F, + 0x7D, 0xFB, 0xDD, 0x8D, 0xA1, 0x8C, 0x24, 0x32, 0x66, 0xEC, 0xEA, 0xF5, + 0x32, 0xE5, 0x18, 0xD8, 0x26, 0x66, 0xE4, 0xE1, 0x59, 0x75, 0xDD, 0x78, + 0x7E, 0x79, 0x56, 0xCC, 0xCF, 0x7E, 0xF3, 0x8B, 0xFF, 0xB8, 0x9C, 0x97, + 0xA7, 0xB6, 0x2F, 0x0B, 0x61, 0x9D, 0x4B, 0xCA, 0x89, 0x1C, 0x0E, 0x10, + 0xF8, 0xD9, 0x62, 0x85, 0xA8, 0xD8, 0x1E, 0xAB, 0xE0, 0x1D, 0x20, 0x2C, + 0xCB, 0x33, 0x82, 0x21, 0xE3, 0x42, 0x8F, 0x1A, 0x53, 0xC4, 0xB0, 0x68, + 0xFA, 0xE1, 0xFE, 0x61, 0x93, 0xC4, 0x29, 0x42, 0xF8, 0x67, 0xDF, 0x7D, + 0xF9, 0xE1, 0x7E, 0x7B, 0xF7, 0xF0, 0x3D, 0xE3, 0xBC, 0x2C, 0xB3, 0xBA, + 0x6D, 0x9D, 0x8F, 0xFB, 0x41, 0xEB, 0x51, 0x5F, 0x9F, 0x2F, 0x0F, 0xCD, + 0xC8, 0x38, 0x1A, 0x94, 0xDE, 0x1F, 0xDB, 0xB2, 0x14, 0x8B, 0xD5, 0x02, + 0x41, 0xD5, 0xB5, 0xDD, 0xB4, 0x48, 0xF3, 0x2C, 0x8F, 0x04, 0x7B, 0x7E, + 0x7C, 0x5A, 0x2E, 0x17, 0xDA, 0x3A, 0x8A, 0x70, 0x00, 0x24, 0xCF, 0x59, + 0x14, 0xF1, 0x68, 0x30, 0xE5, 0x37, 0xAF, 0x27, 0x93, 0xCC, 0x68, 0xD0, + 0x77, 0x92, 0x00, 0x94, 0x0A, 0x3A, 0x7D, 0x73, 0xD6, 0xF6, 0x43, 0x92, + 0xF2, 0x41, 0x19, 0x63, 0x6D, 0xD3, 0xB5, 0x79, 0x96, 0x7D, 0xF6, 0xC9, + 0xCB, 0x76, 0x1C, 0xEB, 0xAA, 0xCE, 0x93, 0x94, 0x52, 0x88, 0x09, 0xA4, + 0x0C, 0x9F, 0x9D, 0x65, 0x5C, 0xD0, 0xC3, 0xA1, 0x1D, 0x3A, 0x35, 0x5A, + 0x1D, 0x40, 0xB9, 0x98, 0x4C, 0x9F, 0x9E, 0x37, 0xD6, 0xE8, 0x46, 0x1A, + 0x82, 0xD1, 0x6A, 0x3A, 0xBD, 0xBE, 0x5C, 0x05, 0x8F, 0xB4, 0x0D, 0x4D, + 0x5D, 0x7D, 0x7A, 0x73, 0xFE, 0xE9, 0xCD, 0xBC, 0xEF, 0x54, 0xCC, 0x0A, + 0x4A, 0x67, 0xD6, 0xC1, 0x1F, 0x1F, 0x36, 0x75, 0x33, 0x20, 0x00, 0x18, + 0xC1, 0x1A, 0xE2, 0x49, 0x92, 0xDF, 0x3D, 0xAE, 0xD5, 0xAE, 0xC9, 0x53, + 0xE6, 0x02, 0x00, 0x84, 0xF5, 0x6D, 0xD7, 0x9C, 0x5C, 0x1E, 0xF3, 0x2C, + 0xE5, 0xA6, 0xEF, 0x5F, 0x5E, 0x9F, 0x2F, 0x7F, 0x3A, 0xCD, 0x12, 0x21, + 0x7B, 0x0D, 0x29, 0x5F, 0x2D, 0x23, 0x42, 0x89, 0x33, 0xEE, 0xF1, 0x79, + 0xED, 0x4C, 0x30, 0xDA, 0xBE, 0xBD, 0xDF, 0x58, 0xAB, 0x5F, 0x5D, 0xCF, + 0xEB, 0xBA, 0x8D, 0xB3, 0x58, 0x8D, 0x3A, 0x00, 0x38, 0x8E, 0x2E, 0x4A, + 0xE3, 0xE6, 0xD4, 0xCC, 0x27, 0xF9, 0x3E, 0xD4, 0x84, 0xE0, 0xCB, 0xB3, + 0xB9, 0x0F, 0x60, 0xB9, 0x98, 0xCB, 0xAA, 0x05, 0x41, 0xC7, 0x71, 0x98, + 0x16, 0x45, 0x2F, 0x43, 0xDB, 0x5B, 0x15, 0x60, 0x40, 0xEC, 0xEA, 0xE2, + 0x2A, 0x8E, 0x44, 0x51, 0xB4, 0x5C, 0x08, 0x6D, 0x8C, 0x57, 0xC1, 0x28, + 0xE8, 0xA1, 0x6E, 0xEB, 0x1E, 0x53, 0x26, 0x62, 0x01, 0x02, 0xF4, 0x84, + 0x4C, 0xCE, 0x4B, 0x6C, 0x7D, 0xD3, 0x0D, 0x8C, 0x11, 0xC1, 0xD9, 0xDD, + 0xD3, 0x16, 0x04, 0xC0, 0x19, 0x8F, 0x38, 0x4F, 0xA0, 0x90, 0x52, 0x3F, + 0x6E, 0xAA, 0xBB, 0xC7, 0x0D, 0x63, 0x2C, 0xCB, 0x12, 0x1F, 0x82, 0x33, + 0x96, 0x0B, 0x26, 0x78, 0x84, 0x61, 0xE0, 0x9C, 0xE4, 0x79, 0x16, 0x73, + 0x7A, 0x38, 0xD6, 0xBF, 0x7B, 0xFB, 0x60, 0x5C, 0x10, 0x82, 0x66, 0x79, + 0x7C, 0x76, 0x5E, 0x7A, 0x63, 0x3C, 0xCC, 0x47, 0x75, 0x7C, 0x78, 0xDE, + 0x6F, 0x0F, 0xD5, 0xFE, 0xD8, 0x72, 0xFA, 0xBD, 0xD1, 0x1A, 0xD3, 0xE8, + 0xFC, 0xFC, 0x65, 0x1C, 0x51, 0x4E, 0xA9, 0xF1, 0x26, 0x2F, 0xCA, 0x6F, + 0x10, 0xE2, 0x51, 0xF6, 0xC3, 0xDD, 0x73, 0x51, 0xCE, 0x30, 0x66, 0x49, + 0x42, 0x9F, 0xB6, 0xFB, 0xFE, 0x78, 0xE8, 0xB4, 0xB9, 0x7F, 0x3E, 0xE4, + 0xA9, 0xF8, 0xE5, 0xEF, 0x7E, 0x3D, 0x9F, 0xCE, 0xE6, 0xB3, 0x65, 0x00, + 0x38, 0x11, 0x71, 0xDD, 0xE9, 0x7F, 0xF8, 0xFE, 0xBD, 0x32, 0xF6, 0xF3, + 0x37, 0x5F, 0x7D, 0xFA, 0xFA, 0xCD, 0xEB, 0x17, 0x04, 0x22, 0xA8, 0x95, + 0x32, 0x1A, 0x11, 0x12, 0x19, 0xAB, 0xF1, 0x4F, 0x7F, 0x72, 0x03, 0x20, + 0xBC, 0x7F, 0xD8, 0x7F, 0xB8, 0xDD, 0xB5, 0x9D, 0x3A, 0x56, 0xF5, 0xE1, + 0x58, 0xC7, 0x31, 0x3F, 0x9C, 0xDA, 0xBE, 0x37, 0x4A, 0x1B, 0x46, 0x7D, + 0x00, 0x63, 0x37, 0xC8, 0xAA, 0x1D, 0x02, 0xD0, 0x6D, 0x2B, 0x23, 0x11, + 0x85, 0xE0, 0x94, 0x91, 0xB5, 0xEC, 0xDE, 0xDE, 0xEE, 0xFF, 0xBF, 0x5F, + 0x7E, 0xFF, 0xB0, 0x3E, 0x68, 0x1D, 0x30, 0x25, 0x71, 0x9C, 0xB6, 0x4D, + 0xE7, 0xAC, 0x69, 0xA5, 0x14, 0x09, 0x9D, 0xCD, 0x93, 0xA2, 0xE0, 0x69, + 0x26, 0x48, 0xCC, 0x09, 0x06, 0xC7, 0xA6, 0xF3, 0x1E, 0x16, 0x69, 0x62, + 0x74, 0xB0, 0x1E, 0x5B, 0x80, 0x1F, 0xB6, 0x95, 0xF5, 0x21, 0x89, 0x45, + 0xC2, 0xE9, 0xA0, 0xC6, 0xED, 0xA9, 0xDD, 0xD7, 0xFD, 0xF3, 0xA1, 0x5A, + 0x1F, 0xFB, 0x63, 0xA3, 0x06, 0xE5, 0xBD, 0x85, 0xBB, 0x93, 0x6C, 0xA5, + 0xC3, 0xD0, 0x5F, 0x2C, 0x27, 0x45, 0x16, 0x9D, 0x1A, 0x89, 0xBD, 0x32, + 0xAA, 0xA9, 0x1A, 0x29, 0xD5, 0xD0, 0x76, 0xE3, 0xA7, 0xAF, 0x5E, 0x30, + 0x4C, 0x4F, 0xA7, 0x91, 0xB2, 0x28, 0x00, 0x72, 0x75, 0x3E, 0x85, 0x10, + 0x07, 0x88, 0xB5, 0x76, 0x08, 0xE2, 0xEB, 0xB3, 0x95, 0x1A, 0xD5, 0x1F, + 0x7F, 0xBC, 0x9B, 0x4D, 0x8A, 0x6F, 0x3F, 0x7B, 0x45, 0x69, 0xE2, 0x00, + 0x6A, 0x8E, 0x7B, 0x0A, 0xCC, 0x7C, 0x56, 0x9C, 0x9A, 0x56, 0x0D, 0x27, + 0x86, 0x21, 0x70, 0x3E, 0x89, 0x84, 0x60, 0x10, 0x38, 0x17, 0x47, 0xAC, + 0xCC, 0x45, 0xDB, 0xC8, 0xDD, 0xB1, 0x3E, 0x56, 0xED, 0x24, 0xCF, 0x81, + 0x0B, 0x7D, 0x3F, 0x60, 0x08, 0x8D, 0x52, 0x49, 0x9C, 0x1E, 0x9B, 0xB1, + 0x9C, 0xA4, 0xCB, 0x59, 0xD9, 0x34, 0x9D, 0xD1, 0x5A, 0x08, 0xFC, 0xE6, + 0xC5, 0x95, 0x60, 0xC9, 0x87, 0x87, 0xE7, 0x2C, 0x4E, 0x08, 0xC5, 0x4D, + 0xD3, 0xAA, 0x61, 0x3C, 0x1E, 0x9B, 0x69, 0x1A, 0x57, 0x75, 0x47, 0x09, + 0xFD, 0x27, 0x3F, 0x7D, 0xE9, 0x80, 0xFD, 0x70, 0xBF, 0xBF, 0xBF, 0x3F, + 0x9C, 0xEA, 0xF6, 0xF6, 0x76, 0xBB, 0xDB, 0x77, 0x08, 0xC3, 0xB3, 0xD5, + 0xF4, 0xEA, 0x72, 0x19, 0x82, 0x3F, 0x9D, 0x3A, 0xAB, 0xD4, 0x30, 0x8E, + 0x9B, 0x7D, 0x15, 0x30, 0xC5, 0x88, 0xDC, 0x3F, 0x3E, 0xB5, 0x9D, 0xF4, + 0x20, 0x1C, 0xAB, 0x06, 0x42, 0xB0, 0x39, 0xD4, 0x04, 0xA1, 0xFD, 0xA9, + 0x3A, 0xBF, 0x7A, 0x79, 0xD8, 0x3E, 0x57, 0x75, 0x13, 0xC5, 0xC9, 0x97, + 0x9F, 0xBC, 0xF8, 0x57, 0xFF, 0xC5, 0xCF, 0x7E, 0xFF, 0xEE, 0xEE, 0x3F, + 0xFD, 0xE6, 0xFB, 0xC5, 0x62, 0xF5, 0x93, 0xEF, 0xFE, 0x6C, 0x92, 0xD3, + 0xBA, 0xD9, 0xDA, 0xB1, 0x0A, 0xC6, 0xF4, 0xCA, 0x42, 0x84, 0x2E, 0xAF, + 0xA6, 0xCE, 0x48, 0x04, 0xE9, 0x62, 0x9E, 0xE6, 0xDC, 0x0C, 0xF5, 0xDD, + 0xC5, 0x45, 0xCA, 0x08, 0xB0, 0x66, 0x78, 0x75, 0x9E, 0x7B, 0x67, 0x09, + 0x04, 0xCE, 0xA8, 0xA6, 0xE9, 0x1D, 0xC4, 0xC7, 0xD3, 0x68, 0x8C, 0x0E, + 0x48, 0x38, 0x5B, 0x4D, 0x67, 0xC2, 0x38, 0x3F, 0x9D, 0xA5, 0x8B, 0xCB, + 0x15, 0x8F, 0xE6, 0xDB, 0xDD, 0xCE, 0x7B, 0x54, 0x94, 0xD3, 0x80, 0x28, + 0x26, 0xAC, 0xDA, 0x6F, 0x9F, 0x1F, 0x36, 0x14, 0x53, 0x00, 0xE0, 0xDD, + 0xFD, 0xAE, 0xEB, 0x06, 0x6D, 0xFD, 0xFB, 0xF7, 0x5B, 0x00, 0x21, 0x63, + 0x14, 0x22, 0x54, 0xD7, 0xDD, 0xF1, 0xD8, 0xD6, 0xDD, 0xA0, 0x8C, 0xF5, + 0x21, 0x6C, 0xF6, 0xC7, 0x51, 0xE9, 0xE0, 0xBD, 0xF3, 0xBE, 0xE9, 0x86, + 0x61, 0xB4, 0x9D, 0xD4, 0x8B, 0x69, 0x39, 0x9B, 0x24, 0x88, 0x12, 0x88, + 0x08, 0x15, 0xD8, 0xF9, 0x60, 0x47, 0x4F, 0x30, 0xE6, 0x2C, 0x2C, 0x66, + 0x49, 0x99, 0xA5, 0x7A, 0xD4, 0xD7, 0xE7, 0xAB, 0xD5, 0xA2, 0xC0, 0x84, + 0x6D, 0x76, 0xA7, 0xBC, 0xE0, 0x16, 0x90, 0xED, 0xAE, 0x99, 0x16, 0x29, + 0x86, 0xE8, 0x58, 0x75, 0x51, 0xC4, 0x41, 0x08, 0x94, 0x62, 0xEF, 0x82, + 0x0F, 0x80, 0x32, 0x02, 0x43, 0x58, 0xCD, 0xCB, 0x2C, 0x62, 0x9C, 0x90, + 0xED, 0xA1, 0x81, 0x18, 0xAE, 0x96, 0x79, 0xD3, 0x48, 0x29, 0xC7, 0xC3, + 0xA9, 0xDD, 0x57, 0x7D, 0x5D, 0x0F, 0xBB, 0x6D, 0x9D, 0xE7, 0x59, 0x31, + 0xCD, 0xA6, 0xD3, 0x82, 0x22, 0x54, 0x66, 0xEC, 0xCB, 0xCF, 0xAE, 0xA7, + 0x45, 0x51, 0x64, 0xD9, 0x3F, 0xFD, 0xF9, 0x57, 0xF3, 0x69, 0x52, 0xE4, + 0x49, 0xCC, 0xA9, 0xB6, 0x36, 0xA2, 0x60, 0x39, 0x89, 0x77, 0x87, 0x4A, + 0x8D, 0xF6, 0x7C, 0x5E, 0xCE, 0xA7, 0x45, 0x9E, 0xB2, 0x17, 0x97, 0x93, + 0x32, 0x8D, 0x2E, 0x17, 0xE5, 0xF5, 0x59, 0x9E, 0x70, 0x76, 0xFF, 0xB4, + 0x33, 0xD6, 0xBE, 0xB8, 0x9A, 0x9D, 0xAF, 0xA6, 0x57, 0x67, 0x8B, 0xC5, + 0xB4, 0x7C, 0x7A, 0xDA, 0x49, 0xD9, 0x5F, 0xAC, 0x32, 0x65, 0xED, 0x64, + 0x52, 0x9C, 0x2D, 0x56, 0xCF, 0xEB, 0x36, 0x00, 0x34, 0x68, 0xD3, 0x49, + 0xD5, 0x76, 0xC3, 0xC3, 0xC3, 0x3E, 0x40, 0x7C, 0x71, 0xB9, 0x58, 0xCD, + 0x27, 0x4D, 0xDF, 0xDD, 0x3E, 0xAC, 0x47, 0xA5, 0x16, 0xD3, 0xC9, 0x76, + 0x7F, 0x94, 0xBD, 0x2A, 0x26, 0xD9, 0xFD, 0xFD, 0x66, 0x1C, 0xF5, 0x20, + 0x07, 0xEF, 0xFC, 0x7C, 0x3A, 0x35, 0x4A, 0xC3, 0x00, 0x8B, 0x24, 0x59, + 0x4C, 0x0A, 0xA3, 0xEC, 0xF3, 0xF3, 0x5E, 0x29, 0xED, 0x02, 0x7A, 0x5E, + 0x1F, 0x76, 0xA7, 0x4A, 0x79, 0x6B, 0x83, 0x03, 0x88, 0x1A, 0x1B, 0x20, + 0x20, 0x4A, 0x99, 0x0F, 0x1F, 0x9E, 0xC7, 0x41, 0x77, 0xED, 0x78, 0x7B, + 0xF7, 0x7C, 0xFF, 0xB8, 0x11, 0x82, 0x03, 0x88, 0xFA, 0x56, 0x9E, 0x6A, + 0x79, 0xDA, 0x57, 0xDA, 0x58, 0x40, 0x10, 0xE3, 0x22, 0x38, 0xFF, 0xB1, + 0xFB, 0xDB, 0xF6, 0xE3, 0x7A, 0x7F, 0xDA, 0xD7, 0xCD, 0xA1, 0xEE, 0x06, + 0xE3, 0xF3, 0x49, 0x02, 0x29, 0xFA, 0x68, 0x65, 0x3E, 0x6F, 0x0E, 0x84, + 0x92, 0x43, 0xDD, 0x00, 0x08, 0x3B, 0x39, 0x48, 0x39, 0x36, 0x9D, 0x74, + 0xCE, 0x2B, 0x65, 0x5B, 0x69, 0x46, 0xEB, 0xAC, 0x73, 0xA3, 0x36, 0xC7, + 0xBA, 0x9D, 0x96, 0x65, 0x56, 0x4C, 0xA2, 0xA8, 0x0C, 0x01, 0x12, 0x82, + 0x9B, 0xAE, 0x2F, 0xB2, 0xDC, 0xFB, 0xA0, 0xB4, 0xA7, 0x98, 0x6E, 0xF7, + 0x55, 0x27, 0xD5, 0xD3, 0xF6, 0x74, 0xF7, 0xB4, 0x3B, 0x54, 0xB2, 0x1F, + 0x95, 0x36, 0xC3, 0xF9, 0x62, 0xCE, 0x44, 0x4C, 0x18, 0xAD, 0xBB, 0xBE, + 0xAA, 0x07, 0xCE, 0xA2, 0x38, 0x9B, 0xB6, 0x83, 0xF3, 0x80, 0x50, 0x22, + 0xCA, 0x24, 0xAF, 0xAB, 0xB6, 0xED, 0xBA, 0x63, 0xD5, 0xD6, 0x9D, 0x62, + 0x4C, 0x7C, 0xF1, 0xE9, 0x97, 0x6D, 0xD3, 0x0C, 0x4A, 0x87, 0x78, 0x01, + 0x30, 0xE6, 0xA1, 0x02, 0xC0, 0x30, 0xEC, 0xE0, 0xFF, 0xF2, 0x3F, 0xFD, + 0xF7, 0xBB, 0x43, 0xFD, 0xFD, 0x8F, 0x0F, 0xFB, 0xAA, 0xA9, 0xDA, 0x61, + 0x54, 0x9A, 0x52, 0x7E, 0xB6, 0x8A, 0xE5, 0xA0, 0xBE, 0x7F, 0xBB, 0x4E, + 0x12, 0xFA, 0xC5, 0x27, 0xD3, 0x61, 0x18, 0xA5, 0x52, 0x6F, 0x5E, 0x5C, + 0xDD, 0xBC, 0xB8, 0x4A, 0x78, 0x2C, 0x04, 0x33, 0xCE, 0x76, 0xA3, 0x46, + 0x04, 0x3B, 0x6B, 0x21, 0xC4, 0xC6, 0x04, 0xA3, 0x64, 0xD3, 0x8D, 0x7D, + 0x6F, 0xFB, 0xBE, 0x9B, 0x2F, 0x0A, 0xCC, 0x88, 0xB1, 0x7E, 0x3E, 0xCD, + 0x0B, 0xCE, 0x20, 0xF0, 0x49, 0xC6, 0xB3, 0x3C, 0x1D, 0x8C, 0xFA, 0xFE, + 0xF7, 0x1F, 0xB0, 0xE7, 0x8C, 0xF2, 0x7D, 0x35, 0x54, 0xBD, 0x36, 0x01, + 0x01, 0x60, 0xEB, 0x6A, 0xDB, 0xF4, 0x26, 0x49, 0x32, 0x67, 0xAD, 0x73, + 0xDE, 0xF9, 0x70, 0xBE, 0x2C, 0xF3, 0x4C, 0x5C, 0x9D, 0x17, 0x31, 0x47, + 0xC6, 0x04, 0x17, 0x50, 0x73, 0xA8, 0xAD, 0x1C, 0xE6, 0xCB, 0xB9, 0x0A, + 0xA0, 0x6F, 0xF7, 0x80, 0xB0, 0xB6, 0xEF, 0x10, 0xF4, 0xD3, 0xC9, 0xF2, + 0x78, 0x90, 0x49, 0x46, 0x26, 0xF9, 0xC4, 0x06, 0x98, 0x26, 0x74, 0x3A, + 0x15, 0x2E, 0x60, 0xA5, 0x3D, 0xA5, 0x28, 0x62, 0xA4, 0xDE, 0xF7, 0xFB, + 0xAA, 0xD5, 0x1E, 0x5D, 0x9C, 0x15, 0xFD, 0xF1, 0xD4, 0x0E, 0x84, 0x32, + 0x4A, 0x5C, 0x43, 0x78, 0x78, 0xDA, 0xD6, 0xDB, 0x43, 0x73, 0xBD, 0x2A, + 0xEC, 0xE8, 0x08, 0x61, 0x80, 0x50, 0x67, 0x87, 0x2C, 0x8B, 0x94, 0x03, + 0xC1, 0x03, 0x6B, 0x1C, 0x08, 0xFE, 0xE1, 0x71, 0xF7, 0xFA, 0xF5, 0x45, + 0x44, 0x99, 0x0D, 0xFE, 0xF6, 0xFE, 0xFE, 0x72, 0xB5, 0xDA, 0x1D, 0xAB, + 0x63, 0xD7, 0x2F, 0x56, 0x93, 0xEA, 0xD8, 0x56, 0x55, 0xBB, 0x98, 0x67, + 0x45, 0x19, 0x2F, 0x67, 0xF3, 0xE0, 0xC9, 0xDD, 0xDD, 0x23, 0xC6, 0xB8, + 0x1F, 0x54, 0x31, 0x89, 0x8D, 0x52, 0x4D, 0x3D, 0xCE, 0x67, 0xF9, 0xDD, + 0xE3, 0xEE, 0x4F, 0xBF, 0xBD, 0x81, 0xC0, 0xEF, 0x4E, 0x95, 0x31, 0x7E, + 0xBD, 0xA9, 0x29, 0xC5, 0x59, 0x9A, 0x74, 0xFD, 0x00, 0x81, 0xBF, 0xB8, + 0x98, 0x8F, 0x83, 0x1B, 0x86, 0x76, 0xB9, 0x2C, 0x82, 0x37, 0x75, 0x3B, + 0x68, 0xED, 0x9D, 0xC5, 0xD5, 0x51, 0x2A, 0xAD, 0x29, 0x25, 0x10, 0xC1, + 0x62, 0x22, 0x70, 0x60, 0x88, 0xB0, 0x9B, 0xAB, 0xD9, 0xB4, 0x2C, 0x02, + 0xE4, 0x66, 0x6C, 0xAD, 0x83, 0x6A, 0x54, 0x88, 0xD0, 0xC5, 0x2C, 0xDF, + 0x57, 0x8D, 0xB5, 0x36, 0x2B, 0x4A, 0x1C, 0x2F, 0xFA, 0xF6, 0x3D, 0x85, + 0x92, 0x04, 0x6E, 0x0D, 0xD4, 0x44, 0x9B, 0x20, 0x60, 0x38, 0xF5, 0x6D, + 0x83, 0x20, 0x03, 0x40, 0xBB, 0x7E, 0x30, 0xDA, 0x27, 0xF3, 0x8C, 0x20, + 0x88, 0xBC, 0xF1, 0xDE, 0x69, 0x63, 0xAD, 0x85, 0xCB, 0x79, 0x71, 0x6C, + 0x3A, 0x69, 0xB1, 0xEC, 0xD4, 0xAB, 0x17, 0xD7, 0x6F, 0xDF, 0x57, 0x17, + 0x67, 0x98, 0xB2, 0xE8, 0xFE, 0x51, 0x96, 0x25, 0xE9, 0xA5, 0xAD, 0xEA, + 0x5E, 0x8D, 0xED, 0xE5, 0x6A, 0xA1, 0x03, 0xDE, 0x1F, 0xEA, 0xFD, 0xB6, + 0xAA, 0x4F, 0x2D, 0x65, 0xEC, 0x8B, 0x2F, 0x3E, 0x49, 0x53, 0x32, 0x48, + 0x29, 0xDB, 0x91, 0x32, 0x9A, 0x67, 0x99, 0xB3, 0x9E, 0x12, 0x58, 0x94, + 0x31, 0x0C, 0xE8, 0xF1, 0xE1, 0x74, 0xB7, 0xDE, 0x4E, 0xCA, 0x02, 0x23, + 0xB4, 0xDB, 0x1F, 0x44, 0x92, 0x96, 0x59, 0x9C, 0xA5, 0xA2, 0x69, 0xFA, + 0xDD, 0xA9, 0xBD, 0x3C, 0x3F, 0xB3, 0x5A, 0x47, 0x82, 0xCC, 0xE6, 0x13, + 0xC1, 0xE8, 0x38, 0x0E, 0xF3, 0x49, 0x66, 0x46, 0xF5, 0xF8, 0xF4, 0x14, + 0x47, 0xE4, 0xEC, 0xAC, 0x84, 0xCE, 0xCF, 0xCA, 0x05, 0xC5, 0x34, 0x4B, + 0x89, 0x54, 0x76, 0x7F, 0xA8, 0x08, 0x8B, 0x1B, 0xE9, 0x81, 0x77, 0x89, + 0x60, 0xC6, 0xFA, 0xDD, 0xA9, 0x3E, 0x1C, 0x6A, 0x1E, 0xD1, 0xA2, 0x88, + 0xBB, 0x61, 0xBC, 0xBA, 0x98, 0x05, 0x1B, 0xAC, 0x35, 0x49, 0x12, 0xA5, + 0x9C, 0xAE, 0xB7, 0xBB, 0x61, 0xF0, 0xD3, 0xF9, 0xDC, 0x01, 0x7B, 0x3C, + 0xB5, 0x55, 0x33, 0xEC, 0x8F, 0x95, 0xF3, 0x20, 0x12, 0x3C, 0x8D, 0xA3, + 0x38, 0xE2, 0x2E, 0xF8, 0xD9, 0x3C, 0xC7, 0x1E, 0x46, 0x0C, 0x11, 0x4A, + 0xAC, 0xF3, 0xF3, 0xB3, 0xD4, 0x18, 0x1D, 0x20, 0xB0, 0x2E, 0x0C, 0xA3, + 0x62, 0x9C, 0x9B, 0xD1, 0xBE, 0xFD, 0xFE, 0x69, 0xBB, 0x3D, 0x5C, 0x5F, + 0x5C, 0x20, 0x08, 0x4F, 0x4D, 0x8F, 0x31, 0x0A, 0xC1, 0xCD, 0xA7, 0x25, + 0xC1, 0x70, 0x31, 0x4B, 0xD4, 0xA8, 0xF7, 0x75, 0x37, 0x29, 0xD3, 0xE5, + 0xBC, 0xEC, 0x07, 0x83, 0x10, 0x1D, 0xA4, 0x7A, 0xDA, 0x57, 0x55, 0x7D, + 0xEA, 0xFA, 0x46, 0x6A, 0xF0, 0xF2, 0xEC, 0x0C, 0x05, 0x64, 0xBD, 0x8F, + 0x62, 0xDE, 0xF6, 0x6D, 0x2F, 0xD5, 0xF6, 0x50, 0x3F, 0x6F, 0x8E, 0x37, + 0x2F, 0x2E, 0x5E, 0x9C, 0x4F, 0x17, 0x8B, 0xCC, 0x21, 0x5F, 0x1D, 0xA5, + 0x36, 0x5E, 0x8D, 0xEA, 0xEE, 0xE1, 0x99, 0x70, 0x92, 0x24, 0xA2, 0x3E, + 0xF4, 0x18, 0xE3, 0x2F, 0xDE, 0x5C, 0xCF, 0xE7, 0xA5, 0x33, 0x5E, 0x4A, + 0xFD, 0xE2, 0xF2, 0x4C, 0xF6, 0xFD, 0x72, 0x3E, 0x31, 0xCE, 0xAF, 0x37, + 0x87, 0xCD, 0xEE, 0x38, 0x9B, 0x95, 0x10, 0x85, 0xAA, 0x3B, 0x58, 0x6B, + 0x16, 0xCB, 0x49, 0x00, 0xE8, 0xEE, 0xF1, 0x04, 0x2C, 0x49, 0x63, 0x5E, + 0xE4, 0x3C, 0x8D, 0x12, 0x0C, 0xF1, 0x2F, 0x7E, 0xF5, 0xF7, 0x83, 0xD2, + 0xD7, 0x2F, 0xCE, 0x79, 0xC4, 0x9B, 0xB6, 0x27, 0x91, 0xE8, 0x4E, 0xED, + 0x30, 0xA8, 0xE5, 0xD5, 0x19, 0x81, 0xE8, 0xB8, 0x3B, 0xA6, 0x79, 0xB4, + 0x58, 0x4C, 0x02, 0x80, 0x5D, 0x3D, 0x08, 0x42, 0x29, 0xA7, 0x3F, 0x7C, + 0x78, 0x36, 0xC6, 0x2E, 0x16, 0x25, 0xC1, 0x28, 0x8E, 0xF8, 0xF3, 0xE3, + 0xDE, 0x5A, 0x77, 0xEA, 0x3A, 0xC1, 0x99, 0x1A, 0x4D, 0x96, 0x25, 0xCE, + 0xB8, 0x8F, 0x37, 0x04, 0x00, 0x7C, 0x78, 0xDA, 0x12, 0x2E, 0x8C, 0x31, + 0x93, 0x22, 0x61, 0x18, 0x9E, 0x9F, 0x5D, 0x30, 0x9E, 0x0F, 0xC3, 0x10, + 0x11, 0x5B, 0x64, 0x0C, 0x23, 0x7C, 0x38, 0x9D, 0x16, 0xB3, 0x02, 0x04, + 0xB4, 0xD9, 0x57, 0x00, 0x80, 0x53, 0xD3, 0x2E, 0x26, 0x05, 0xC6, 0xB0, + 0xEB, 0x86, 0x51, 0xAB, 0x7E, 0x1C, 0x77, 0x87, 0x8A, 0x33, 0x31, 0x5F, + 0x5D, 0x11, 0x16, 0xA9, 0xBE, 0x82, 0x98, 0xA4, 0xE5, 0xB2, 0x5C, 0x5C, + 0x04, 0xEF, 0x37, 0xEF, 0x7E, 0x7B, 0xFB, 0xFE, 0x6D, 0x9A, 0x17, 0xFB, + 0xEA, 0x04, 0x20, 0x9D, 0x4C, 0x4A, 0xC1, 0x58, 0x2B, 0x47, 0x4E, 0x09, + 0x80, 0x30, 0x16, 0x9E, 0x21, 0x29, 0x47, 0xBD, 0xD9, 0x9E, 0xC8, 0xED, + 0xC3, 0x2E, 0x8B, 0xE3, 0x6F, 0x3F, 0x7F, 0x33, 0x8C, 0xFA, 0x77, 0xEF, + 0xEE, 0x1F, 0xF7, 0xB5, 0x32, 0xBA, 0x97, 0x87, 0x51, 0xF9, 0xB3, 0x39, + 0xA1, 0x14, 0x5A, 0x0F, 0x94, 0xF2, 0x5F, 0xDD, 0x7C, 0x76, 0xBE, 0xBA, + 0x94, 0xD2, 0x34, 0x7D, 0x67, 0x8C, 0xEE, 0x07, 0x75, 0xAA, 0x25, 0xA6, + 0x74, 0x94, 0xC3, 0xA4, 0xCC, 0x84, 0x10, 0x79, 0x22, 0xCA, 0x69, 0xBE, + 0x38, 0xC3, 0x8F, 0x0F, 0x78, 0x96, 0x97, 0x79, 0x96, 0x29, 0x6B, 0x93, + 0x58, 0x4C, 0x52, 0x4C, 0x31, 0x82, 0x38, 0x3C, 0x3E, 0xEE, 0xE2, 0x88, + 0x7E, 0xF6, 0xFA, 0x42, 0xF0, 0xD8, 0x6A, 0x10, 0xA7, 0x7D, 0xD6, 0xF5, + 0x93, 0x49, 0x16, 0xBC, 0x6D, 0xFA, 0x3C, 0x04, 0xF4, 0xF0, 0x78, 0x6C, + 0x7B, 0xE9, 0x3C, 0xFC, 0xEE, 0xCB, 0xCB, 0x4F, 0x6F, 0x16, 0xBD, 0x1A, + 0xEB, 0x7A, 0x0C, 0x01, 0x76, 0x43, 0xBF, 0x5C, 0x94, 0xD3, 0x62, 0xD5, + 0x54, 0x5D, 0xC4, 0xE8, 0xCB, 0x49, 0xF6, 0xB0, 0x03, 0xEF, 0x9F, 0x76, + 0xE7, 0x67, 0xC5, 0xB4, 0x28, 0x84, 0x48, 0x62, 0xDE, 0x4C, 0xE7, 0x91, + 0x77, 0x28, 0xCF, 0x12, 0x11, 0x61, 0xED, 0xD4, 0x60, 0x34, 0x22, 0xD6, + 0xDA, 0x10, 0x78, 0x9A, 0x4C, 0x48, 0x3C, 0x9F, 0x21, 0x84, 0xA7, 0x45, + 0xEA, 0xCE, 0x22, 0xA3, 0x5C, 0x96, 0x64, 0x9B, 0x0D, 0x56, 0xBD, 0x5C, + 0x7E, 0x96, 0x13, 0x8A, 0xBC, 0x71, 0x10, 0x33, 0xA9, 0xAD, 0xD6, 0x56, + 0xE9, 0x2C, 0x2D, 0x33, 0xEB, 0x3C, 0x80, 0x80, 0x0B, 0xDE, 0x77, 0x8D, + 0x48, 0x18, 0xA6, 0x78, 0x31, 0x2B, 0x8E, 0x55, 0x7B, 0x7D, 0x7D, 0x15, + 0xBC, 0xB7, 0x50, 0x33, 0x06, 0x41, 0x00, 0x4C, 0xD0, 0xD7, 0xAF, 0x57, + 0x79, 0x1A, 0x53, 0xC6, 0x10, 0x26, 0x55, 0x55, 0xA9, 0x71, 0x28, 0xA7, + 0x05, 0xC2, 0xBC, 0x3A, 0xEE, 0x05, 0x86, 0x57, 0xAB, 0xC9, 0xED, 0xFA, + 0x10, 0x73, 0xE2, 0x94, 0xBE, 0x7F, 0xDA, 0x62, 0x46, 0x9C, 0x35, 0xAF, + 0xAF, 0x26, 0x0E, 0xD0, 0x77, 0x77, 0xCF, 0x52, 0x8E, 0xB2, 0xD7, 0x3E, + 0x40, 0x88, 0x00, 0xA3, 0xBE, 0x95, 0xD2, 0x5B, 0xAF, 0x54, 0x38, 0xB5, + 0x3D, 0x45, 0x70, 0x3A, 0xCB, 0xD4, 0x80, 0xDB, 0x76, 0x78, 0x79, 0x75, + 0xF1, 0xE2, 0x7A, 0x42, 0x11, 0xBF, 0xBC, 0x9C, 0x61, 0x84, 0x36, 0x07, + 0x43, 0x59, 0x34, 0x4D, 0x11, 0xA3, 0x64, 0x7B, 0x94, 0x98, 0x90, 0x9B, + 0xEB, 0xD5, 0xBC, 0x8C, 0x4F, 0x8D, 0x14, 0x71, 0xE2, 0xE1, 0xB6, 0xAF, + 0x4F, 0xC0, 0x49, 0xC8, 0xB3, 0x3F, 0xBE, 0x7B, 0x12, 0xA5, 0xA0, 0x08, + 0x5A, 0xDD, 0x3C, 0x6D, 0xBB, 0x2C, 0x8F, 0x29, 0x23, 0x09, 0xC6, 0x26, + 0xB8, 0x61, 0x34, 0xC6, 0x98, 0xE3, 0x6E, 0x87, 0x30, 0xCE, 0xF3, 0xD8, + 0x28, 0x0D, 0x9D, 0x8A, 0xB2, 0x98, 0x70, 0x58, 0xA4, 0x69, 0x33, 0xF0, + 0x88, 0xAB, 0x32, 0x9D, 0x0C, 0x8A, 0x26, 0xC2, 0xF4, 0x6D, 0x6D, 0x2C, + 0xAC, 0xAB, 0xF6, 0x27, 0xDF, 0xDC, 0x24, 0x71, 0xF4, 0xFD, 0x0F, 0xB7, + 0xF3, 0x59, 0x0A, 0x11, 0xF0, 0xC0, 0x53, 0x26, 0x36, 0xBB, 0xD3, 0xE6, + 0xD9, 0x85, 0xE0, 0xF3, 0x3C, 0xDE, 0x3D, 0x1E, 0xF1, 0x0B, 0xDA, 0x4B, + 0x75, 0xAA, 0x9A, 0xB3, 0xC5, 0x24, 0xCF, 0x92, 0x24, 0x13, 0xE4, 0x40, + 0x6F, 0x1F, 0xB7, 0x97, 0xAB, 0x85, 0x71, 0x5E, 0x37, 0x6D, 0x12, 0x47, + 0x6D, 0x3F, 0x1A, 0xEB, 0xB5, 0x71, 0xF7, 0x8F, 0xEB, 0x34, 0x16, 0xA3, + 0xA6, 0x00, 0x09, 0x6F, 0xDB, 0xB2, 0x8C, 0xB7, 0xFB, 0x3E, 0x89, 0xC8, + 0xD5, 0xCB, 0xEB, 0x5E, 0x8E, 0x90, 0x24, 0x2F, 0x5F, 0x9F, 0xB5, 0x55, + 0x85, 0x38, 0xDD, 0x4B, 0x3D, 0x8C, 0x63, 0x3A, 0x2D, 0x08, 0xE4, 0x4C, + 0x04, 0x4A, 0x51, 0xD3, 0xF4, 0x20, 0x40, 0x82, 0xC0, 0xE5, 0xCB, 0x65, + 0x39, 0xCB, 0xA0, 0xF7, 0x78, 0x5F, 0x01, 0x0F, 0xA3, 0x48, 0x78, 0x18, + 0x75, 0x5D, 0xAF, 0x95, 0x13, 0x71, 0x5E, 0x94, 0x91, 0x1C, 0xEC, 0xC3, + 0xE3, 0x76, 0xBD, 0xDD, 0xCC, 0x97, 0xF3, 0xAF, 0xBF, 0xBA, 0xD9, 0x6C, + 0x8E, 0x18, 0x22, 0xA3, 0xED, 0xBB, 0xF7, 0x8F, 0x93, 0x49, 0x31, 0x0E, + 0x6A, 0x35, 0x2F, 0xA1, 0x67, 0xAA, 0x69, 0xA8, 0xC0, 0xBF, 0xFF, 0xED, + 0x7E, 0x50, 0xDA, 0x84, 0xD0, 0x0F, 0x23, 0x8B, 0x85, 0x1A, 0xD5, 0x62, + 0x35, 0x9B, 0x9E, 0x4F, 0xF2, 0x49, 0x0A, 0x35, 0x7E, 0x5A, 0x1F, 0xB4, + 0x55, 0xC7, 0xBA, 0x4B, 0x93, 0x28, 0x4B, 0x92, 0x83, 0x54, 0xBB, 0x43, + 0x13, 0x20, 0xC8, 0xB3, 0x74, 0xBD, 0x93, 0x55, 0xA3, 0x38, 0xA3, 0x55, + 0xD5, 0x2B, 0x33, 0x5E, 0x5E, 0xCD, 0x31, 0x8A, 0xAD, 0x35, 0x69, 0xCC, + 0xCB, 0x34, 0x95, 0x83, 0x74, 0xD6, 0x1F, 0xAB, 0x53, 0x37, 0x0C, 0xCE, + 0x81, 0xE3, 0xF1, 0x24, 0x87, 0x3E, 0x00, 0x8F, 0x11, 0x92, 0x72, 0x74, + 0x30, 0x80, 0x00, 0xB2, 0x2C, 0x62, 0x0C, 0xDD, 0xDC, 0x9C, 0x4D, 0xA7, + 0x29, 0xB4, 0xEE, 0xEA, 0xCF, 0xBE, 0x01, 0x08, 0x20, 0x4C, 0xE2, 0x98, + 0x53, 0x04, 0x84, 0x88, 0xF4, 0x60, 0x41, 0xCE, 0x18, 0xE3, 0xDF, 0xBF, + 0x7F, 0xDE, 0x9F, 0x2A, 0x00, 0x01, 0x66, 0xE4, 0xFE, 0xE9, 0x51, 0xBB, + 0xB1, 0xC8, 0xE3, 0xFB, 0x87, 0x35, 0xE3, 0x5C, 0x8F, 0x6E, 0x54, 0x8A, + 0x44, 0x38, 0x45, 0x1C, 0x32, 0xF0, 0xF4, 0xB4, 0x16, 0x09, 0x79, 0x79, + 0xB3, 0x9C, 0x4E, 0xE7, 0x3F, 0xFE, 0x70, 0xD7, 0xB6, 0x92, 0x69, 0xD3, + 0x76, 0x03, 0xA1, 0x38, 0x04, 0xBF, 0xD9, 0x1D, 0xB9, 0x60, 0xC6, 0xDA, + 0xD3, 0xA9, 0xB5, 0xD6, 0xE6, 0x65, 0x0E, 0x03, 0x81, 0x00, 0xBD, 0x7A, + 0xB9, 0xEA, 0x86, 0x41, 0x08, 0x7A, 0x7F, 0xBB, 0x2F, 0xB3, 0xF4, 0x6C, + 0x35, 0x3D, 0xD5, 0xED, 0xB1, 0x6E, 0x9D, 0xB1, 0x10, 0x86, 0xAE, 0x97, + 0xCE, 0x07, 0x63, 0xAC, 0xB3, 0x6E, 0x3A, 0xC9, 0x92, 0x88, 0xFF, 0xF8, + 0xB0, 0xC9, 0xB3, 0x14, 0x95, 0xE9, 0xF9, 0x6A, 0x2A, 0x88, 0x93, 0xF2, + 0xD0, 0xF5, 0x43, 0x32, 0xCF, 0x01, 0xF6, 0xCA, 0x38, 0xE7, 0xDD, 0xE9, + 0x54, 0x97, 0x45, 0x31, 0x29, 0xD2, 0xBA, 0x6D, 0x16, 0xB3, 0x1C, 0x43, + 0x74, 0x3C, 0xB5, 0x71, 0x92, 0x44, 0x84, 0xC5, 0x59, 0x32, 0x9D, 0xCC, + 0x64, 0xD7, 0x9F, 0xCF, 0x92, 0xF9, 0xC5, 0xEB, 0xBA, 0x3A, 0x9C, 0x76, + 0xDB, 0xD9, 0x34, 0x75, 0x41, 0x3D, 0x1F, 0xEB, 0x87, 0xCD, 0x7A, 0x7D, + 0x3C, 0x5C, 0x52, 0x9C, 0x45, 0xD1, 0xE5, 0xD9, 0x6A, 0x3E, 0xCD, 0x4E, + 0xB5, 0x3C, 0x5F, 0x4E, 0x7D, 0x70, 0x4D, 0xD7, 0xE5, 0x09, 0xF6, 0x1E, + 0xC7, 0x09, 0xA4, 0x94, 0xC3, 0xFF, 0xEA, 0x2F, 0xFF, 0x9C, 0x12, 0x42, + 0x09, 0xC3, 0x10, 0x4E, 0xF2, 0x74, 0x73, 0xAC, 0x7E, 0xF1, 0xDB, 0x5F, + 0x27, 0x09, 0xD2, 0x06, 0x10, 0x02, 0x9C, 0x85, 0x37, 0xAF, 0x5F, 0xCD, + 0x27, 0xB3, 0x51, 0xFA, 0x53, 0x55, 0x9D, 0x9D, 0x4F, 0x77, 0xC7, 0x7A, + 0x7B, 0x68, 0xFB, 0xAE, 0xB7, 0xCE, 0x1B, 0xA3, 0x7D, 0x00, 0x10, 0x92, + 0xE0, 0x5D, 0x96, 0x65, 0x22, 0x82, 0x3F, 0xFB, 0xE6, 0xC5, 0x62, 0x32, + 0xB1, 0x1A, 0x3A, 0xFF, 0xFF, 0xB3, 0xF4, 0x1E, 0x3B, 0xB7, 0x65, 0x59, + 0x76, 0xDE, 0xF2, 0x6B, 0x6D, 0xBF, 0x8F, 0xFD, 0xED, 0x75, 0x61, 0x33, + 0x23, 0x2D, 0xAA, 0x2A, 0x59, 0x44, 0xA9, 0x23, 0x02, 0xEC, 0x48, 0x20, + 0x28, 0x40, 0xCF, 0xAB, 0x9E, 0x20, 0x40, 0x82, 0x24, 0x8A, 0x60, 0x95, + 0x32, 0x23, 0x33, 0x32, 0xE2, 0xC6, 0x35, 0xBF, 0x3B, 0x6E, 0xFB, 0xE5, + 0x8D, 0x1A, 0xA1, 0x87, 0x98, 0x8D, 0x39, 0xC7, 0xFC, 0xC6, 0x87, 0x7D, + 0xB4, 0x00, 0x40, 0x4A, 0x70, 0x5B, 0x65, 0x84, 0x40, 0xAD, 0x34, 0x00, + 0xD0, 0x25, 0x9F, 0xE5, 0x4C, 0x4A, 0x6B, 0x6D, 0xF4, 0x31, 0x28, 0x63, + 0xA4, 0x34, 0x52, 0x9A, 0xA6, 0x29, 0xDB, 0xBA, 0x62, 0x9C, 0xC5, 0xE8, + 0x5F, 0x5F, 0xB5, 0xC7, 0xCB, 0xD8, 0x0D, 0x72, 0x1A, 0xCD, 0x30, 0x2C, + 0x9F, 0x9E, 0x8E, 0x6D, 0x5D, 0x08, 0x02, 0x1C, 0x48, 0xEF, 0x5E, 0xED, + 0xF7, 0xAB, 0x82, 0xF3, 0x0C, 0x11, 0x68, 0x9C, 0x9E, 0x95, 0x75, 0xC6, + 0x35, 0x75, 0xA1, 0x6D, 0x78, 0x7A, 0x3C, 0x12, 0x8C, 0xCA, 0x3C, 0x9B, + 0x95, 0x26, 0x8C, 0x44, 0x08, 0x5E, 0x4E, 0x7D, 0xDF, 0xCD, 0xAB, 0x55, + 0x2E, 0x72, 0x8E, 0x09, 0xC9, 0x05, 0x5F, 0xD5, 0xC5, 0x76, 0x53, 0x50, + 0x4C, 0xBC, 0x75, 0x34, 0xC1, 0x60, 0x82, 0xD6, 0x32, 0xE3, 0xCC, 0xF8, + 0x88, 0x79, 0x7E, 0x3A, 0xCC, 0x11, 0x80, 0x4E, 0x2E, 0x59, 0x96, 0x63, + 0x9A, 0xB2, 0x02, 0x0F, 0xD3, 0x34, 0x0C, 0x06, 0x41, 0x78, 0xB3, 0x6D, + 0x21, 0x48, 0xED, 0x7A, 0x35, 0x2F, 0x73, 0xCE, 0x79, 0x99, 0xE7, 0xC6, + 0x99, 0x08, 0x62, 0x95, 0x0B, 0xEB, 0xBC, 0x31, 0x76, 0xEE, 0xEC, 0x5F, + 0xBE, 0xFF, 0xE1, 0xE6, 0xFE, 0x2A, 0xC6, 0xF8, 0xF1, 0xE3, 0x03, 0xE5, + 0xB8, 0xE0, 0xB4, 0xCA, 0x8B, 0xF5, 0xEE, 0x76, 0x9A, 0xE6, 0xC7, 0xA7, + 0xCF, 0x7F, 0x7F, 0xFF, 0x58, 0x94, 0xD9, 0xDB, 0x57, 0x1B, 0xCE, 0xD8, + 0x0F, 0x3F, 0x1F, 0x06, 0x69, 0x20, 0x84, 0x5A, 0xB9, 0x5C, 0x90, 0xD7, + 0xF7, 0x1B, 0x42, 0xC9, 0x38, 0x4E, 0x99, 0x60, 0x21, 0xB8, 0x63, 0xA7, + 0x62, 0x08, 0x37, 0xBB, 0x46, 0x8E, 0x96, 0x53, 0xF1, 0x87, 0xDF, 0xBE, + 0xAB, 0x32, 0x96, 0x22, 0x04, 0x3C, 0xC4, 0x20, 0x46, 0x2D, 0xAE, 0xEF, + 0xDE, 0xF6, 0x2F, 0x3F, 0x6B, 0x63, 0x08, 0x87, 0x55, 0x96, 0x1D, 0x4F, + 0x5D, 0x9D, 0x31, 0x4E, 0xE9, 0xF5, 0x8E, 0x7D, 0x7C, 0xF9, 0xFE, 0xFB, + 0x1F, 0x9F, 0x2A, 0x41, 0x68, 0xBD, 0x19, 0xB5, 0x43, 0x66, 0x4E, 0xDE, + 0x74, 0x83, 0x3B, 0x0D, 0x26, 0x02, 0xF0, 0xD5, 0xBB, 0xA6, 0xEF, 0xF4, + 0xE9, 0x2C, 0x31, 0x25, 0x9C, 0xA5, 0x2A, 0xA7, 0x09, 0x61, 0xA9, 0xA3, + 0x9C, 0xE5, 0xCD, 0xAE, 0xA6, 0x59, 0xAE, 0x54, 0xBF, 0xBF, 0x7E, 0x7B, + 0x3C, 0xE9, 0x9B, 0x35, 0xA6, 0x90, 0x5D, 0x06, 0x09, 0xB0, 0x36, 0xD2, + 0xFF, 0xEB, 0x0F, 0xC3, 0x6F, 0x7E, 0xFF, 0x0D, 0x23, 0xE1, 0x70, 0xEC, + 0x20, 0x88, 0x55, 0x2D, 0xBE, 0xFF, 0xDB, 0x71, 0xB3, 0x59, 0x1F, 0x5F, + 0x3A, 0x98, 0xB0, 0xB1, 0x76, 0xBF, 0x5D, 0x2B, 0xA5, 0xC6, 0x69, 0xFE, + 0xE6, 0xAB, 0x57, 0x21, 0xC6, 0x97, 0x43, 0xC7, 0x38, 0xBD, 0xBD, 0x5A, + 0x69, 0xA9, 0x16, 0xE5, 0x5E, 0x4E, 0x13, 0x25, 0x04, 0x80, 0x88, 0x10, + 0xBC, 0xBF, 0xBE, 0x86, 0x30, 0x6A, 0x1B, 0x67, 0x65, 0xAF, 0xB7, 0x6D, + 0x7F, 0x39, 0x57, 0x65, 0x29, 0xB5, 0x5D, 0x94, 0xA9, 0xCA, 0x6C, 0xBF, + 0x59, 0x29, 0xA5, 0xD7, 0xEB, 0xD5, 0xAF, 0xBE, 0xBE, 0x09, 0x4E, 0x9F, + 0xCF, 0x43, 0xD7, 0x8F, 0x3E, 0xC4, 0x84, 0x30, 0xE3, 0x84, 0xE7, 0xDC, + 0x68, 0x8B, 0x21, 0xDE, 0x6E, 0x6B, 0x82, 0x10, 0xC1, 0xA1, 0xCA, 0xD8, + 0x24, 0x2D, 0x13, 0x94, 0x11, 0x9C, 0x53, 0xA1, 0xA5, 0xEB, 0x47, 0x65, + 0x12, 0xF0, 0x31, 0x90, 0x08, 0x00, 0xA4, 0xDD, 0x28, 0x61, 0x8C, 0xD3, + 0x74, 0x61, 0x82, 0x71, 0x91, 0x11, 0x8E, 0xF2, 0xAC, 0xA4, 0x58, 0xFC, + 0xDB, 0x9F, 0xFF, 0xEA, 0x43, 0x2A, 0xCA, 0x02, 0xA7, 0x28, 0x28, 0x2E, + 0xAB, 0xA2, 0xAC, 0x50, 0x08, 0x61, 0xE8, 0xD4, 0x65, 0x9C, 0xB4, 0x77, + 0xC7, 0x63, 0xDF, 0x6C, 0x5B, 0x4A, 0x31, 0x42, 0x10, 0x81, 0xB4, 0x6E, + 0xEA, 0x3A, 0x2F, 0x9F, 0x9F, 0x3B, 0x67, 0x0C, 0xC6, 0x68, 0x56, 0x4E, + 0x69, 0x57, 0xE6, 0x1C, 0xA1, 0x84, 0x28, 0x3D, 0x5D, 0xE6, 0x18, 0xE2, + 0xA6, 0x2D, 0xAA, 0xB2, 0xC8, 0x38, 0xBF, 0xB9, 0xA9, 0xBB, 0xE1, 0xDC, + 0xD6, 0x95, 0xB7, 0xBF, 0x54, 0xB0, 0xA6, 0x79, 0x94, 0x80, 0xE0, 0x63, + 0x37, 0x8E, 0xB3, 0x74, 0xD6, 0x3D, 0x1F, 0xCF, 0x08, 0xA2, 0x57, 0xB7, + 0x57, 0xD7, 0xDB, 0x76, 0x5C, 0x46, 0x51, 0x65, 0x08, 0x12, 0xAD, 0x55, + 0x59, 0xF1, 0xD7, 0xFB, 0x2D, 0x8E, 0xC0, 0xDA, 0x38, 0x2B, 0xF9, 0x72, + 0xEC, 0x94, 0x0E, 0xD7, 0x57, 0xAB, 0x69, 0x9C, 0xCA, 0x9A, 0x73, 0x41, + 0xDB, 0xB2, 0xD8, 0xAD, 0xD6, 0xDA, 0x44, 0x69, 0x6C, 0x37, 0xCC, 0x9F, + 0x9E, 0x8E, 0x88, 0xC2, 0x2C, 0x17, 0xC6, 0x99, 0x69, 0x18, 0xD6, 0x6D, + 0x1B, 0x01, 0x4A, 0x20, 0x05, 0x90, 0x8C, 0xF4, 0x77, 0x37, 0x9B, 0x18, + 0x43, 0x7F, 0x39, 0xDE, 0xDE, 0xDE, 0xC8, 0xC5, 0x76, 0xA7, 0x0E, 0x33, + 0x74, 0xEE, 0x16, 0x44, 0xA8, 0xC8, 0x08, 0xC6, 0x28, 0x44, 0x44, 0x39, + 0x57, 0xD3, 0x12, 0x5C, 0x58, 0xB5, 0x15, 0x27, 0x34, 0x02, 0xE4, 0x23, + 0x6C, 0xDB, 0x8C, 0xD2, 0x18, 0x53, 0x82, 0x08, 0xA7, 0x98, 0x18, 0x42, + 0xD6, 0x58, 0x1F, 0xD2, 0xE5, 0x3C, 0x8E, 0xA3, 0x5D, 0xB4, 0x3B, 0x0F, + 0x63, 0xF1, 0x0B, 0xF5, 0xC5, 0x69, 0x08, 0xF1, 0x5F, 0x7F, 0x78, 0x4F, + 0x08, 0xFD, 0x1F, 0xFE, 0xE3, 0x9F, 0x7E, 0xF3, 0xEB, 0xFB, 0x69, 0x92, + 0x08, 0xE2, 0xB1, 0x1F, 0x30, 0x86, 0x45, 0x59, 0xA4, 0x04, 0x96, 0x49, + 0x79, 0x1F, 0x12, 0x40, 0x98, 0xE0, 0x45, 0xD9, 0x65, 0xD1, 0x55, 0x91, + 0x31, 0xC2, 0x9E, 0x5F, 0x06, 0x9B, 0xAC, 0xD3, 0x3E, 0x25, 0x48, 0x30, + 0xBE, 0xD9, 0x35, 0xAF, 0x6E, 0x76, 0xEB, 0xA6, 0xB6, 0xCE, 0x2D, 0x5A, + 0x8F, 0xE3, 0xBC, 0x98, 0xF8, 0xFE, 0xE7, 0x8F, 0x84, 0xD2, 0xDB, 0x6D, + 0x63, 0x9C, 0xCF, 0xF2, 0x4C, 0x2E, 0x8B, 0xD4, 0x16, 0x20, 0xD8, 0x8F, + 0xDD, 0xB8, 0x98, 0x3C, 0x47, 0xFB, 0xED, 0x3A, 0x46, 0x20, 0x18, 0xC3, + 0x77, 0xD7, 0x57, 0x00, 0x00, 0x25, 0x15, 0xC2, 0xB8, 0x1B, 0xC7, 0x55, + 0x53, 0xBC, 0xDA, 0xEF, 0x86, 0x45, 0xBF, 0x9C, 0xC7, 0x65, 0x31, 0x75, + 0x2D, 0xBA, 0x5E, 0x0F, 0x53, 0xEC, 0xE7, 0xF9, 0xE7, 0x4F, 0x1F, 0x8D, + 0x8B, 0x0F, 0xCF, 0x7D, 0x48, 0x48, 0x2A, 0xED, 0xAC, 0x29, 0xCA, 0xCA, + 0x87, 0x60, 0x8C, 0x0A, 0x31, 0x42, 0x48, 0x7E, 0xFF, 0xAB, 0x6F, 0xEA, + 0x22, 0x9B, 0xA5, 0xD3, 0x1E, 0xFC, 0xEB, 0xF7, 0xEF, 0x83, 0x0F, 0x75, + 0x99, 0x75, 0xFD, 0x32, 0x4C, 0x7A, 0x98, 0x8C, 0x34, 0xAE, 0xEF, 0x66, + 0xA9, 0xFD, 0xA7, 0xA7, 0xF3, 0xCB, 0xA9, 0x7F, 0x3A, 0x74, 0x8F, 0x2F, + 0xFD, 0x34, 0xEB, 0x45, 0x59, 0xEB, 0xBD, 0xB6, 0xE1, 0xF3, 0xD3, 0xE9, + 0x74, 0x1E, 0xB4, 0x0B, 0xA3, 0xB4, 0x08, 0x51, 0x08, 0x60, 0x9E, 0x15, + 0x10, 0x12, 0xC6, 0x58, 0x5B, 0xF0, 0xC3, 0xB9, 0x2B, 0xCB, 0x2C, 0xCF, + 0xB2, 0x18, 0x03, 0xC6, 0xF8, 0xC3, 0xC7, 0x8B, 0x54, 0xEE, 0xEF, 0xEF, + 0x1F, 0x2F, 0xFD, 0x0C, 0x00, 0xBC, 0x74, 0x73, 0x04, 0x50, 0x1B, 0xDB, + 0x4F, 0xFA, 0xF3, 0xC3, 0xD9, 0xBA, 0xB4, 0x48, 0xEB, 0x9C, 0x4F, 0x08, + 0x56, 0x55, 0x89, 0x19, 0x09, 0x09, 0x8C, 0xA3, 0x54, 0x36, 0x3C, 0x7E, + 0x3A, 0xA6, 0x18, 0x41, 0x00, 0x01, 0x24, 0x2E, 0x68, 0x9E, 0x65, 0x11, + 0x02, 0x17, 0x02, 0x13, 0xB8, 0xAE, 0xD8, 0x76, 0x9D, 0x11, 0x02, 0x8B, + 0x82, 0x41, 0x1C, 0x38, 0x4E, 0xDF, 0x7E, 0xF1, 0x6A, 0xD5, 0xE6, 0xEB, + 0xA6, 0x6C, 0xCB, 0x22, 0xCF, 0x98, 0x60, 0x88, 0x61, 0x46, 0x00, 0x1D, + 0x47, 0x33, 0x2F, 0x66, 0x9C, 0x16, 0xE7, 0xC3, 0xBC, 0xA8, 0xB6, 0xC9, + 0xAB, 0x3C, 0x5B, 0xAD, 0x2A, 0x40, 0x82, 0x75, 0x66, 0xB7, 0xDF, 0xAC, + 0x56, 0x75, 0x2E, 0x44, 0x02, 0x78, 0x5A, 0x66, 0xC6, 0x81, 0x89, 0x76, + 0x7B, 0xD5, 0xFE, 0xC3, 0x1F, 0xBF, 0x1C, 0x26, 0xF5, 0xE9, 0xB1, 0xAF, + 0x9A, 0x02, 0xE2, 0x18, 0x93, 0x0F, 0xDE, 0xE6, 0x19, 0xE3, 0x9C, 0x9F, + 0xFB, 0x59, 0x19, 0x17, 0xBC, 0x1F, 0xA7, 0xB9, 0xAA, 0xCA, 0xEB, 0x9B, + 0x9A, 0x51, 0xB0, 0x6E, 0xAB, 0x2F, 0xBF, 0xBC, 0xBB, 0xBD, 0xAD, 0x61, + 0x0A, 0xCE, 0xAA, 0x84, 0x91, 0xC8, 0xF8, 0xAC, 0xFC, 0xE3, 0x61, 0x38, + 0x1C, 0x3F, 0x12, 0x62, 0x94, 0xC1, 0x1F, 0x3E, 0x7D, 0xD6, 0xA6, 0x07, + 0x31, 0x96, 0xDC, 0xBC, 0xFF, 0xF0, 0xF4, 0xFE, 0xF9, 0xA2, 0x8D, 0x3B, + 0x9D, 0x54, 0x53, 0x30, 0xCC, 0xAC, 0x55, 0xF6, 0xC3, 0xA7, 0x11, 0x0B, + 0x16, 0x83, 0x4F, 0x29, 0x60, 0x0C, 0x7F, 0xFA, 0x30, 0xCC, 0x32, 0xE6, + 0x02, 0xEE, 0xF6, 0xF5, 0xE7, 0x17, 0x39, 0xCF, 0x96, 0x73, 0x4A, 0x30, + 0x81, 0x00, 0xC7, 0x94, 0x94, 0x01, 0x4F, 0x0F, 0x03, 0x8A, 0x0E, 0xA1, + 0xEC, 0xE5, 0xF9, 0x10, 0x62, 0xA0, 0x94, 0x7F, 0x7A, 0x18, 0x23, 0xCC, + 0x5E, 0xBD, 0xDA, 0x41, 0xA0, 0x63, 0x8C, 0x8C, 0xF2, 0x71, 0x9A, 0xF2, + 0x62, 0xAD, 0x16, 0xA5, 0x26, 0xE9, 0xBC, 0xF3, 0xDE, 0xEF, 0x77, 0x6B, + 0x6D, 0xAC, 0x10, 0xAC, 0xAE, 0x72, 0x6B, 0x03, 0xA6, 0xB4, 0xC8, 0x78, + 0x59, 0xF0, 0x73, 0x3F, 0x66, 0x8C, 0x49, 0x65, 0x42, 0x88, 0x4D, 0x5B, + 0x7E, 0xF7, 0xED, 0xAB, 0xFB, 0xEB, 0x75, 0x4A, 0xF0, 0x78, 0x1E, 0xCA, + 0x3C, 0xBB, 0xD9, 0xB6, 0x21, 0x84, 0xB6, 0xAD, 0xCF, 0xDD, 0x90, 0x40, + 0x2A, 0x84, 0xA8, 0xCA, 0x22, 0x45, 0xB0, 0xAA, 0xCB, 0x52, 0xF0, 0xFF, + 0xEB, 0xFF, 0xFE, 0x7F, 0x3F, 0x3D, 0x9C, 0x12, 0x40, 0xB3, 0xB6, 0xE3, + 0xB0, 0x38, 0xEF, 0xE7, 0x69, 0x59, 0x16, 0xED, 0x23, 0xE8, 0xFA, 0xB9, + 0x1F, 0x97, 0xC3, 0xA9, 0x53, 0x5A, 0x5B, 0xEB, 0xFA, 0x7E, 0x90, 0x52, + 0x9D, 0xCE, 0xA3, 0x92, 0x12, 0x63, 0x38, 0xCD, 0x76, 0x1C, 0x24, 0xE1, + 0xC4, 0x79, 0x3F, 0x0C, 0x43, 0x37, 0x1D, 0x27, 0x6B, 0xBA, 0x41, 0xFF, + 0xFC, 0xF1, 0xF3, 0xB9, 0xEB, 0x53, 0x82, 0xE3, 0xA4, 0x01, 0xC0, 0x98, + 0x32, 0xEB, 0x7C, 0x5B, 0xE7, 0x9B, 0x55, 0xCD, 0x38, 0x90, 0x52, 0x41, + 0x4C, 0x7C, 0x8A, 0x52, 0x19, 0xE7, 0x7D, 0x82, 0x20, 0xA6, 0x88, 0x20, + 0x64, 0x8C, 0xA6, 0x10, 0x21, 0x22, 0x08, 0xD8, 0xED, 0xBE, 0xC1, 0x84, + 0x7E, 0x7A, 0x38, 0x4A, 0xA5, 0x5F, 0xCE, 0x97, 0xDD, 0xAA, 0x4D, 0x30, + 0x76, 0x43, 0x97, 0x92, 0xBB, 0xB9, 0x2A, 0x31, 0x02, 0x18, 0x21, 0x4C, + 0x93, 0x51, 0x36, 0x06, 0x64, 0x6C, 0x0C, 0x31, 0x20, 0x8A, 0x37, 0x9B, + 0xE6, 0xCD, 0xED, 0x5E, 0x1B, 0xF3, 0xD7, 0x1F, 0x3E, 0x6E, 0x9A, 0xBA, + 0xCA, 0xB8, 0xD6, 0x46, 0x70, 0x9A, 0x71, 0x2E, 0x72, 0xB1, 0x18, 0xCD, + 0x73, 0x02, 0x31, 0xF4, 0x29, 0x70, 0x8E, 0xA1, 0xC5, 0x4A, 0xD9, 0x84, + 0x41, 0x84, 0x29, 0x41, 0xE8, 0x42, 0xCC, 0x73, 0xAE, 0xB4, 0xB3, 0x1E, + 0x4C, 0x8B, 0x1C, 0x95, 0x3C, 0x5D, 0x86, 0x45, 0x1B, 0xEF, 0x7D, 0x5D, + 0x97, 0x08, 0x42, 0x4C, 0xF9, 0x6A, 0xBD, 0x79, 0x39, 0x9E, 0xCB, 0xAA, + 0x28, 0xCA, 0x0C, 0xC2, 0x10, 0xA3, 0x23, 0x04, 0xD5, 0x55, 0x01, 0x09, + 0x74, 0xCE, 0x10, 0x8C, 0x10, 0xC2, 0x31, 0x01, 0x44, 0xB1, 0x28, 0xE8, + 0x66, 0xDD, 0xDE, 0xBF, 0xBA, 0x66, 0x02, 0x13, 0x84, 0x31, 0x41, 0xDE, + 0x3A, 0x10, 0x80, 0x9E, 0x15, 0x27, 0x28, 0x67, 0xC2, 0x6A, 0x4F, 0x10, + 0x24, 0x08, 0x53, 0x48, 0x8E, 0x4F, 0x27, 0x35, 0x2B, 0x46, 0x08, 0x26, + 0x04, 0xF8, 0x84, 0x10, 0xDA, 0x6F, 0xD7, 0x6D, 0x9B, 0x27, 0x80, 0xCB, + 0x5C, 0x48, 0xA9, 0x9A, 0x36, 0x27, 0x18, 0x6E, 0x57, 0xD5, 0xCD, 0x76, + 0x7D, 0xBB, 0x6F, 0xFF, 0xF4, 0x87, 0x3B, 0x1F, 0x5D, 0xF4, 0xB6, 0xCA, + 0xC4, 0xD4, 0x0F, 0x20, 0x85, 0xC7, 0x97, 0xD3, 0xE9, 0x3C, 0x58, 0xE7, + 0xFB, 0x71, 0x51, 0xC6, 0x3E, 0x1D, 0x2E, 0x52, 0xDB, 0xBC, 0x28, 0x29, + 0x23, 0x88, 0x40, 0x42, 0x52, 0x96, 0xA1, 0x3C, 0x67, 0x29, 0x81, 0x79, + 0xD1, 0x00, 0xA4, 0x2A, 0xE7, 0x30, 0x86, 0xB2, 0xC8, 0xAD, 0x94, 0x20, + 0x85, 0x82, 0xA2, 0xAB, 0xCD, 0xEA, 0xF7, 0xDF, 0xBE, 0x2E, 0x38, 0x2B, + 0x72, 0x7E, 0xB5, 0xDB, 0xD4, 0x45, 0x96, 0xE7, 0x82, 0x60, 0x0C, 0x12, + 0x44, 0x08, 0x3B, 0xEB, 0x8B, 0x8C, 0xAF, 0xDA, 0x0A, 0x45, 0x04, 0xFF, + 0xF4, 0xC7, 0x3F, 0xA6, 0x18, 0x52, 0xF0, 0x55, 0x55, 0x86, 0x10, 0x18, + 0x45, 0xDB, 0x55, 0xAD, 0x6D, 0xFC, 0x7F, 0xFE, 0xFC, 0x67, 0xCE, 0x2C, + 0xE7, 0xE2, 0x32, 0xBA, 0xFD, 0xAA, 0xB9, 0xB9, 0xD9, 0xFD, 0xDB, 0xF7, + 0x0F, 0x5A, 0xD9, 0xFB, 0x9B, 0x9B, 0xC4, 0x8A, 0x9F, 0xDF, 0xFF, 0x74, + 0x77, 0xB3, 0xF7, 0x31, 0xBD, 0xFF, 0xF9, 0x23, 0x82, 0xA0, 0x2A, 0xCB, + 0xED, 0x66, 0xF5, 0xCD, 0x9B, 0xBB, 0x61, 0x9A, 0x1F, 0x0F, 0x47, 0xCE, + 0x73, 0xAD, 0x96, 0xEF, 0xBE, 0x7C, 0xEB, 0x9C, 0x4B, 0x29, 0x51, 0xCE, + 0xBA, 0x7E, 0x70, 0xD6, 0x46, 0xEF, 0x31, 0xE3, 0x3E, 0x05, 0x91, 0x0B, + 0x6B, 0x43, 0xD7, 0x0F, 0x5A, 0x9B, 0x37, 0xAF, 0x6F, 0xAC, 0xB3, 0x98, + 0xE0, 0xFE, 0xD2, 0xD7, 0x75, 0x5D, 0xD7, 0x45, 0x4A, 0x10, 0x26, 0xD0, + 0xD4, 0xD9, 0xA6, 0x6D, 0x20, 0xA0, 0xF3, 0x30, 0x79, 0x6B, 0x52, 0xF2, + 0x77, 0xB7, 0x2B, 0xEF, 0xBC, 0x32, 0xEE, 0xE1, 0xB1, 0xEB, 0x46, 0xB9, + 0xDB, 0xE5, 0xD2, 0x6A, 0xE3, 0xE2, 0xF1, 0xB9, 0xA3, 0x94, 0x96, 0x55, + 0x16, 0x42, 0x9A, 0x26, 0x89, 0x31, 0x74, 0x3E, 0x68, 0x6B, 0x39, 0x23, + 0x2C, 0x17, 0x08, 0xA6, 0xBB, 0x57, 0x7B, 0x8C, 0xA0, 0x73, 0x91, 0x67, + 0xE2, 0xE9, 0xC3, 0x23, 0xC1, 0xE9, 0xF7, 0xDF, 0x7D, 0xE1, 0xBC, 0xDD, + 0x6D, 0x4A, 0xA3, 0xFD, 0xF1, 0x3C, 0x77, 0xFD, 0x64, 0xAC, 0xAF, 0xF2, + 0xAC, 0xBF, 0x8C, 0xFF, 0xE1, 0xDF, 0xFF, 0xFE, 0x87, 0x8F, 0x07, 0xE3, + 0xEC, 0xAF, 0xBF, 0xB8, 0x29, 0xDA, 0xFA, 0x2F, 0x3F, 0xFD, 0x5C, 0xE7, + 0x95, 0x56, 0xAE, 0xEB, 0x94, 0x73, 0xC0, 0xC7, 0x64, 0x9C, 0xE7, 0x1C, + 0x29, 0xAD, 0x53, 0x08, 0xAF, 0x6E, 0x37, 0xC1, 0x7B, 0xCA, 0x30, 0x82, + 0x38, 0xCB, 0x58, 0xD1, 0xB0, 0xCD, 0x6A, 0x6D, 0xAC, 0xB6, 0xDA, 0x45, + 0xEB, 0xBB, 0x69, 0x2C, 0x57, 0x85, 0x77, 0x16, 0x63, 0xD4, 0xD4, 0x05, + 0x82, 0xF8, 0xF1, 0xE1, 0x1C, 0x02, 0x30, 0xD6, 0x61, 0x04, 0x67, 0xB9, + 0x28, 0xE5, 0xC7, 0x59, 0x4E, 0xF3, 0x72, 0xEA, 0x16, 0xE3, 0xE2, 0xAE, + 0xC9, 0xBE, 0xFD, 0x7A, 0x5D, 0x56, 0xC8, 0x39, 0x8D, 0x12, 0x5E, 0x57, + 0x6B, 0xC1, 0xB2, 0x10, 0xE6, 0x71, 0xD0, 0x98, 0x52, 0x17, 0xAC, 0xE0, + 0xB4, 0x9B, 0x74, 0xDF, 0xAB, 0xAB, 0x75, 0x96, 0x17, 0xD7, 0x4F, 0x2F, + 0xF3, 0xDB, 0x1B, 0x06, 0xA1, 0x20, 0xC4, 0x4B, 0x3B, 0x9D, 0xBA, 0xB8, + 0xDE, 0x97, 0xFF, 0xFB, 0xFF, 0xF9, 0x3D, 0xB0, 0xCB, 0xEF, 0xBE, 0xBD, + 0x2A, 0x5B, 0xF4, 0xBF, 0xFC, 0xAF, 0x3F, 0x8F, 0x33, 0xDC, 0xEE, 0xF2, + 0xF3, 0x79, 0x29, 0x0A, 0x4C, 0x30, 0x1A, 0x97, 0xF0, 0x74, 0x58, 0x6E, + 0xF6, 0xC5, 0x1F, 0x7F, 0x77, 0xF5, 0xBF, 0xFD, 0x1F, 0xCF, 0xD6, 0xD8, + 0x4D, 0x4B, 0xF7, 0x9B, 0x7C, 0x9E, 0x81, 0x09, 0x69, 0xB5, 0x12, 0xC1, + 0x38, 0x04, 0xD0, 0x34, 0xBB, 0xBC, 0x10, 0x2C, 0x17, 0xCF, 0x87, 0x71, + 0x9C, 0xE5, 0xDD, 0xFD, 0xA6, 0x2C, 0xF0, 0x66, 0x5D, 0x3A, 0x8F, 0x16, + 0x9D, 0xDA, 0x32, 0xEB, 0x2F, 0xE7, 0xA1, 0x57, 0x4A, 0x86, 0x53, 0xBF, + 0xAC, 0xAA, 0xAA, 0x2A, 0x8B, 0x6E, 0x9C, 0x09, 0x41, 0xDE, 0xBB, 0xA2, + 0xCC, 0xB5, 0x76, 0x0C, 0x13, 0xE3, 0x74, 0x95, 0x0B, 0xC6, 0x98, 0x8B, + 0x00, 0x40, 0x7C, 0x73, 0xB5, 0xAD, 0x0B, 0xE8, 0x5D, 0xE8, 0x47, 0x8D, + 0x90, 0xC8, 0x04, 0xE5, 0x8C, 0x58, 0x67, 0x21, 0x24, 0x7F, 0xFF, 0xF1, + 0xC3, 0xF5, 0xF5, 0x9E, 0xC2, 0x58, 0x96, 0xA4, 0x2C, 0x9B, 0x55, 0xDB, + 0x3C, 0x3F, 0xBC, 0x3C, 0x3C, 0x1F, 0xE7, 0x59, 0x19, 0xEF, 0xAF, 0x6E, + 0xB6, 0x2F, 0x2F, 0x27, 0xE7, 0x2D, 0xC6, 0x98, 0x50, 0x4E, 0x19, 0xA5, + 0x94, 0xC4, 0xE0, 0x18, 0x45, 0x94, 0xA6, 0x57, 0x77, 0xB7, 0x30, 0x86, + 0x2C, 0xE3, 0xCE, 0xC6, 0x14, 0x03, 0x23, 0x04, 0x63, 0x8A, 0x11, 0xCA, + 0xCA, 0x7C, 0x91, 0xF6, 0x6F, 0x3F, 0xFC, 0xF4, 0x97, 0x1F, 0xDF, 0x87, + 0x84, 0xA3, 0x8F, 0xAB, 0x55, 0x91, 0x89, 0xBC, 0x2E, 0x0A, 0x8C, 0xB1, + 0xF5, 0xC0, 0x7A, 0x08, 0x61, 0xF8, 0xE6, 0xDD, 0xDE, 0x69, 0xA3, 0x94, + 0xC5, 0x08, 0x25, 0x08, 0xB4, 0x33, 0xE7, 0x73, 0xDF, 0x8F, 0x73, 0x56, + 0x08, 0xE3, 0x3C, 0x21, 0xE4, 0x8B, 0xB7, 0xB7, 0x72, 0x51, 0xD6, 0xC5, + 0x9A, 0x07, 0x0F, 0x01, 0x2F, 0x1A, 0x27, 0xCD, 0xD3, 0xE3, 0x11, 0x02, + 0xD2, 0xD6, 0xE5, 0x20, 0xD5, 0xF5, 0x55, 0xEE, 0xBD, 0xB4, 0xCE, 0x17, + 0x59, 0x31, 0xCF, 0xDE, 0x85, 0x58, 0xE5, 0x55, 0x51, 0x14, 0x52, 0x8F, + 0x59, 0x91, 0x79, 0x97, 0xD6, 0x75, 0xB9, 0x59, 0x95, 0xA7, 0x7E, 0x50, + 0x0A, 0x66, 0x98, 0x0D, 0xE3, 0xF0, 0x7C, 0x3A, 0x7D, 0xFD, 0xD5, 0x2B, + 0x9E, 0xF1, 0x8F, 0x0F, 0x2F, 0xDD, 0xA2, 0x29, 0x4D, 0x8B, 0x9C, 0x6E, + 0xAF, 0x76, 0xB7, 0x57, 0xEB, 0x55, 0x59, 0x42, 0x84, 0x16, 0x69, 0x53, + 0x04, 0xD6, 0x7A, 0x4C, 0x90, 0xD2, 0x6E, 0x9A, 0x95, 0xD4, 0x76, 0x9E, + 0x66, 0x08, 0x80, 0x77, 0x96, 0x31, 0x06, 0x00, 0x6A, 0xAA, 0xFC, 0x7A, + 0xBB, 0x71, 0x09, 0xB9, 0x94, 0x10, 0xB2, 0x9C, 0x21, 0x0C, 0xA1, 0x52, + 0x9A, 0x51, 0x0A, 0x29, 0x09, 0x31, 0x28, 0xAD, 0x2F, 0xC7, 0x8E, 0xE7, + 0x9C, 0x30, 0x81, 0x11, 0x89, 0x29, 0x38, 0x67, 0x28, 0xE5, 0xBF, 0x18, + 0xD9, 0x52, 0x48, 0xD6, 0x98, 0x2C, 0x2B, 0x57, 0x75, 0xC3, 0x08, 0x20, + 0x18, 0x21, 0x80, 0x0F, 0xCF, 0xE3, 0x7E, 0xBB, 0xC1, 0x18, 0x6A, 0xB5, + 0x58, 0x6F, 0x8D, 0x0D, 0x55, 0x59, 0x16, 0x45, 0xC6, 0x39, 0x9F, 0xE5, + 0x84, 0x29, 0xD3, 0xCE, 0x40, 0x8C, 0x9D, 0xB1, 0x0F, 0x9F, 0xCF, 0x79, + 0xC6, 0x36, 0xAB, 0xD6, 0x99, 0x50, 0x55, 0x05, 0x17, 0x51, 0x2E, 0x2F, + 0x10, 0x40, 0xBD, 0x44, 0xAD, 0x03, 0xA6, 0xF0, 0xE5, 0xD8, 0x85, 0x94, + 0x10, 0x21, 0xD6, 0xC4, 0x22, 0xCF, 0x7F, 0x31, 0x57, 0x41, 0x88, 0x8B, + 0xB2, 0x32, 0xDA, 0xD5, 0x55, 0x56, 0x57, 0xFC, 0xE9, 0xE9, 0x80, 0x08, + 0xC9, 0xCA, 0x0C, 0x42, 0xE4, 0x4C, 0xCC, 0x19, 0xDE, 0xD4, 0xAB, 0xCD, + 0x6A, 0x1D, 0x63, 0x8A, 0xDE, 0x0A, 0x4A, 0xF2, 0x9C, 0x2F, 0xCB, 0xA2, + 0x94, 0xE1, 0x59, 0x41, 0x18, 0x81, 0x29, 0x09, 0xC1, 0x62, 0x8A, 0x87, + 0x73, 0xFF, 0xE1, 0xE3, 0x03, 0x84, 0x60, 0xB3, 0x6E, 0x30, 0x86, 0xFD, + 0x20, 0xE1, 0xAF, 0xBF, 0xFE, 0xC6, 0x39, 0x97, 0x67, 0x82, 0x31, 0x1C, + 0x62, 0xE0, 0x94, 0xC2, 0xE8, 0xAF, 0xF6, 0x3B, 0x63, 0x74, 0x8A, 0x0A, + 0xB3, 0xF4, 0xF9, 0xE5, 0xB4, 0x5E, 0x5D, 0xB9, 0x58, 0xD9, 0xC8, 0x5B, + 0x91, 0x9E, 0x0F, 0x87, 0xC3, 0x79, 0xB8, 0x5C, 0x4E, 0x59, 0xC6, 0x63, + 0x8C, 0x9C, 0xB2, 0xAB, 0xDD, 0xA6, 0x29, 0xC5, 0xEB, 0xFB, 0x9B, 0xBF, + 0xFE, 0xFD, 0xE1, 0xD0, 0x0D, 0x94, 0x60, 0x1F, 0xFC, 0xFD, 0x7E, 0x7D, + 0x77, 0x75, 0xAD, 0x8C, 0xED, 0xA7, 0xD9, 0x38, 0x2F, 0xE5, 0xA2, 0xA5, + 0x34, 0xD6, 0xB4, 0xEB, 0x6D, 0x53, 0x17, 0xD3, 0x22, 0x13, 0x80, 0x4F, + 0xCF, 0xCF, 0x10, 0x80, 0xD7, 0xF7, 0xF7, 0x00, 0x46, 0x63, 0x0D, 0xC6, + 0xB8, 0xAA, 0xCA, 0xCB, 0x79, 0x90, 0x52, 0x5F, 0xDF, 0x6C, 0x05, 0xA7, + 0x55, 0xC1, 0x37, 0x6D, 0xAD, 0xBB, 0x0B, 0x04, 0x98, 0x66, 0x99, 0xB3, + 0x6E, 0x99, 0xE5, 0xAC, 0xCC, 0x28, 0xF5, 0x7E, 0xDF, 0x70, 0x8A, 0x3F, + 0x3F, 0x9F, 0x16, 0x69, 0x7F, 0x01, 0xBB, 0x94, 0xB6, 0xDA, 0xE8, 0x37, + 0xAF, 0x6E, 0x63, 0x0C, 0xFD, 0x38, 0x23, 0x8C, 0x10, 0x82, 0xCE, 0xDA, + 0xF5, 0xA6, 0xD9, 0x6D, 0xDA, 0xEE, 0xD2, 0x8B, 0x8C, 0xE5, 0x4D, 0x31, + 0x0D, 0x23, 0x4A, 0x69, 0x1A, 0x25, 0x23, 0x18, 0x63, 0x34, 0x8C, 0x66, + 0x5A, 0x54, 0x99, 0x31, 0x4A, 0xE9, 0x30, 0x6B, 0x6F, 0xC3, 0x7F, 0xFA, + 0x0F, 0xFF, 0x7C, 0x1A, 0x96, 0x8C, 0xB3, 0xCD, 0xBA, 0xFC, 0xEB, 0x87, + 0xCF, 0x9F, 0x3F, 0xBF, 0xAC, 0xDB, 0xC6, 0x87, 0xF8, 0xEB, 0x2F, 0x5E, + 0x77, 0xA3, 0xFC, 0xFB, 0xC7, 0xC3, 0xCD, 0xF5, 0xF6, 0x78, 0x3E, 0x49, + 0xAD, 0x36, 0x75, 0xF9, 0xF6, 0x76, 0x17, 0x9C, 0xB7, 0x3E, 0x30, 0x41, + 0x21, 0x84, 0xEB, 0x55, 0x75, 0x7B, 0xBD, 0x39, 0x9E, 0x0F, 0x6D, 0x53, + 0x2F, 0x8B, 0xE1, 0x0C, 0x1C, 0x86, 0x29, 0x81, 0xA0, 0x94, 0x49, 0x91, + 0x28, 0xE5, 0xA4, 0xB6, 0xC6, 0xD8, 0xE4, 0x7D, 0x5D, 0x55, 0x8C, 0x31, + 0x0C, 0x43, 0xC6, 0x89, 0x54, 0x6A, 0x8E, 0x8A, 0x00, 0xD4, 0x06, 0x6F, + 0x0A, 0xCC, 0x00, 0x00, 0x20, 0x00, 0x49, 0x44, 0x41, 0x54, 0x70, 0xBA, + 0x6A, 0x51, 0x4A, 0xDE, 0x07, 0x53, 0x72, 0xCA, 0x30, 0x1F, 0xA5, 0x43, + 0x28, 0x9E, 0x8E, 0x33, 0x80, 0x40, 0x07, 0x17, 0x21, 0xC1, 0x48, 0xBF, + 0xBA, 0xDE, 0x3B, 0x8B, 0xCF, 0x83, 0xCA, 0x98, 0xDC, 0xB6, 0x3B, 0x80, + 0x79, 0xB7, 0xCC, 0xA7, 0x8B, 0xBE, 0xBF, 0xDF, 0x15, 0x19, 0x78, 0x78, + 0x59, 0xAE, 0x76, 0x59, 0x4D, 0xFC, 0x7F, 0xFB, 0xE1, 0xF0, 0x78, 0x56, + 0xF7, 0x77, 0x37, 0x8B, 0x74, 0x09, 0xC5, 0xE8, 0x16, 0x29, 0xE5, 0xD3, + 0xD1, 0xB4, 0x8D, 0x78, 0x75, 0x53, 0x9E, 0xCE, 0xFD, 0x5F, 0xFE, 0x36, + 0x31, 0x82, 0x9A, 0x92, 0x59, 0x1D, 0xBB, 0xD1, 0x15, 0x15, 0xA5, 0x04, + 0x06, 0x9F, 0x56, 0xEB, 0x86, 0x10, 0xBA, 0x4C, 0x3A, 0x84, 0xE4, 0x63, + 0x2C, 0x6B, 0xF2, 0xE6, 0xF5, 0x0A, 0x41, 0xC0, 0x45, 0xF5, 0xF1, 0xE1, + 0x58, 0x95, 0x02, 0x04, 0x15, 0x22, 0x20, 0x28, 0x7B, 0x7C, 0x1E, 0x62, + 0x00, 0x39, 0x63, 0x2F, 0xA7, 0x71, 0x98, 0x15, 0x22, 0x28, 0xF9, 0xB8, + 0xDF, 0xAE, 0x16, 0x69, 0x86, 0x49, 0x72, 0x8A, 0xBE, 0x7D, 0xFB, 0xFA, + 0x3C, 0x4A, 0x80, 0x61, 0x51, 0xE4, 0x75, 0xC9, 0x93, 0x93, 0x31, 0x40, + 0x2E, 0x2A, 0x96, 0x09, 0x4A, 0x41, 0xB0, 0x06, 0x21, 0xB4, 0x6A, 0x57, + 0x4A, 0xDB, 0xAA, 0xAC, 0xCF, 0xA7, 0xC7, 0xAC, 0xC2, 0xB7, 0x57, 0x57, + 0x20, 0x82, 0xCF, 0x9F, 0x9E, 0xBC, 0x8D, 0x8B, 0x54, 0xEF, 0x1F, 0xCE, + 0xDB, 0xED, 0x76, 0x1C, 0xFB, 0x59, 0x29, 0x1F, 0x82, 0x31, 0xA1, 0xA8, + 0x0A, 0x0A, 0xD3, 0xAF, 0xBE, 0xBA, 0xDF, 0x6E, 0xEA, 0x90, 0x1C, 0x67, + 0xE5, 0xD0, 0x2B, 0x42, 0x40, 0x59, 0x88, 0x71, 0xD2, 0x84, 0xA2, 0x18, + 0x22, 0x42, 0x88, 0x10, 0x9C, 0x12, 0x92, 0xCB, 0xFC, 0xE1, 0xD3, 0xE3, + 0xF3, 0x61, 0x68, 0xAA, 0xAC, 0xAE, 0x0B, 0x8C, 0xB9, 0xF3, 0x1E, 0x93, + 0xB4, 0xDD, 0xAD, 0x13, 0x80, 0x08, 0x43, 0x60, 0xEC, 0xE5, 0x32, 0xD4, + 0x75, 0xDD, 0xB4, 0x65, 0xDF, 0x8D, 0xEB, 0xA6, 0x9C, 0x94, 0xB4, 0x20, + 0x61, 0x04, 0x43, 0xF4, 0xFB, 0xF5, 0x1A, 0x02, 0xFC, 0xAF, 0xDF, 0xFF, + 0x8D, 0x42, 0x2C, 0xB0, 0xBB, 0xA8, 0x20, 0x8A, 0xFA, 0xCD, 0x6D, 0xDD, + 0x5F, 0xE4, 0xF3, 0xD3, 0x78, 0x7B, 0xBB, 0xF1, 0x00, 0xC5, 0x30, 0x3B, + 0x3B, 0x63, 0x8C, 0x28, 0x11, 0xD6, 0x25, 0x84, 0x0B, 0xA3, 0x1C, 0x63, + 0xB1, 0x28, 0x79, 0x4C, 0x68, 0x9E, 0x64, 0x88, 0x71, 0x31, 0x2A, 0x46, + 0xB0, 0x5D, 0x6F, 0x9B, 0xA2, 0xE6, 0x14, 0x84, 0x08, 0x9C, 0x0B, 0x52, + 0x4E, 0x36, 0x3A, 0x44, 0xA0, 0xE0, 0xA4, 0xCE, 0xF9, 0xA6, 0xAE, 0xB5, + 0xF6, 0xE3, 0xA2, 0xAC, 0x8B, 0xCB, 0x62, 0xA4, 0x32, 0x45, 0x99, 0x59, + 0xEF, 0x9C, 0x0F, 0x10, 0xC2, 0xA6, 0xAE, 0x11, 0xC2, 0x3E, 0x04, 0xCE, + 0xE8, 0xD3, 0xE3, 0x61, 0x9E, 0x97, 0xB6, 0x29, 0xF3, 0x8C, 0x8A, 0xAC, + 0x84, 0x10, 0x16, 0x39, 0x7C, 0x7E, 0x1A, 0x9A, 0xAA, 0x28, 0xCB, 0xCC, + 0xFA, 0xE8, 0x5C, 0x60, 0x9C, 0x20, 0x04, 0xAC, 0xD1, 0x2E, 0x06, 0xED, + 0x55, 0x96, 0x67, 0xB3, 0x5C, 0x9C, 0xF7, 0x21, 0x41, 0x04, 0x21, 0xA5, + 0x1C, 0x84, 0x98, 0xE7, 0x59, 0x51, 0x94, 0x20, 0x25, 0xCE, 0x58, 0x8A, + 0xB1, 0xC8, 0x8B, 0x5F, 0x2C, 0x9C, 0x04, 0x42, 0x6F, 0x9D, 0x75, 0x5E, + 0x2F, 0x7E, 0xDD, 0x36, 0xF3, 0x3C, 0x6B, 0x6B, 0x98, 0xA0, 0x84, 0xA2, + 0x10, 0xC1, 0x38, 0x2B, 0x17, 0xC0, 0xAE, 0x69, 0x63, 0x80, 0x4A, 0x7B, + 0xCA, 0x48, 0x88, 0xC1, 0x7A, 0x73, 0x77, 0x55, 0x46, 0xBD, 0x1C, 0x0E, + 0x97, 0xAB, 0xAB, 0xAB, 0x87, 0x97, 0xA7, 0xCB, 0xA0, 0xDA, 0x32, 0x5B, + 0xAF, 0xEA, 0x3C, 0xCB, 0x39, 0xA1, 0x79, 0x91, 0x11, 0x46, 0x95, 0x72, + 0xCA, 0x78, 0xED, 0x1C, 0x82, 0x70, 0x1C, 0x27, 0xEF, 0xDD, 0xDB, 0x57, + 0x5B, 0x88, 0xD1, 0x2C, 0xCD, 0x34, 0x59, 0x44, 0x20, 0x85, 0x88, 0x53, + 0x0E, 0x02, 0xE0, 0x04, 0x12, 0x14, 0x08, 0xE5, 0x31, 0xC2, 0xFD, 0x6E, + 0x53, 0xD6, 0x55, 0xF0, 0xEE, 0x97, 0x3A, 0x7F, 0x6D, 0x6D, 0x51, 0x54, + 0x87, 0xC3, 0x81, 0x12, 0xBC, 0xDD, 0x6C, 0xA6, 0x79, 0x16, 0x42, 0xC0, + 0x77, 0xAF, 0x5F, 0x1B, 0x6D, 0x29, 0x25, 0x9C, 0xD3, 0xA2, 0xC8, 0x82, + 0x0F, 0xD6, 0xC8, 0xCD, 0xBA, 0x2A, 0x45, 0x41, 0x29, 0x7B, 0xFF, 0x7C, + 0x09, 0x11, 0x6D, 0x77, 0xAF, 0x10, 0x02, 0xD3, 0xD8, 0x37, 0x05, 0xF9, + 0xEB, 0xFB, 0x8F, 0x4E, 0x2F, 0x22, 0xE3, 0x84, 0xD0, 0xE7, 0xC3, 0xE9, + 0x5F, 0xFE, 0xE1, 0x8F, 0xAB, 0x4A, 0xCC, 0x6A, 0x0A, 0x11, 0xFF, 0xF9, + 0x87, 0x8F, 0xB3, 0x54, 0xD6, 0x98, 0x77, 0xF7, 0xFB, 0xBB, 0xAB, 0x5D, + 0x4C, 0xCC, 0x38, 0xAB, 0x8C, 0x1E, 0xE7, 0xC5, 0x87, 0xF8, 0x72, 0x38, + 0x64, 0x9C, 0xBF, 0x7B, 0xF7, 0x0E, 0xC1, 0xE4, 0x83, 0x8B, 0x10, 0x9E, + 0xCF, 0x1D, 0x4C, 0x90, 0x10, 0x5C, 0x56, 0xB9, 0x73, 0x0E, 0x23, 0x04, + 0x31, 0xF2, 0x3E, 0x69, 0xA5, 0xAD, 0xD1, 0x57, 0xD7, 0x5B, 0x08, 0x61, + 0x46, 0x71, 0x23, 0x22, 0x04, 0x90, 0xF2, 0xF2, 0x7C, 0x5E, 0x46, 0x69, + 0x10, 0x4C, 0xD3, 0x3C, 0xBF, 0x7E, 0x75, 0x65, 0xAC, 0x7D, 0x39, 0x8D, + 0x21, 0x24, 0x46, 0x90, 0x0B, 0xE9, 0xF9, 0x74, 0xAA, 0x0A, 0xD1, 0xD6, + 0xCD, 0xF1, 0x72, 0x71, 0xCE, 0x6F, 0x56, 0x0D, 0xA3, 0xF8, 0x74, 0xEA, + 0xAA, 0xAA, 0xFC, 0xE2, 0xED, 0xDD, 0x4F, 0x1F, 0x3E, 0x67, 0x82, 0x15, + 0x25, 0xDF, 0x6D, 0xEA, 0xA1, 0x9F, 0xC7, 0x69, 0xA1, 0x94, 0xFD, 0xFD, + 0xC7, 0xC7, 0x3C, 0x13, 0xFF, 0xF8, 0xFB, 0x6F, 0x9E, 0x4F, 0xE7, 0xAE, + 0x9B, 0x10, 0x64, 0x6F, 0xEE, 0xF7, 0xC1, 0x9B, 0xAA, 0x6C, 0xD6, 0x4D, + 0xF3, 0xE3, 0xE7, 0xE7, 0x9F, 0x3E, 0x7C, 0xDE, 0xB4, 0xE5, 0xFE, 0x6A, + 0x7B, 0x3A, 0x76, 0x84, 0x90, 0x80, 0xD8, 0xA5, 0xEB, 0xAB, 0x42, 0xA4, + 0xE8, 0x9F, 0x8F, 0x97, 0x6F, 0xDE, 0x5C, 0xBF, 0xBE, 0xDE, 0x8E, 0xF3, + 0x62, 0x43, 0x80, 0x08, 0xCA, 0xC5, 0xEC, 0xB6, 0xEB, 0xA6, 0xCE, 0x10, + 0x0C, 0x08, 0xA1, 0x0F, 0x0F, 0xC7, 0x7F, 0xF8, 0xFD, 0xBB, 0x51, 0xEA, + 0x84, 0x7C, 0x91, 0x89, 0xB1, 0x73, 0x20, 0x81, 0x2C, 0xC7, 0x30, 0x05, + 0xE3, 0x89, 0x36, 0x20, 0x9A, 0x0E, 0x13, 0x74, 0xB5, 0xDF, 0x56, 0x79, + 0x3A, 0xCF, 0x87, 0x9C, 0x63, 0x37, 0x2F, 0x88, 0xE7, 0x8B, 0x1A, 0x09, + 0x02, 0xDE, 0xD3, 0xCF, 0xCF, 0xC3, 0xB0, 0x8C, 0xC3, 0xE4, 0xFB, 0xDE, + 0x57, 0x39, 0xDA, 0x6C, 0x73, 0x1D, 0x82, 0xA0, 0xE0, 0x7E, 0x5B, 0xFA, + 0x08, 0x32, 0x81, 0x97, 0x45, 0xA3, 0x10, 0x02, 0xE6, 0x4C, 0x08, 0x63, + 0x3D, 0xA3, 0x84, 0x30, 0x5C, 0x94, 0xB5, 0xD5, 0xFA, 0xE9, 0xA9, 0xDF, + 0xBE, 0xFA, 0xA6, 0x2E, 0x05, 0x42, 0x49, 0x4A, 0xED, 0x23, 0x20, 0x48, + 0xFD, 0xF5, 0xCF, 0x7F, 0x9E, 0x16, 0xF0, 0x87, 0xEF, 0xAE, 0x8E, 0xA7, + 0xF9, 0xE3, 0xC3, 0xD0, 0xF5, 0xD6, 0x2A, 0x50, 0x15, 0x18, 0x02, 0x38, + 0xCE, 0x9E, 0x32, 0xC4, 0x19, 0xC1, 0x04, 0x31, 0x46, 0x9F, 0x9F, 0x87, + 0x32, 0x67, 0x99, 0x40, 0x4D, 0x5B, 0x32, 0xC1, 0x09, 0x72, 0xF7, 0xD7, + 0xAD, 0x8B, 0x69, 0x98, 0x2D, 0x67, 0x60, 0x92, 0x4B, 0x5D, 0xAD, 0xE7, + 0xC9, 0x9C, 0xCF, 0xD2, 0xBA, 0x00, 0x21, 0xD4, 0x2E, 0x30, 0x4E, 0x17, + 0x69, 0x08, 0x66, 0xD3, 0xB0, 0x68, 0xE5, 0x00, 0x22, 0x5F, 0x5E, 0x6F, + 0x00, 0x80, 0x11, 0xD1, 0xCD, 0xBA, 0x7E, 0x3C, 0x9E, 0x29, 0x81, 0x29, + 0x25, 0x67, 0x74, 0xD3, 0x6E, 0x46, 0x69, 0xB6, 0xAB, 0x6A, 0xDD, 0x56, + 0x09, 0x24, 0x82, 0xA1, 0xF3, 0xD1, 0x19, 0x63, 0xDC, 0xBC, 0xDF, 0x97, + 0x14, 0x50, 0x82, 0xD8, 0xC3, 0xC3, 0x67, 0xE7, 0xED, 0xB4, 0x78, 0xA9, + 0xDD, 0x7E, 0xB7, 0xB7, 0xC1, 0x1D, 0x4E, 0x47, 0xAD, 0xBC, 0x0D, 0x10, + 0x20, 0x78, 0xB5, 0xAE, 0xFE, 0xF4, 0xDB, 0x6F, 0x2E, 0xFD, 0x1C, 0x93, + 0x0B, 0x3E, 0xF9, 0x08, 0x19, 0xA3, 0xC3, 0x2C, 0x09, 0x25, 0xDE, 0xF9, + 0x5F, 0x70, 0x9C, 0x3C, 0xCF, 0xE7, 0x59, 0xFD, 0xEA, 0xCB, 0xDB, 0x75, + 0x5D, 0x8C, 0x93, 0xBD, 0xBB, 0x5E, 0x9F, 0x7B, 0x75, 0xBE, 0x0C, 0x94, + 0x93, 0xF5, 0x9A, 0x53, 0x4A, 0x09, 0x42, 0x11, 0x84, 0x79, 0x58, 0xF6, + 0xBB, 0x15, 0x40, 0x00, 0x41, 0x2C, 0x17, 0x49, 0x08, 0x9E, 0x97, 0x65, + 0x56, 0xD6, 0x45, 0x78, 0x3E, 0x1E, 0xBF, 0x7C, 0x75, 0x23, 0x6D, 0xD4, + 0xDE, 0x62, 0x8C, 0x86, 0xE3, 0x53, 0x6F, 0x42, 0x5E, 0xD4, 0x95, 0x80, + 0x39, 0x2F, 0x94, 0x8C, 0xCA, 0x48, 0xCC, 0x90, 0xD6, 0xDA, 0x3B, 0x09, + 0x23, 0xE6, 0x59, 0x56, 0x94, 0x3C, 0xE3, 0xED, 0xF3, 0xF3, 0x85, 0x92, + 0x40, 0x05, 0xA1, 0x84, 0x1B, 0xAB, 0x19, 0xA5, 0xC7, 0xD3, 0xA5, 0x2E, + 0x37, 0xF3, 0x32, 0x6A, 0x6B, 0xEA, 0x52, 0xAC, 0xEA, 0xD5, 0xA5, 0x5B, + 0xCA, 0x92, 0x63, 0x1C, 0xBF, 0x7C, 0xBB, 0xC3, 0x90, 0xEB, 0x65, 0x94, + 0xF3, 0xF2, 0xE3, 0xE7, 0x91, 0x32, 0xEC, 0x62, 0xEC, 0x87, 0x39, 0xC6, + 0x58, 0x55, 0xA5, 0x73, 0x1E, 0x60, 0x48, 0x29, 0xC9, 0xF2, 0x1C, 0x21, + 0x8C, 0x08, 0xB1, 0xDA, 0x64, 0x9C, 0xC4, 0x60, 0x18, 0x67, 0x55, 0x25, + 0x32, 0xC1, 0x53, 0xC2, 0xC7, 0x73, 0xAF, 0xA4, 0xE3, 0x94, 0x10, 0x0C, + 0xFB, 0x41, 0x4E, 0x93, 0xD6, 0xD6, 0x15, 0x39, 0x2F, 0x0B, 0xC1, 0xB3, + 0x1C, 0xE3, 0x00, 0x90, 0x05, 0x20, 0x50, 0xC6, 0x6C, 0x70, 0xFD, 0x20, + 0x9F, 0x9E, 0x2E, 0xFB, 0xAB, 0x35, 0x65, 0x34, 0x13, 0x19, 0x42, 0x10, + 0x04, 0xC4, 0x09, 0x05, 0x28, 0xFA, 0xE0, 0x87, 0x41, 0x73, 0x91, 0x6D, + 0x9A, 0x7A, 0x19, 0x14, 0x08, 0x10, 0x40, 0xF4, 0x74, 0x38, 0x87, 0xE0, + 0x04, 0xC7, 0xDE, 0x87, 0xA6, 0xA9, 0xBC, 0x8F, 0xF3, 0x62, 0xEB, 0xAA, + 0x01, 0x09, 0x06, 0x00, 0x00, 0x8C, 0x52, 0x1B, 0x29, 0xF5, 0xBB, 0xD7, + 0xD7, 0x9B, 0x36, 0xCF, 0x32, 0x16, 0xAC, 0xF9, 0xF9, 0xE7, 0x9F, 0xCB, + 0x22, 0xFF, 0xE6, 0x8B, 0xD7, 0x4A, 0xEB, 0x08, 0x40, 0x02, 0x28, 0xC4, + 0x64, 0x43, 0x34, 0xD6, 0x69, 0xE7, 0x84, 0x60, 0x56, 0x87, 0xD3, 0x79, + 0x00, 0x29, 0x06, 0x67, 0x43, 0x8C, 0xBF, 0xF9, 0xEE, 0x1D, 0xC1, 0x84, + 0x40, 0xB4, 0x2C, 0xF3, 0x7A, 0xB5, 0xC5, 0x00, 0x81, 0xE0, 0xA6, 0x65, + 0x50, 0xD6, 0x31, 0x8C, 0x57, 0x4D, 0x85, 0x30, 0x75, 0x1E, 0x30, 0x46, + 0x4F, 0xC3, 0x84, 0x21, 0x20, 0x18, 0x65, 0x22, 0xA3, 0x08, 0xDE, 0xDF, + 0x5F, 0x51, 0xCA, 0x83, 0xF3, 0xF0, 0x3F, 0xFF, 0xA7, 0xFF, 0x68, 0x8C, + 0x7D, 0x7E, 0x3C, 0x9D, 0x2F, 0x5D, 0x9E, 0xF1, 0xE8, 0x03, 0xC2, 0x20, + 0x85, 0xD8, 0x54, 0x05, 0xCF, 0xEA, 0x88, 0x73, 0xB3, 0x4C, 0xC9, 0x0F, + 0x84, 0x67, 0x31, 0xE2, 0x9F, 0x3E, 0x3D, 0x02, 0x08, 0xF7, 0x6D, 0x35, + 0x6A, 0xE7, 0xBC, 0x17, 0x8C, 0xDF, 0x5D, 0x5F, 0xF7, 0x97, 0x97, 0xED, + 0xA6, 0x98, 0x95, 0xEF, 0x27, 0xC3, 0x28, 0xDC, 0xD6, 0x59, 0x55, 0x94, + 0x00, 0x62, 0xE7, 0x51, 0xD7, 0x5F, 0x8C, 0xD3, 0xB3, 0x34, 0xFD, 0x38, + 0x69, 0xAD, 0xCA, 0xB2, 0xA0, 0x84, 0x51, 0xCA, 0x20, 0x48, 0x08, 0x63, + 0x80, 0x92, 0x35, 0x9A, 0x31, 0xD1, 0x34, 0xCD, 0xB2, 0x2C, 0x87, 0x97, + 0x97, 0xCD, 0x76, 0x03, 0x00, 0x24, 0x84, 0xCC, 0xD3, 0x4C, 0x19, 0xC9, + 0xF3, 0x6C, 0xEA, 0xFA, 0x9B, 0x7D, 0x93, 0x0B, 0x21, 0xB5, 0x97, 0x26, + 0xF8, 0x44, 0x18, 0x8E, 0x7D, 0x7F, 0xB9, 0xBB, 0xB9, 0x06, 0x08, 0x8C, + 0xB3, 0x46, 0x10, 0xF9, 0x10, 0x1E, 0x1E, 0x5F, 0xDA, 0xB6, 0x62, 0x8C, + 0xCA, 0x45, 0xCF, 0x6A, 0x69, 0x9B, 0xA6, 0xEB, 0x06, 0x08, 0x22, 0x48, + 0xE0, 0xFE, 0xE6, 0xA6, 0x2A, 0xF2, 0x53, 0xDF, 0x5B, 0x6B, 0x76, 0xDB, + 0xFA, 0x8B, 0x57, 0xD7, 0x04, 0xA5, 0x6F, 0x7E, 0x75, 0xE7, 0x42, 0xB8, + 0x5C, 0xA6, 0x4C, 0xF0, 0xA6, 0xAC, 0x86, 0xD9, 0x98, 0x45, 0x1B, 0xE9, + 0x5F, 0xCE, 0x87, 0xFD, 0x6E, 0xED, 0x0D, 0x4A, 0x09, 0x2E, 0xDA, 0x28, + 0x63, 0x08, 0x27, 0xE7, 0xF3, 0xA0, 0xA4, 0x7A, 0xE9, 0xC6, 0xB2, 0x6A, + 0xA3, 0x57, 0x55, 0x21, 0xBC, 0x75, 0x94, 0xF3, 0x7F, 0xFC, 0xED, 0x57, + 0xEF, 0x3F, 0x3C, 0x28, 0x65, 0x00, 0x84, 0x84, 0x92, 0x18, 0x63, 0x5E, + 0xAD, 0x8E, 0xE7, 0xC3, 0xAA, 0x66, 0x94, 0x30, 0xA9, 0xF4, 0x6F, 0x7F, + 0xFD, 0xAA, 0x1F, 0x96, 0xF5, 0x36, 0xDB, 0x34, 0x15, 0xC5, 0xCC, 0x7B, + 0x0B, 0x41, 0x8C, 0x21, 0x14, 0x75, 0x73, 0x1E, 0xA4, 0x99, 0xBB, 0x4C, + 0x70, 0x4E, 0xD9, 0x7C, 0x79, 0x38, 0x4F, 0x63, 0xD5, 0xAC, 0x9D, 0x99, + 0x07, 0x39, 0x07, 0xEF, 0x11, 0xE4, 0x0F, 0x27, 0xF5, 0x74, 0x18, 0x9B, + 0x8A, 0xD9, 0x10, 0x95, 0x46, 0x97, 0x5E, 0x55, 0x15, 0x25, 0x38, 0x5E, + 0xAD, 0x0B, 0xEF, 0xD3, 0x6C, 0x4C, 0x2E, 0xE8, 0x38, 0x78, 0xC6, 0xE0, + 0xFD, 0x55, 0x0E, 0x93, 0x97, 0x96, 0x42, 0x9C, 0x9A, 0x2A, 0x4B, 0x09, + 0x1F, 0xCF, 0x4B, 0x40, 0xEC, 0xCD, 0xEB, 0x7B, 0x80, 0x30, 0x46, 0x70, + 0x38, 0x1D, 0xB2, 0xA2, 0xBA, 0xB9, 0xDB, 0x0B, 0x30, 0x4C, 0xA7, 0x97, + 0x8F, 0x9F, 0xFA, 0x0F, 0x4F, 0xCB, 0x65, 0x94, 0xD7, 0xBB, 0x0D, 0xA7, + 0xEC, 0x78, 0xEA, 0x8B, 0x22, 0x93, 0x8B, 0x87, 0x30, 0xB6, 0x15, 0x57, + 0xD6, 0xA7, 0x18, 0x09, 0xA5, 0x59, 0x93, 0x45, 0x6D, 0xAF, 0x37, 0x1B, + 0x07, 0x82, 0xB3, 0x8A, 0x42, 0x5F, 0x16, 0xB9, 0x4D, 0x31, 0x24, 0xCB, + 0xB3, 0xCC, 0x39, 0xE0, 0x23, 0xD0, 0x36, 0x55, 0x65, 0xF5, 0xF1, 0xE1, + 0x28, 0xA5, 0x47, 0x09, 0x4E, 0x52, 0x13, 0x42, 0xEA, 0x22, 0x8F, 0x06, + 0x58, 0xE7, 0x5F, 0xED, 0x73, 0xE7, 0xCD, 0xBA, 0x59, 0x75, 0xB3, 0x99, + 0x74, 0xBC, 0x74, 0x5D, 0x55, 0x35, 0xCF, 0x2F, 0x4F, 0x45, 0x59, 0xE5, + 0x59, 0xB6, 0x69, 0x6A, 0xA5, 0xCD, 0x38, 0x4F, 0x09, 0xA4, 0x69, 0x1A, + 0x9D, 0xF3, 0xB7, 0xD7, 0xDB, 0xFB, 0x9B, 0x2D, 0x86, 0x70, 0xD3, 0x34, + 0xC7, 0x73, 0x37, 0xC9, 0x29, 0x86, 0xB0, 0xD9, 0x54, 0xAC, 0xA8, 0xDE, + 0x7F, 0xF8, 0x6C, 0xAD, 0x2D, 0xF2, 0xA2, 0x1F, 0x55, 0x9E, 0xF3, 0xDF, + 0x7C, 0x75, 0xE7, 0x8D, 0xFD, 0xF0, 0x78, 0xC9, 0xB3, 0x5C, 0x4A, 0x87, + 0x19, 0x2E, 0x8A, 0xFC, 0xC3, 0xA7, 0x93, 0x0B, 0x2E, 0x84, 0xF0, 0x9B, + 0x6F, 0xDF, 0x3C, 0x3D, 0x9F, 0x87, 0x51, 0x52, 0xC6, 0xF6, 0xEB, 0x7A, + 0xDB, 0x96, 0x84, 0xD2, 0xAF, 0xDF, 0xEC, 0x10, 0x66, 0x38, 0x79, 0x4A, + 0x90, 0x0D, 0x0E, 0x21, 0xA2, 0xB4, 0x03, 0x18, 0x30, 0xCC, 0x7C, 0x70, + 0x8B, 0x31, 0xBB, 0x4D, 0xD5, 0x8F, 0xF3, 0x38, 0x2A, 0x46, 0xA9, 0x56, + 0xFE, 0x32, 0xC8, 0xCB, 0xF9, 0x70, 0xBD, 0xDD, 0x40, 0x46, 0x13, 0x08, + 0x3E, 0x38, 0x2F, 0x65, 0xE2, 0x34, 0x2F, 0x18, 0x41, 0xDC, 0x48, 0x4B, + 0x10, 0x49, 0x29, 0xC5, 0x04, 0x07, 0xD9, 0x43, 0x08, 0x11, 0x00, 0x28, + 0xC5, 0xB2, 0x2C, 0x7C, 0x88, 0xCE, 0x24, 0xC1, 0x19, 0xA1, 0xF0, 0xD4, + 0x8D, 0xDB, 0xDD, 0x56, 0x60, 0x3C, 0x8E, 0x63, 0x82, 0x99, 0x33, 0x26, + 0x26, 0x7F, 0x73, 0xD5, 0x16, 0x39, 0xF3, 0x11, 0x40, 0x88, 0x32, 0x8E, + 0x18, 0x63, 0x46, 0x07, 0x46, 0x10, 0x46, 0x48, 0xE9, 0x80, 0x31, 0xEC, + 0x86, 0xF9, 0x32, 0x4C, 0xC6, 0xB9, 0x71, 0x5C, 0x12, 0x48, 0xD6, 0x7B, + 0xEB, 0x42, 0x96, 0x09, 0x48, 0x09, 0x44, 0xB8, 0xAD, 0xB3, 0xFD, 0x2A, + 0xA7, 0x18, 0xB8, 0x98, 0x60, 0x4C, 0xDE, 0x7A, 0xE3, 0x03, 0x13, 0x19, + 0x61, 0x34, 0xC6, 0x80, 0x10, 0x98, 0x47, 0xFB, 0xF7, 0x1F, 0x1E, 0x67, + 0xA3, 0x29, 0xC6, 0x82, 0x60, 0x4C, 0x39, 0x17, 0x2C, 0xCF, 0xE9, 0x34, + 0x4D, 0xD6, 0xFA, 0xD5, 0x2A, 0x2B, 0x6B, 0xF1, 0xE9, 0xF9, 0xA4, 0x8C, + 0xE6, 0x9C, 0x17, 0x45, 0xC1, 0x08, 0x4E, 0x21, 0xAE, 0xAA, 0x62, 0x59, + 0x06, 0x1F, 0x91, 0xF6, 0x08, 0x27, 0x52, 0x15, 0xD5, 0xE5, 0x3C, 0x7E, + 0x7E, 0x78, 0xBE, 0xBB, 0xBD, 0xA2, 0x98, 0xDC, 0xDE, 0xEC, 0x21, 0x0A, + 0xDF, 0xFF, 0xED, 0xBD, 0xD6, 0x6E, 0xB3, 0x5D, 0x33, 0x46, 0x11, 0xC6, + 0x65, 0xC6, 0xEA, 0x26, 0x27, 0x94, 0x3A, 0xE7, 0xF3, 0x8C, 0x20, 0x80, + 0x42, 0xF0, 0x00, 0x62, 0x84, 0x21, 0xA3, 0x88, 0x11, 0x1C, 0x5C, 0x50, + 0xC6, 0xC8, 0x45, 0x41, 0x48, 0xBA, 0xCB, 0x62, 0x83, 0x8F, 0x29, 0x41, + 0x08, 0x10, 0x46, 0x54, 0xB0, 0x14, 0x53, 0x46, 0xF9, 0x38, 0x4B, 0x84, + 0x11, 0xA1, 0x58, 0x2A, 0xD5, 0x54, 0x05, 0x42, 0x89, 0x53, 0xC2, 0x10, + 0xE4, 0x98, 0x01, 0x00, 0x7C, 0x70, 0x4A, 0x19, 0x1F, 0x93, 0x36, 0x8E, + 0x50, 0x0E, 0x52, 0x22, 0x84, 0xAC, 0x9A, 0x5A, 0x1B, 0x37, 0x2F, 0x5A, + 0x30, 0x7A, 0x7B, 0xBD, 0x59, 0xD7, 0x79, 0x2E, 0x04, 0xFC, 0x9F, 0xFF, + 0xA7, 0xFF, 0x11, 0x21, 0x18, 0x00, 0x98, 0xA6, 0xC5, 0x1A, 0x9B, 0x82, + 0x7F, 0xFC, 0xFC, 0x10, 0x9C, 0xCF, 0x33, 0x21, 0xB2, 0x12, 0x42, 0x2C, + 0xC7, 0x43, 0xD5, 0x08, 0x69, 0x7C, 0x55, 0x57, 0x2E, 0xC2, 0xBA, 0xAA, + 0xE6, 0x49, 0x5F, 0x26, 0xB7, 0xCC, 0x0B, 0xC1, 0x30, 0x05, 0x1B, 0x9C, + 0x03, 0x30, 0x2E, 0xDA, 0x43, 0x48, 0xFF, 0xF8, 0x9B, 0x57, 0xAB, 0x22, + 0xEF, 0x27, 0xA7, 0x8D, 0xFA, 0xF9, 0xE3, 0x53, 0x59, 0x55, 0xFD, 0xD0, + 0x53, 0xC1, 0x40, 0x4C, 0x5D, 0xD7, 0x6D, 0xD6, 0x4D, 0x3F, 0x4A, 0x00, + 0x11, 0x80, 0x89, 0x20, 0xC2, 0x28, 0x71, 0xDE, 0x48, 0x65, 0xB7, 0xDB, + 0xBD, 0xE0, 0xB4, 0xEF, 0xFB, 0x3C, 0xCF, 0x94, 0x36, 0x6D, 0xDB, 0x28, + 0x29, 0x7D, 0x70, 0x04, 0x22, 0x46, 0x71, 0x5D, 0xE4, 0xD3, 0x2C, 0xAD, + 0x8F, 0xFD, 0xB4, 0x5C, 0x5F, 0x6D, 0x6E, 0x6F, 0x37, 0xF3, 0x2C, 0x97, + 0xF1, 0x97, 0x37, 0x4B, 0xB0, 0x48, 0x4D, 0x08, 0xEE, 0x86, 0x41, 0x70, + 0xC1, 0x19, 0xAB, 0xAA, 0x62, 0x1C, 0x86, 0x6F, 0xBE, 0xBC, 0x67, 0x9C, + 0x78, 0xE7, 0xAE, 0x77, 0xEB, 0xD5, 0xBA, 0x5D, 0xE4, 0x12, 0x62, 0x1A, + 0x86, 0x69, 0xB5, 0xAA, 0xAE, 0xDB, 0xB6, 0x2A, 0xC8, 0xF1, 0x32, 0xCC, + 0x52, 0x57, 0x65, 0xB1, 0xDF, 0xD6, 0xC7, 0xD3, 0xC4, 0xA9, 0x28, 0x72, + 0x41, 0x09, 0x67, 0x22, 0x1A, 0x6B, 0xED, 0x02, 0x9B, 0xBA, 0xEA, 0x87, + 0xF9, 0xE9, 0xD4, 0x7D, 0x7C, 0x3E, 0x50, 0x24, 0x7E, 0xF8, 0xF1, 0x87, + 0xDD, 0xB6, 0xFE, 0xF5, 0xD7, 0x6F, 0x56, 0x4D, 0x31, 0x9B, 0x18, 0x13, + 0x66, 0x2C, 0x83, 0x30, 0x39, 0x6B, 0xAB, 0x42, 0x2C, 0xCB, 0xD2, 0x75, + 0x43, 0x42, 0xB1, 0x9B, 0xDD, 0xCB, 0xCB, 0xCB, 0x3F, 0xFD, 0xE1, 0x0B, + 0x9A, 0x21, 0x6F, 0xC2, 0xAA, 0xCE, 0x9F, 0x4F, 0xFD, 0xF5, 0xAE, 0x2D, + 0x32, 0xAA, 0x94, 0x4E, 0x31, 0x70, 0x21, 0x7C, 0x70, 0x8B, 0x9A, 0x04, + 0x27, 0xD1, 0xE7, 0x56, 0x9B, 0x18, 0xDD, 0x2F, 0x99, 0x2F, 0xC6, 0x62, + 0x56, 0xC6, 0x03, 0x8F, 0x43, 0xF8, 0xF0, 0xF0, 0xF0, 0xF1, 0xF9, 0x54, + 0x67, 0x3C, 0x04, 0x65, 0x62, 0x9C, 0x15, 0x98, 0x54, 0x50, 0xDA, 0x7E, + 0xFB, 0xAE, 0xD1, 0xCA, 0x7E, 0xFF, 0xE3, 0x58, 0x16, 0x62, 0xD3, 0x52, + 0x67, 0xDC, 0x6E, 0xC5, 0xB3, 0x8A, 0x1D, 0x9E, 0x07, 0x51, 0x6D, 0x43, + 0x72, 0x5E, 0x2F, 0xB7, 0xB7, 0x5B, 0x97, 0x04, 0x63, 0x9C, 0x10, 0x72, + 0x3E, 0x4F, 0x98, 0x0A, 0x8C, 0x11, 0x0C, 0xB1, 0x5D, 0xB7, 0x6D, 0x5D, + 0x46, 0xDD, 0x2F, 0xD3, 0xC5, 0xCA, 0xF1, 0xF1, 0xE8, 0x44, 0x96, 0x8F, + 0xF3, 0x98, 0xB3, 0xAC, 0xCE, 0x6B, 0x1F, 0xE1, 0x38, 0x2D, 0xDF, 0x7D, + 0xFD, 0x0A, 0x21, 0x82, 0x10, 0x74, 0xDE, 0x53, 0x26, 0x10, 0x80, 0x6D, + 0x55, 0x94, 0xB9, 0x38, 0x8F, 0xFD, 0xCB, 0xF3, 0x63, 0x95, 0x97, 0x75, + 0x5B, 0x5A, 0xA7, 0x17, 0xA5, 0x0E, 0xDD, 0xC1, 0x04, 0x40, 0x59, 0xA1, + 0x94, 0x05, 0x10, 0x82, 0x04, 0x08, 0xCE, 0x1F, 0x0F, 0x17, 0xC1, 0xF9, + 0xF5, 0x6E, 0xB5, 0xCC, 0x6A, 0x5D, 0x50, 0x65, 0x8E, 0xC7, 0xD3, 0x5C, + 0x97, 0x25, 0xCF, 0x57, 0x5A, 0x83, 0x53, 0x37, 0x94, 0x45, 0xAE, 0xB5, + 0xCC, 0x28, 0x4B, 0x88, 0x42, 0x14, 0x39, 0xB5, 0x94, 0x11, 0xE9, 0xC8, + 0xF9, 0x38, 0x01, 0x10, 0x57, 0x4D, 0xBD, 0xDB, 0xAE, 0x93, 0x0F, 0x8C, + 0x90, 0x7E, 0x1C, 0x12, 0x4D, 0x28, 0x19, 0x67, 0x82, 0xF1, 0xFE, 0xE7, + 0x4F, 0x87, 0xCD, 0x7A, 0xF5, 0xD5, 0xBB, 0x7B, 0x88, 0x60, 0x51, 0xF0, + 0xB1, 0x3F, 0x8D, 0xD3, 0x72, 0x99, 0x83, 0x60, 0xE5, 0x3C, 0xBB, 0x3C, + 0x67, 0x10, 0xC2, 0x4F, 0x4F, 0xE7, 0x79, 0x99, 0xEB, 0xB2, 0xFA, 0xEE, + 0xDB, 0xAF, 0x9E, 0x5E, 0x9E, 0xAD, 0xB1, 0xDB, 0x6D, 0x9B, 0x71, 0x36, + 0x8E, 0xCB, 0xBB, 0xBB, 0xED, 0xB7, 0x6F, 0xB6, 0xB3, 0xD4, 0x04, 0x93, + 0x65, 0xD1, 0x90, 0x80, 0xBC, 0xE0, 0x8B, 0x0C, 0xDD, 0x30, 0x61, 0x84, + 0xAA, 0x2A, 0xF7, 0x21, 0x40, 0xF8, 0x8B, 0x48, 0x16, 0x56, 0x65, 0x61, + 0xA4, 0x07, 0x08, 0x2A, 0x35, 0x69, 0x65, 0x8D, 0x55, 0x2E, 0x78, 0xAD, + 0x2C, 0xF4, 0xC9, 0xC2, 0xE4, 0xA3, 0x69, 0xCB, 0xAA, 0xAD, 0xB6, 0x8C, + 0x71, 0x90, 0xA0, 0x75, 0x1A, 0x40, 0x5F, 0x95, 0xC5, 0x3C, 0x0D, 0x18, + 0x44, 0x80, 0x78, 0xD3, 0xB6, 0x14, 0x91, 0xF3, 0xE5, 0xF4, 0xF9, 0xF9, + 0x31, 0x2B, 0xAB, 0xA6, 0x59, 0x4D, 0xFD, 0x50, 0xE6, 0xB9, 0x56, 0x56, + 0x70, 0x9E, 0x67, 0x8C, 0x52, 0x31, 0x4D, 0x7D, 0x51, 0x97, 0xC7, 0xC3, + 0x04, 0x40, 0x64, 0x8C, 0x2B, 0x6D, 0xF3, 0x9C, 0x4B, 0x6D, 0x38, 0x63, + 0x08, 0xA2, 0xAA, 0xCE, 0xDB, 0x9C, 0xD9, 0x18, 0xA5, 0xD3, 0xC6, 0x99, + 0xE7, 0xA7, 0xB3, 0x60, 0xC2, 0xB9, 0xD8, 0x8D, 0x33, 0x40, 0xE9, 0xE6, + 0x6A, 0x57, 0x66, 0xFC, 0xE5, 0xF1, 0x54, 0xB6, 0x94, 0xA2, 0x74, 0x38, + 0x49, 0x9E, 0x89, 0x79, 0xD2, 0x55, 0x5D, 0x1A, 0xE7, 0x10, 0x42, 0xAB, + 0xA6, 0x81, 0x00, 0x26, 0x04, 0x3F, 0xFE, 0xFC, 0xA4, 0xA5, 0x52, 0x2E, + 0x70, 0x21, 0x78, 0x46, 0x00, 0x08, 0x31, 0x00, 0x29, 0xD5, 0x6A, 0x5D, + 0x50, 0x8E, 0x3E, 0x7C, 0x7E, 0x01, 0x00, 0x42, 0x08, 0xAB, 0x9C, 0x5C, + 0x6F, 0x4B, 0xA5, 0xFD, 0xB8, 0x18, 0x42, 0x08, 0x67, 0x82, 0x02, 0x81, + 0x31, 0x89, 0x28, 0x26, 0xEF, 0x39, 0x11, 0xBF, 0xFA, 0xEA, 0x75, 0x96, + 0x0B, 0x44, 0xD0, 0xB0, 0x2C, 0xC6, 0x38, 0x63, 0x6D, 0x88, 0x71, 0xB5, + 0xAE, 0x92, 0x0F, 0xDE, 0xF9, 0x69, 0xD6, 0x3C, 0xE3, 0x42, 0x08, 0xAB, + 0x0D, 0x02, 0x30, 0x21, 0xA8, 0x8C, 0x9B, 0x87, 0xC9, 0xBA, 0x88, 0x18, + 0xE6, 0x84, 0x50, 0x02, 0x63, 0x08, 0x14, 0xD3, 0x71, 0x94, 0x52, 0x1A, + 0x84, 0xB0, 0xB1, 0xB6, 0x59, 0x57, 0xC1, 0x87, 0xFE, 0x32, 0xAD, 0x56, + 0x15, 0x17, 0xCC, 0xBA, 0x88, 0x11, 0x98, 0xE6, 0x19, 0x12, 0xEC, 0x9C, + 0xB5, 0x56, 0x5B, 0xE3, 0x8D, 0xF4, 0x4D, 0x99, 0x79, 0x1F, 0xC7, 0x45, + 0x97, 0x05, 0xAF, 0x2B, 0x81, 0x10, 0x24, 0x84, 0x10, 0x42, 0x20, 0x22, + 0x9C, 0x32, 0xEF, 0xA2, 0x75, 0xF1, 0x9B, 0x37, 0x37, 0xEB, 0x3A, 0x83, + 0xFF, 0xFC, 0x4F, 0xFF, 0x9C, 0x09, 0xCA, 0x05, 0xC3, 0x8C, 0x41, 0x84, + 0x39, 0xC7, 0x4A, 0xC9, 0xFE, 0x74, 0xEE, 0x4E, 0x67, 0x10, 0xE2, 0x66, + 0xB7, 0x25, 0x24, 0x36, 0x6D, 0x09, 0x21, 0xC8, 0x84, 0xA8, 0xAB, 0x42, + 0x5A, 0xBB, 0x28, 0xC3, 0x39, 0x9F, 0x46, 0xF5, 0x7C, 0x18, 0x3E, 0x3F, + 0x74, 0x72, 0x19, 0x95, 0xD6, 0x3E, 0x84, 0xDD, 0xB6, 0xF9, 0xDD, 0xAF, + 0x5F, 0x3F, 0x7D, 0x3A, 0x1D, 0x4E, 0xFD, 0x7E, 0xB7, 0xFA, 0xFC, 0x72, + 0xA1, 0x5C, 0x58, 0xA3, 0xDE, 0xBD, 0xBA, 0x39, 0x9C, 0xFB, 0x97, 0xE3, + 0xF1, 0xD5, 0xCD, 0x0E, 0x11, 0x62, 0x5D, 0x34, 0xD6, 0x44, 0x1F, 0x39, + 0xA7, 0x5D, 0x3F, 0xC6, 0x94, 0x04, 0xCF, 0xCA, 0x5C, 0x20, 0x84, 0xBA, + 0x61, 0xB4, 0xCE, 0xB5, 0x6D, 0xA3, 0x94, 0xA2, 0x14, 0x5B, 0x6D, 0x9B, + 0x2A, 0x4F, 0x09, 0x18, 0xEB, 0xC6, 0x69, 0xB9, 0xBD, 0xB9, 0xFA, 0xFA, + 0x8B, 0x57, 0x52, 0xEB, 0x45, 0x29, 0x39, 0xA9, 0x45, 0xEA, 0x49, 0xAA, + 0x10, 0x43, 0x08, 0xC1, 0x87, 0x70, 0xB5, 0xDD, 0xC7, 0x98, 0x6E, 0x77, + 0xCD, 0x37, 0x6F, 0x5F, 0xED, 0x77, 0x4D, 0xF0, 0x1E, 0x40, 0x30, 0x4C, + 0xB3, 0x07, 0xA0, 0xAC, 0x79, 0x51, 0x08, 0x6D, 0x0D, 0x63, 0xC2, 0x2D, + 0xFA, 0xE3, 0xCF, 0x0F, 0x8C, 0x32, 0xE7, 0x43, 0x53, 0x17, 0xEB, 0x75, + 0xF5, 0xF8, 0xD4, 0x6D, 0x56, 0x6D, 0x59, 0x50, 0x84, 0x30, 0xCF, 0x28, + 0x82, 0xF1, 0x7A, 0xBB, 0x4D, 0x01, 0x7F, 0x7A, 0x7C, 0xA1, 0x9C, 0x13, + 0xC6, 0xE4, 0xEC, 0x96, 0x79, 0x12, 0x1C, 0x29, 0x27, 0x3F, 0x3E, 0x8F, + 0xF3, 0x1C, 0x7C, 0x08, 0x08, 0x61, 0xE7, 0xF4, 0xAA, 0xCD, 0x09, 0xC1, + 0x00, 0xA0, 0x42, 0x64, 0x45, 0x41, 0x4F, 0xDD, 0x78, 0x3C, 0x9C, 0xFF, + 0xF8, 0xDB, 0xB7, 0x9C, 0x23, 0x84, 0xA0, 0xF3, 0x21, 0xC4, 0x44, 0x31, + 0x0B, 0xC1, 0x4E, 0xF3, 0xCC, 0x39, 0x56, 0xDA, 0xA6, 0xE4, 0xB5, 0x9C, + 0x8B, 0x8C, 0xD7, 0xE5, 0xCD, 0xB2, 0x4C, 0x90, 0x60, 0x8C, 0x69, 0x4A, + 0xBF, 0x98, 0x36, 0x31, 0xE3, 0x88, 0x60, 0x08, 0xA2, 0x1F, 0x26, 0x1D, + 0x01, 0x30, 0x6E, 0xB1, 0x4E, 0x2D, 0xCA, 0xBA, 0x10, 0x4E, 0x97, 0xDE, + 0x18, 0xDB, 0x4F, 0xDE, 0xDA, 0xF0, 0xE6, 0xCD, 0xFA, 0xC3, 0x87, 0x7E, + 0x5D, 0x21, 0x0A, 0x63, 0x56, 0x97, 0xEB, 0xED, 0xFA, 0xE3, 0x87, 0xC3, + 0xF1, 0xB2, 0xDC, 0xEE, 0xF3, 0x8C, 0xE1, 0x00, 0x48, 0xD5, 0x94, 0xCE, + 0x46, 0xE3, 0x92, 0xF7, 0xA8, 0x5D, 0xAF, 0x51, 0x72, 0x82, 0x61, 0x9E, + 0x55, 0x59, 0x46, 0x8D, 0xBA, 0xBC, 0xDA, 0x5E, 0x19, 0x0D, 0x47, 0xA9, + 0x18, 0xC5, 0x08, 0x80, 0x32, 0x2F, 0x42, 0x00, 0x2E, 0x44, 0x42, 0x30, + 0x02, 0x11, 0x13, 0xAC, 0x16, 0x63, 0x6D, 0x80, 0x10, 0x38, 0x6B, 0xEE, + 0xAE, 0x76, 0xF3, 0x62, 0x84, 0xA0, 0x31, 0x45, 0xCE, 0x58, 0x02, 0x50, + 0xCB, 0x61, 0x94, 0xC7, 0x6E, 0x98, 0x08, 0xC9, 0x70, 0x96, 0x8F, 0xE3, + 0x4C, 0x31, 0xD5, 0x26, 0x3A, 0x9F, 0x18, 0x43, 0xCE, 0xBB, 0xB2, 0xA0, + 0x0D, 0x4F, 0xC7, 0xF3, 0x24, 0x0D, 0x8A, 0x3E, 0x48, 0x65, 0x10, 0xE1, + 0x09, 0xB3, 0xEB, 0x7D, 0x8D, 0xA2, 0xC6, 0x00, 0x23, 0x2A, 0x16, 0x39, + 0x40, 0xE0, 0x16, 0x65, 0xEA, 0xA6, 0x5C, 0x95, 0x15, 0x40, 0x7C, 0x92, + 0x8E, 0x62, 0xF2, 0xE1, 0xC3, 0x13, 0xE5, 0x62, 0x5A, 0x66, 0x48, 0xD2, + 0xF3, 0xF3, 0x31, 0x25, 0x92, 0xA2, 0xA3, 0x04, 0xBD, 0x7E, 0xFD, 0x66, + 0xDD, 0xB4, 0x31, 0xBA, 0xD3, 0x65, 0x80, 0x71, 0x16, 0x82, 0x7E, 0x7E, + 0x9E, 0x08, 0xE5, 0xCE, 0xC7, 0x3C, 0xCF, 0x87, 0x71, 0xB9, 0xF4, 0x1D, + 0xC2, 0xB8, 0xAE, 0x5A, 0x82, 0xB1, 0xB5, 0x3A, 0x04, 0x7F, 0x7F, 0xBB, + 0x7B, 0x75, 0xBD, 0xDA, 0xD6, 0x35, 0x02, 0x28, 0xE3, 0xF0, 0xD3, 0x73, + 0x57, 0xE4, 0x79, 0x5B, 0xB3, 0x97, 0x73, 0xE7, 0x63, 0x24, 0x84, 0x5A, + 0x1B, 0x20, 0x88, 0x55, 0x55, 0x3A, 0xEF, 0x83, 0x8B, 0x59, 0x29, 0xFA, + 0x61, 0xCA, 0x0A, 0x61, 0xA4, 0x6D, 0xD6, 0xD7, 0x34, 0x2B, 0x29, 0x9C, + 0xB4, 0x96, 0x00, 0xA6, 0xA1, 0xEB, 0xA3, 0x89, 0x8B, 0x56, 0x2F, 0x97, + 0x4B, 0x4C, 0xF4, 0xDD, 0xED, 0xFD, 0xAF, 0xBE, 0xB8, 0xAE, 0x4A, 0x21, + 0x95, 0x61, 0x9C, 0x52, 0x8C, 0x18, 0x26, 0x52, 0x69, 0x84, 0x49, 0x51, + 0x95, 0x5A, 0x9B, 0xC5, 0xC9, 0x7E, 0x99, 0xAD, 0x76, 0xE3, 0x30, 0xF9, + 0x90, 0x9A, 0x36, 0xDF, 0xD6, 0x9B, 0x14, 0x81, 0x0F, 0x88, 0x51, 0xBA, + 0xC8, 0x91, 0x10, 0xAA, 0xA4, 0x0D, 0xC1, 0x69, 0xE3, 0x2E, 0xDD, 0xF8, + 0x72, 0xE9, 0x7C, 0x88, 0x77, 0xB7, 0x37, 0xC3, 0xB8, 0x20, 0x8E, 0xBE, + 0xB8, 0xD9, 0x55, 0x65, 0xB9, 0x18, 0xD9, 0xF7, 0x1D, 0xE7, 0xA2, 0xAD, + 0x8A, 0xBE, 0x9F, 0xFF, 0xFA, 0xC3, 0x87, 0x90, 0xE2, 0x97, 0x6F, 0x5F, + 0x97, 0x05, 0xFB, 0xEB, 0xDF, 0x3E, 0xDE, 0xDF, 0xD5, 0x4A, 0x4B, 0x9F, + 0x68, 0xB0, 0x28, 0x04, 0x50, 0x14, 0x99, 0x34, 0x1A, 0xA4, 0x48, 0x29, + 0x25, 0x4C, 0x64, 0x39, 0xAB, 0xAB, 0xDC, 0xCE, 0xEA, 0xD8, 0x4D, 0xCF, + 0xC7, 0x3E, 0xC4, 0x28, 0x04, 0x46, 0x08, 0x20, 0x42, 0x38, 0x01, 0x59, + 0xCE, 0x00, 0x00, 0xD3, 0xAC, 0x00, 0x80, 0x4D, 0x8E, 0x20, 0xB4, 0xB3, + 0x41, 0xA7, 0x5E, 0xA5, 0xE8, 0xD7, 0xAB, 0x55, 0x59, 0x96, 0x7D, 0x3F, + 0x3A, 0x6D, 0xDF, 0xBD, 0xBA, 0xBF, 0xBB, 0xBA, 0xC6, 0x08, 0x9D, 0xBA, + 0xF1, 0x74, 0xBE, 0x00, 0x04, 0x08, 0xC6, 0xF3, 0x24, 0x95, 0xD4, 0x44, + 0xB0, 0x94, 0x62, 0x4A, 0x69, 0xD5, 0x56, 0x31, 0xC4, 0x84, 0x31, 0x42, + 0x90, 0x12, 0xE2, 0x63, 0x42, 0x08, 0x05, 0x17, 0xF2, 0x22, 0x47, 0x08, + 0x2D, 0xB3, 0x22, 0x9C, 0x69, 0x29, 0x83, 0x33, 0xAB, 0x3A, 0xF7, 0xDE, + 0xCF, 0xD2, 0x5D, 0xBA, 0x79, 0xBD, 0x59, 0x59, 0xE3, 0x10, 0x04, 0x4D, + 0xC9, 0x61, 0xF2, 0x11, 0x22, 0x41, 0xA9, 0x10, 0x2C, 0x26, 0x30, 0x1B, + 0x77, 0x1E, 0x26, 0x25, 0x95, 0xD3, 0x4E, 0x2A, 0x5D, 0x64, 0x99, 0x32, + 0x06, 0x82, 0xD4, 0xD6, 0xA2, 0x69, 0xCA, 0x65, 0x31, 0x00, 0x41, 0x6B, + 0x9D, 0x60, 0xBC, 0x2A, 0xF2, 0xA2, 0x28, 0x51, 0x82, 0x9C, 0x13, 0xF8, + 0xA7, 0x7F, 0xF8, 0x23, 0x42, 0x6C, 0x5E, 0x54, 0x5D, 0x57, 0xE3, 0xB8, + 0x24, 0x10, 0xF7, 0xD7, 0x2D, 0x04, 0x49, 0x4E, 0x63, 0x5D, 0x32, 0x2E, + 0x04, 0x82, 0x04, 0x84, 0xC8, 0x18, 0x09, 0x21, 0x5A, 0xEB, 0x00, 0x46, + 0x46, 0x6B, 0x4A, 0x60, 0x5D, 0x97, 0xED, 0x7A, 0x7D, 0x38, 0xAA, 0xBF, + 0xBF, 0x7F, 0x10, 0x9C, 0x97, 0xA5, 0xD0, 0x6A, 0x42, 0x61, 0x3E, 0x0D, + 0xF2, 0xF1, 0xB1, 0x47, 0x18, 0xED, 0xB7, 0x4D, 0x3F, 0xCA, 0x37, 0xAF, + 0xF7, 0x97, 0xB3, 0x9C, 0xA4, 0xEC, 0xFB, 0x61, 0xBB, 0xAA, 0x29, 0xA3, + 0x11, 0x82, 0x65, 0x9E, 0xD7, 0x6D, 0x3B, 0x8E, 0x53, 0x3F, 0x8C, 0x22, + 0xCB, 0x10, 0xC0, 0x9C, 0xE3, 0x45, 0x4A, 0x65, 0x1C, 0xC6, 0x28, 0xCF, + 0x85, 0xD6, 0x26, 0x2F, 0xF8, 0xBB, 0xD7, 0xEB, 0xF3, 0x45, 0x7D, 0xFC, + 0x74, 0xDA, 0xAC, 0x1B, 0xCA, 0x98, 0x5A, 0xDC, 0xFD, 0xED, 0x96, 0x60, + 0xE4, 0x43, 0x30, 0xCA, 0x60, 0x04, 0x1F, 0x4F, 0x97, 0x65, 0x51, 0xBF, + 0x64, 0x14, 0x6D, 0xD5, 0x5C, 0xC6, 0xF1, 0x9F, 0x7F, 0xFF, 0xDB, 0xDF, + 0xFF, 0xFA, 0x9D, 0x75, 0xFA, 0xC3, 0xA7, 0xE7, 0xBC, 0x16, 0xBF, 0x14, + 0x49, 0x57, 0x75, 0x6E, 0xAC, 0xD6, 0xD6, 0x31, 0x4C, 0x97, 0x69, 0x66, + 0x94, 0xE6, 0x9C, 0xA6, 0x98, 0x56, 0xEB, 0x8D, 0xD6, 0x1A, 0x21, 0xE8, + 0xA2, 0xB5, 0x4A, 0x39, 0x17, 0xEA, 0xB2, 0x5A, 0xAD, 0x4A, 0xAD, 0xED, + 0x22, 0x95, 0xB4, 0x1A, 0x02, 0x5C, 0x17, 0x05, 0x08, 0xD8, 0xB8, 0xE8, + 0xBD, 0x0D, 0x20, 0x85, 0x08, 0xA4, 0x8E, 0xE3, 0xAC, 0x63, 0xF4, 0x21, + 0xBA, 0xB2, 0xC8, 0x30, 0x82, 0x11, 0x00, 0xA3, 0x3C, 0x67, 0x04, 0x22, + 0x10, 0xBD, 0xDB, 0x6D, 0x9A, 0xE8, 0x92, 0x0F, 0xEE, 0xD4, 0x8D, 0x65, + 0x91, 0x1B, 0x6B, 0xA7, 0x69, 0x1A, 0xA6, 0xE5, 0xEB, 0x2F, 0x76, 0xAF, + 0x6F, 0xB6, 0x45, 0xCE, 0x21, 0x88, 0x59, 0x5E, 0xCC, 0xD2, 0x63, 0x8C, + 0x20, 0x80, 0x00, 0x22, 0x17, 0x1D, 0x48, 0x10, 0x21, 0x08, 0x11, 0xC4, + 0x18, 0x07, 0x97, 0xA6, 0xC5, 0xB6, 0xAB, 0x2A, 0x26, 0xE3, 0x9D, 0x56, + 0xD6, 0x3C, 0x3F, 0xBE, 0x70, 0x9E, 0xCD, 0xCA, 0x60, 0x12, 0x1E, 0x9E, + 0x3B, 0x2E, 0xC8, 0xF3, 0x61, 0x49, 0xC1, 0xDD, 0xEE, 0x38, 0xCF, 0xCB, + 0xD7, 0x6F, 0x6E, 0xFE, 0xFE, 0xE3, 0xD3, 0x30, 0xCA, 0x52, 0x20, 0x6B, + 0xA2, 0xC8, 0xB9, 0x36, 0xE1, 0xD2, 0xE9, 0xED, 0xBE, 0x5E, 0x46, 0x4B, + 0x21, 0xAD, 0x1B, 0x9E, 0x67, 0x80, 0xB0, 0xBC, 0x5E, 0x55, 0x88, 0xF0, + 0xAF, 0xEF, 0xEF, 0x86, 0x61, 0x41, 0x90, 0x2C, 0xA3, 0xD4, 0x4A, 0x49, + 0x25, 0xAD, 0x0F, 0x94, 0x92, 0xCB, 0x65, 0xF4, 0x31, 0x15, 0x79, 0x26, + 0x32, 0xEA, 0x9D, 0x03, 0x31, 0x15, 0x45, 0xD6, 0x14, 0xE5, 0xE1, 0xD4, + 0x65, 0x99, 0xB0, 0xCE, 0xE6, 0x79, 0x56, 0xE6, 0x39, 0x81, 0x29, 0xCB, + 0x98, 0xD6, 0x53, 0x2E, 0x32, 0x0F, 0xA0, 0xF3, 0x91, 0x12, 0xD6, 0xF5, + 0x1D, 0xE3, 0xD9, 0xF3, 0xE1, 0x90, 0x30, 0x6E, 0xB8, 0x80, 0x76, 0x81, + 0x84, 0x4B, 0xE3, 0xA5, 0x32, 0xCE, 0xBB, 0xF5, 0xAA, 0xB9, 0xB9, 0xBF, + 0x8A, 0x31, 0x38, 0x2B, 0xAF, 0xAF, 0xD6, 0x84, 0x8A, 0xA7, 0xE7, 0x67, + 0x65, 0x4C, 0x88, 0xA8, 0xEF, 0x86, 0x2A, 0x13, 0xD6, 0xE3, 0xCF, 0x8F, + 0x47, 0xEF, 0x9C, 0xF5, 0x31, 0x2B, 0xD9, 0xAA, 0xAD, 0x21, 0x84, 0x43, + 0x3F, 0x2F, 0x06, 0x0B, 0x9E, 0x56, 0xA5, 0x68, 0x8A, 0x76, 0x5C, 0xDC, + 0xF9, 0x72, 0xEE, 0x87, 0xCB, 0xDB, 0xBB, 0xED, 0x22, 0xF5, 0xCF, 0x4F, + 0x67, 0x65, 0xC3, 0xAA, 0xAD, 0x8F, 0x97, 0xBE, 0x2A, 0xCA, 0xD5, 0x7A, + 0xD5, 0x75, 0xBD, 0x36, 0x86, 0x53, 0x4A, 0x08, 0x59, 0xE4, 0xF2, 0xC5, + 0xAB, 0xBB, 0xAF, 0xEF, 0x57, 0x04, 0x51, 0x65, 0x62, 0x59, 0x30, 0x80, + 0x62, 0x3F, 0x48, 0x1F, 0x42, 0x04, 0x01, 0x80, 0x34, 0x4C, 0x8A, 0x51, + 0x7E, 0xE9, 0x7B, 0xC1, 0x58, 0xBB, 0xAA, 0xA7, 0x71, 0x66, 0x5C, 0x58, + 0xA3, 0x9B, 0xF5, 0x2A, 0x6F, 0xEE, 0xAD, 0xF3, 0xE3, 0xF9, 0xD3, 0xED, + 0xF5, 0x1A, 0x63, 0x48, 0x29, 0xCC, 0x8B, 0x3C, 0xC5, 0x98, 0xA2, 0x5F, + 0x17, 0x42, 0x7B, 0x1F, 0x7C, 0x04, 0x3E, 0x38, 0x1F, 0x4E, 0x97, 0x09, + 0x42, 0x90, 0x09, 0x6E, 0xAD, 0x47, 0x08, 0x61, 0x8C, 0x43, 0x8C, 0x09, + 0x24, 0x1F, 0x3C, 0xA2, 0x78, 0xB5, 0x69, 0x08, 0x44, 0x18, 0xA1, 0x61, + 0x1E, 0x28, 0xE5, 0xC1, 0x45, 0x82, 0x09, 0x86, 0x10, 0x42, 0x18, 0x40, + 0x20, 0x10, 0x1F, 0xFB, 0xE1, 0xD3, 0xC3, 0x81, 0x33, 0x3C, 0x2F, 0x16, + 0x22, 0x68, 0x8C, 0x97, 0xDA, 0x6E, 0xB6, 0xB5, 0xB7, 0x09, 0xE0, 0xB4, + 0x5B, 0xD5, 0x4D, 0x2E, 0x2E, 0xFD, 0x58, 0x96, 0xF9, 0x32, 0xA9, 0x53, + 0x37, 0xBE, 0x1C, 0xBB, 0x3F, 0x7E, 0xF7, 0x9D, 0xB1, 0x43, 0x4A, 0x20, + 0x86, 0xB0, 0xC8, 0xA9, 0x59, 0x97, 0x9F, 0x3E, 0x4C, 0x18, 0xD3, 0x10, + 0x22, 0xA7, 0x70, 0xB3, 0x2D, 0x2F, 0xDD, 0x42, 0x28, 0x73, 0x21, 0x7E, + 0xF9, 0x6E, 0x47, 0x18, 0xA7, 0x9C, 0x9F, 0x0E, 0x1D, 0xF2, 0x01, 0xA3, + 0xF4, 0xD2, 0x8D, 0x84, 0xD1, 0x3D, 0x27, 0x81, 0xD1, 0x59, 0xC9, 0x7A, + 0x55, 0xEF, 0x77, 0xFB, 0xF9, 0xF2, 0x8C, 0x50, 0x3A, 0x0F, 0xF2, 0xB2, + 0x38, 0x08, 0x61, 0xD3, 0x34, 0xD3, 0xBC, 0x08, 0x46, 0xDB, 0xAA, 0xAC, + 0xF2, 0xCA, 0x99, 0x64, 0x5D, 0xE8, 0xFA, 0x71, 0x9A, 0x67, 0xEB, 0xFC, + 0x38, 0x2E, 0xD6, 0xD9, 0xA2, 0xC8, 0x56, 0x75, 0x49, 0x48, 0xCA, 0xAA, + 0xA2, 0x2E, 0x73, 0xEF, 0xC2, 0xA9, 0x9B, 0x31, 0x46, 0x00, 0x41, 0xEF, + 0x3C, 0xF8, 0x65, 0x6B, 0x2E, 0x72, 0x8C, 0x90, 0x77, 0x3E, 0xC4, 0x54, + 0x97, 0x0C, 0x25, 0x63, 0x55, 0x20, 0x1C, 0x4E, 0xD2, 0x8F, 0xA3, 0x82, + 0x08, 0xBF, 0x3C, 0x9F, 0x57, 0x65, 0xC6, 0x84, 0x50, 0x5A, 0xF1, 0x8C, + 0x03, 0x80, 0xCA, 0x22, 0xAF, 0x4B, 0x51, 0x14, 0xD9, 0x71, 0x18, 0x8D, + 0xB5, 0x53, 0x3F, 0x5A, 0x17, 0x18, 0xE3, 0xC1, 0x5B, 0xEF, 0x42, 0x4C, + 0x01, 0x24, 0x98, 0x00, 0xAC, 0xAA, 0x3C, 0x46, 0x0F, 0x21, 0xCE, 0x33, + 0x76, 0xB5, 0x5D, 0x23, 0x48, 0x00, 0x04, 0xF0, 0xBF, 0xFB, 0xF7, 0xFF, + 0xEE, 0xE5, 0xD8, 0x4F, 0xD3, 0x72, 0x7B, 0x7B, 0x25, 0xA5, 0xB6, 0xC6, + 0xB4, 0xAB, 0x92, 0x51, 0x04, 0x53, 0xC0, 0x98, 0x4C, 0xA3, 0x3C, 0x9E, + 0x3A, 0x8C, 0xD0, 0xEB, 0xFB, 0x7D, 0x4A, 0x9E, 0x32, 0xCE, 0x39, 0x2B, + 0x32, 0x7A, 0xB5, 0x5D, 0x11, 0x92, 0x21, 0x8C, 0x20, 0x4A, 0x8B, 0x72, + 0x08, 0x81, 0x55, 0x93, 0x4D, 0x8B, 0xC1, 0x24, 0x3A, 0x6F, 0x9F, 0x9F, + 0xBA, 0xD3, 0x65, 0xE4, 0xC8, 0x7D, 0x78, 0x98, 0x22, 0x00, 0x98, 0xD0, + 0xF3, 0xB9, 0xC7, 0x28, 0x3A, 0xEF, 0xB5, 0x71, 0x59, 0xC6, 0x72, 0x91, + 0x71, 0x46, 0x0F, 0xE7, 0x6E, 0xB3, 0x69, 0xEF, 0xAE, 0xD7, 0x65, 0x5E, + 0x76, 0xA3, 0x7C, 0x3A, 0x9E, 0x97, 0x79, 0x89, 0xD1, 0x21, 0x04, 0x39, + 0x27, 0x9C, 0x55, 0xDE, 0xCB, 0xB6, 0x11, 0x6F, 0x6F, 0xDF, 0xE4, 0x22, + 0x53, 0xCE, 0xFD, 0xDB, 0xF7, 0x3F, 0x2B, 0x65, 0x72, 0x0E, 0x6F, 0x77, + 0x5B, 0x00, 0x52, 0xDB, 0x94, 0xD6, 0xFB, 0x87, 0xA7, 0x97, 0xA6, 0xC9, + 0xAD, 0xF6, 0xC7, 0x61, 0xAA, 0xCA, 0xFA, 0x4F, 0xBF, 0xFB, 0x4D, 0x53, + 0x17, 0xC3, 0xD4, 0x8F, 0x52, 0xB9, 0x94, 0xB4, 0x33, 0x08, 0x23, 0x39, + 0xEB, 0x79, 0x5E, 0x30, 0x45, 0x6A, 0xD6, 0x8C, 0x73, 0xCE, 0xC8, 0x32, + 0x0C, 0xF7, 0x57, 0xFB, 0xC7, 0xC3, 0x39, 0x58, 0xDB, 0xAE, 0x0A, 0x0F, + 0x93, 0x35, 0xA1, 0xCC, 0xB3, 0x61, 0x50, 0xEB, 0xB6, 0x39, 0x77, 0x5D, + 0x44, 0x20, 0x80, 0x58, 0x88, 0xBC, 0x14, 0x6C, 0x1C, 0x64, 0x59, 0xD5, + 0x4F, 0x87, 0xE3, 0xAB, 0x9B, 0xFD, 0xF1, 0xD4, 0x61, 0x4C, 0x11, 0xA1, + 0xF3, 0x22, 0x11, 0x46, 0x8B, 0x54, 0xDE, 0x79, 0x84, 0x10, 0xC2, 0xC4, + 0x1A, 0x5D, 0x97, 0xF9, 0x6E, 0xDD, 0x8E, 0xB3, 0x9C, 0xA5, 0x8E, 0x21, + 0x52, 0x82, 0x04, 0x67, 0xCF, 0xC7, 0x8B, 0x73, 0x56, 0x30, 0xF2, 0xDF, + 0xFF, 0xBB, 0x5F, 0xBF, 0xBE, 0xDB, 0x1D, 0x2E, 0x3D, 0x24, 0xF8, 0x78, + 0xE9, 0x63, 0x82, 0x4E, 0x87, 0xAE, 0x5F, 0xDA, 0x4D, 0x15, 0x7D, 0x0C, + 0x31, 0x02, 0x0C, 0x53, 0x02, 0x46, 0x9A, 0xF5, 0xBA, 0xB5, 0xD6, 0xB1, + 0x8C, 0x95, 0x79, 0xE6, 0x8C, 0xC9, 0xCA, 0xEC, 0x78, 0xB8, 0x2C, 0x52, + 0xAE, 0xB6, 0x2B, 0xAB, 0x67, 0xA5, 0x96, 0x97, 0xF3, 0xF4, 0x74, 0x1C, + 0xBF, 0xFD, 0x62, 0x43, 0x09, 0x98, 0x26, 0xC7, 0x38, 0xC6, 0x84, 0x7C, + 0x7E, 0xEC, 0x61, 0x0A, 0x85, 0xC0, 0x4A, 0x27, 0x1F, 0x50, 0x5E, 0x09, + 0x84, 0xA0, 0x33, 0xB0, 0xAC, 0x2A, 0x39, 0xCD, 0x08, 0xB9, 0x3C, 0xA7, + 0x94, 0x80, 0xBB, 0x9B, 0x6B, 0xE3, 0x38, 0x66, 0x9C, 0x41, 0x04, 0x01, + 0xF2, 0xCE, 0x5E, 0xCE, 0x97, 0x94, 0x22, 0x00, 0xE8, 0xD4, 0x8D, 0x3C, + 0x13, 0x20, 0xC4, 0x5C, 0x50, 0x2E, 0xF8, 0x2C, 0x95, 0xD2, 0xFA, 0x7E, + 0xBF, 0x0D, 0x31, 0x11, 0x46, 0x19, 0xC3, 0xBF, 0x28, 0x60, 0x39, 0x23, + 0x55, 0x59, 0x10, 0x82, 0xEF, 0x76, 0x2D, 0xC1, 0xC1, 0x1A, 0x17, 0x22, + 0x59, 0x94, 0xFE, 0xFB, 0xA7, 0x67, 0xA3, 0xCD, 0xFD, 0xFD, 0x2B, 0x3B, + 0x0E, 0x4E, 0xCB, 0x10, 0x03, 0x20, 0x8C, 0x72, 0x5E, 0x35, 0x65, 0xCE, + 0x79, 0x59, 0x62, 0x04, 0x61, 0x51, 0x67, 0x84, 0xD0, 0xBE, 0x9B, 0x53, + 0x8A, 0x80, 0xC2, 0x59, 0xEA, 0xEE, 0x3C, 0x69, 0x65, 0x10, 0xA4, 0xF3, + 0x3C, 0xA4, 0xE0, 0x66, 0x03, 0x8A, 0x22, 0x6F, 0xEB, 0xBA, 0xEF, 0x47, + 0x42, 0xD8, 0x87, 0xCF, 0x0F, 0x18, 0xC7, 0xAF, 0x5E, 0xDF, 0xAF, 0xEA, + 0xFA, 0xE7, 0xC7, 0xEE, 0xE9, 0xE9, 0x20, 0x8D, 0xDC, 0xB6, 0xD5, 0xE3, + 0xD3, 0x01, 0x73, 0x6E, 0x7C, 0xD4, 0x0E, 0x78, 0x67, 0xDA, 0x66, 0xC5, + 0x28, 0x7D, 0x3E, 0x3C, 0x53, 0x4A, 0x84, 0xC8, 0x9D, 0xF3, 0x84, 0x92, + 0x7F, 0xFA, 0xEE, 0x8B, 0xB7, 0x57, 0xC5, 0xE7, 0xA7, 0x91, 0x67, 0xA5, + 0x10, 0xE4, 0xE5, 0x78, 0x82, 0x10, 0x74, 0xE3, 0x4C, 0x28, 0x6E, 0xAA, + 0xF2, 0x87, 0x9F, 0x1E, 0x78, 0xC6, 0x30, 0x46, 0x65, 0xBD, 0x55, 0x73, + 0xBF, 0x48, 0x59, 0x94, 0xAB, 0xEB, 0xFD, 0x86, 0xE4, 0xCD, 0xA7, 0x8F, + 0xEF, 0x8D, 0x9C, 0xB6, 0x9B, 0x15, 0x86, 0x20, 0xC1, 0x04, 0x52, 0xBC, + 0xDA, 0xAF, 0x12, 0x00, 0xCB, 0x22, 0xEB, 0x82, 0x63, 0x8C, 0x08, 0xC6, + 0x45, 0x59, 0x3C, 0x3D, 0x1C, 0x42, 0x70, 0x59, 0x26, 0x9C, 0x8F, 0x82, + 0xB3, 0x42, 0x88, 0x7E, 0x54, 0xDA, 0x1A, 0xA3, 0x2D, 0xC2, 0x08, 0x00, + 0x88, 0x08, 0xCE, 0x0A, 0x86, 0x50, 0x04, 0x09, 0x68, 0x6B, 0xB3, 0x3C, + 0x43, 0x30, 0x36, 0x45, 0x65, 0xAC, 0xEB, 0xA7, 0x71, 0xB7, 0xDD, 0x1D, + 0x2F, 0xFD, 0x30, 0x2D, 0x75, 0x59, 0x9C, 0x4F, 0x5D, 0xBB, 0x2E, 0x87, + 0x7E, 0x4A, 0x30, 0xF6, 0x27, 0x59, 0x54, 0x6C, 0xBD, 0x6D, 0x18, 0x2F, + 0x39, 0x4E, 0xCF, 0x4F, 0x87, 0x14, 0x88, 0x36, 0x76, 0x59, 0x64, 0xDB, + 0x6C, 0x33, 0x5E, 0x77, 0xDD, 0x39, 0x24, 0x75, 0x3C, 0xF5, 0x5F, 0xBD, + 0xDD, 0x8B, 0x1C, 0x17, 0x65, 0xD3, 0x56, 0x39, 0x8C, 0x11, 0x51, 0x1C, + 0x11, 0x1A, 0x87, 0x65, 0x1A, 0xA4, 0x54, 0x12, 0x63, 0x6A, 0x12, 0x6A, + 0x9A, 0xA2, 0x2D, 0x44, 0x41, 0x82, 0x8A, 0x70, 0x9C, 0x5C, 0x74, 0x0E, + 0xCC, 0xCA, 0x0B, 0x4A, 0xB3, 0x06, 0xC4, 0x70, 0xB5, 0xCE, 0x9D, 0xB3, + 0xC1, 0x48, 0x2A, 0xB2, 0xC4, 0xB3, 0x8C, 0x73, 0xC1, 0xE9, 0xA2, 0x54, + 0x4A, 0x00, 0x41, 0xA0, 0xB5, 0x53, 0xD2, 0xC5, 0x04, 0xCF, 0xE7, 0x6E, + 0x98, 0x16, 0x63, 0x75, 0x9E, 0x67, 0x00, 0x21, 0x4A, 0x31, 0x0A, 0xFE, + 0x6E, 0x5B, 0x0E, 0x36, 0xC2, 0x04, 0x8C, 0x8B, 0xE3, 0xAC, 0xDB, 0x4D, + 0xBB, 0x4C, 0xD2, 0x19, 0xE3, 0x63, 0xC2, 0x84, 0x52, 0x82, 0xD7, 0x4D, + 0x7D, 0x3C, 0x75, 0x94, 0x52, 0x90, 0xE2, 0xAA, 0x44, 0x45, 0x46, 0xA4, + 0x92, 0x8C, 0x17, 0xD2, 0xF8, 0xEE, 0x2C, 0x71, 0x0A, 0xCA, 0x2D, 0x0E, + 0x35, 0x8B, 0x72, 0xC3, 0x30, 0x20, 0x14, 0x6F, 0xAF, 0xF7, 0xBF, 0x58, + 0x13, 0xAB, 0x32, 0x3B, 0x9D, 0x4F, 0xFD, 0xD0, 0xC7, 0x08, 0x40, 0x02, + 0x21, 0x78, 0x00, 0xC0, 0x22, 0x6D, 0x8C, 0xA9, 0xAA, 0x32, 0xA3, 0x1D, + 0xC6, 0x10, 0x42, 0x50, 0xD6, 0x05, 0x8A, 0x70, 0x55, 0x97, 0x10, 0x41, + 0x22, 0x4D, 0x9C, 0xC7, 0xFE, 0x7A, 0xBB, 0x3A, 0x1E, 0xCF, 0x4D, 0x5D, + 0xAC, 0xF6, 0x79, 0x02, 0x31, 0x7A, 0x67, 0xB4, 0x7D, 0xFF, 0xF1, 0xA5, + 0x6D, 0x56, 0x84, 0xE7, 0x31, 0xB8, 0xA6, 0xA9, 0x6E, 0x76, 0x9B, 0x76, + 0xD5, 0x5A, 0xEF, 0x30, 0x02, 0x29, 0x82, 0x18, 0x13, 0x42, 0x08, 0x80, + 0x14, 0xAC, 0xFB, 0xEB, 0x4F, 0x4F, 0x59, 0x51, 0x20, 0x9A, 0x8A, 0x8C, + 0xE7, 0x39, 0x5F, 0xAF, 0x57, 0xF7, 0xF7, 0xD7, 0xDD, 0xE1, 0x38, 0x8C, + 0x16, 0x60, 0xBA, 0xDD, 0x54, 0xE7, 0xD3, 0xA9, 0xCA, 0xC5, 0x28, 0x81, + 0x57, 0x96, 0x62, 0xB4, 0xAB, 0xB3, 0x9F, 0x1E, 0x0E, 0xD6, 0xC5, 0xBA, + 0xAE, 0x19, 0x23, 0x9F, 0x1F, 0x1F, 0xCF, 0xBD, 0x32, 0xC6, 0x20, 0x08, + 0xA3, 0x4F, 0x80, 0x20, 0x6B, 0xE2, 0x3C, 0xF6, 0xFB, 0x4D, 0xFB, 0xCF, + 0xDF, 0xFD, 0x3E, 0x63, 0x1C, 0x11, 0x9C, 0x92, 0xFB, 0xFA, 0xBE, 0xF9, + 0xF0, 0xF0, 0xFC, 0x5F, 0xFE, 0xEB, 0x4F, 0x75, 0x91, 0x6D, 0xB6, 0x6D, + 0x8A, 0xC1, 0x5B, 0xB7, 0xFA, 0xE6, 0x75, 0x44, 0x29, 0x78, 0xF8, 0xFB, + 0x3F, 0xFC, 0xE3, 0x6E, 0xBD, 0x19, 0xC7, 0xF3, 0x0F, 0x3F, 0x3F, 0xC4, + 0x14, 0x67, 0xA5, 0xC6, 0x59, 0xFA, 0xE0, 0x19, 0xC3, 0x10, 0x42, 0x29, + 0x0D, 0x80, 0x29, 0xCB, 0x8B, 0x79, 0x96, 0xE3, 0xE8, 0x29, 0x86, 0x1F, + 0x1E, 0x0E, 0x29, 0x26, 0x42, 0xF0, 0xE7, 0xE7, 0x53, 0x5E, 0x8A, 0x2C, + 0x2B, 0xA7, 0xC5, 0x00, 0x08, 0xDF, 0x7F, 0x7E, 0x72, 0x3E, 0x60, 0x4A, + 0x94, 0xF1, 0x26, 0x8B, 0x78, 0xDD, 0x7A, 0x1F, 0xAD, 0xB5, 0x77, 0x77, + 0x37, 0xD3, 0x3C, 0xBB, 0x14, 0x28, 0x82, 0x04, 0x42, 0x63, 0x14, 0x42, + 0x98, 0x60, 0x7A, 0x3C, 0x75, 0x57, 0xBB, 0x8D, 0xB5, 0x46, 0x19, 0x4D, + 0x30, 0xEE, 0xC6, 0xE5, 0xE9, 0xE5, 0x82, 0x08, 0x8A, 0x31, 0x41, 0x10, + 0x63, 0x8C, 0xBB, 0x56, 0xFC, 0xC3, 0x6F, 0x7E, 0x03, 0x52, 0x2A, 0x72, + 0xF6, 0xFD, 0x8F, 0x0F, 0x2F, 0x97, 0x7E, 0x18, 0x97, 0x10, 0x22, 0xE7, + 0x9C, 0x51, 0x46, 0x29, 0x36, 0xCA, 0x20, 0x82, 0x16, 0x6D, 0x8D, 0x8B, + 0xCE, 0xBA, 0xBA, 0xCE, 0x2E, 0xFD, 0xE8, 0x9C, 0xE7, 0x2E, 0xD3, 0xCA, + 0x6B, 0xA5, 0xC4, 0xA2, 0xBD, 0x4F, 0x98, 0xB3, 0x69, 0xEE, 0xBD, 0xF3, + 0x31, 0x41, 0xEB, 0x43, 0x70, 0xC9, 0x27, 0x10, 0x5C, 0x10, 0x19, 0xFA, + 0xF8, 0x30, 0x70, 0x86, 0xA7, 0xD9, 0x21, 0x90, 0xAA, 0x8C, 0x86, 0x18, + 0x19, 0x23, 0x9B, 0x6D, 0x11, 0x13, 0xF6, 0x36, 0x41, 0x80, 0xBC, 0x8F, + 0x4A, 0xB9, 0xC7, 0xE7, 0x79, 0xBF, 0x2D, 0x0A, 0xB1, 0x48, 0x2B, 0xB9, + 0xC8, 0x09, 0x42, 0x65, 0x59, 0x41, 0x4C, 0x9C, 0x0F, 0x8C, 0xD0, 0xD9, + 0x18, 0xC2, 0xE9, 0x30, 0x2C, 0x8C, 0x33, 0x80, 0x50, 0x48, 0x96, 0x71, + 0xA1, 0x95, 0x46, 0x04, 0x06, 0x17, 0xFB, 0x7E, 0x74, 0x21, 0x20, 0x8C, + 0x16, 0xE9, 0x52, 0x8C, 0x37, 0xFB, 0x35, 0xE7, 0xA4, 0x1F, 0xE7, 0xA6, + 0xA0, 0x82, 0xE3, 0xA6, 0xAC, 0x7D, 0x84, 0x08, 0xD2, 0x4D, 0x5B, 0x6C, + 0x9A, 0x92, 0xAC, 0x8A, 0x90, 0x92, 0x52, 0xBA, 0x2C, 0x73, 0x63, 0xDC, + 0x28, 0xF5, 0xE7, 0x97, 0x6E, 0x6B, 0x98, 0x55, 0xD2, 0xA7, 0x14, 0x31, + 0x11, 0x82, 0xA1, 0x04, 0x01, 0x00, 0x84, 0x91, 0xB6, 0x6D, 0x42, 0x15, + 0x84, 0x10, 0x97, 0x23, 0x39, 0xBE, 0x9C, 0xF7, 0xAB, 0x66, 0x9E, 0xA5, + 0x55, 0xD1, 0x1B, 0xBF, 0x2C, 0x6E, 0xD3, 0x96, 0xE3, 0x38, 0x81, 0x18, + 0x60, 0x5A, 0xAA, 0x12, 0xF6, 0x99, 0x08, 0xC9, 0x4F, 0xB3, 0xDA, 0xEF, + 0x76, 0x10, 0x93, 0xA7, 0x6E, 0x62, 0xC9, 0x4B, 0xE9, 0x62, 0xF4, 0x31, + 0xC4, 0x2A, 0xE3, 0x6D, 0x55, 0x3C, 0x9D, 0xBB, 0xFD, 0x6E, 0x57, 0x15, + 0xA5, 0xD6, 0xD6, 0xDA, 0xDC, 0x07, 0xC0, 0x21, 0x3A, 0x5D, 0x46, 0xA9, + 0xBC, 0x0F, 0x16, 0x61, 0xF4, 0x0B, 0x0F, 0x4B, 0x28, 0x7E, 0x7A, 0x39, + 0x6D, 0xD6, 0xDB, 0x7A, 0x45, 0xA5, 0x76, 0x79, 0x51, 0x7C, 0xF3, 0xBB, + 0x7F, 0x7A, 0x7A, 0x78, 0x3A, 0x7C, 0xFF, 0xDF, 0xAA, 0x32, 0xDB, 0x5F, + 0x6F, 0xF7, 0x9B, 0x66, 0xBF, 0x6D, 0x42, 0x08, 0xDD, 0x30, 0xAD, 0xDB, + 0x52, 0x1A, 0x8B, 0x41, 0xEA, 0xFA, 0xF1, 0x7A, 0xDF, 0x78, 0xEF, 0xFE, + 0xF2, 0xB7, 0x0F, 0x9B, 0x75, 0x83, 0x3C, 0xD4, 0xC6, 0x43, 0x8C, 0x20, + 0x46, 0xCA, 0x39, 0x1F, 0xA3, 0xB1, 0x9E, 0x67, 0xC2, 0xBA, 0x10, 0x43, + 0x88, 0x3E, 0x8C, 0xE3, 0x32, 0x4C, 0xF3, 0xF3, 0xE1, 0x92, 0x00, 0xBC, + 0xBB, 0xDB, 0x12, 0x1C, 0xC0, 0x0D, 0x5E, 0x94, 0x12, 0x5C, 0x3C, 0xBE, + 0x1C, 0x42, 0x84, 0x84, 0x50, 0x63, 0xDC, 0x7A, 0xD3, 0x2C, 0xCB, 0xD4, + 0x54, 0x39, 0x61, 0x24, 0x17, 0x62, 0xB3, 0xA9, 0x2E, 0xC3, 0x78, 0x38, + 0x9F, 0x9B, 0x92, 0xAF, 0x77, 0xCD, 0xB2, 0x18, 0x40, 0x52, 0x2E, 0x56, + 0x18, 0x65, 0x97, 0xBE, 0xEB, 0xC6, 0xC1, 0x19, 0x95, 0xE7, 0x62, 0xB7, + 0xAB, 0x8B, 0x8C, 0x6D, 0x36, 0xFB, 0xA9, 0xEF, 0x59, 0x91, 0x05, 0x00, + 0x8D, 0x71, 0x57, 0xFB, 0x7A, 0xDF, 0xB2, 0x4B, 0x8F, 0x44, 0xD5, 0x3C, + 0xBF, 0x4C, 0x04, 0x06, 0x63, 0x16, 0xE7, 0x09, 0x26, 0x62, 0xB7, 0x2B, + 0x29, 0x42, 0xD1, 0xF8, 0xEB, 0x5D, 0xF5, 0xF1, 0x14, 0xB4, 0xB6, 0x04, + 0xFB, 0x42, 0xD4, 0x53, 0x70, 0xCB, 0x6C, 0xA9, 0x27, 0x2C, 0x6B, 0x9E, + 0x1E, 0x5F, 0x00, 0x4A, 0x43, 0x3F, 0xC7, 0x18, 0x33, 0x21, 0x9A, 0xB6, + 0x4A, 0x21, 0xAE, 0xDF, 0xDE, 0x2C, 0x8B, 0xE2, 0x19, 0xAA, 0xAB, 0x72, + 0x5C, 0xAC, 0xF5, 0x6E, 0xEC, 0xC6, 0x18, 0x53, 0x58, 0xA4, 0xB3, 0x16, + 0xE4, 0x39, 0xCF, 0xC5, 0xF9, 0x34, 0xA4, 0x90, 0xAA, 0xA6, 0xD0, 0xC6, + 0x6A, 0x65, 0xEF, 0xAF, 0xB6, 0xC7, 0x53, 0x37, 0x2B, 0xB3, 0x16, 0xC2, + 0xE8, 0x78, 0x19, 0xD5, 0xAA, 0xCD, 0x04, 0x4E, 0x01, 0xBA, 0x6E, 0x32, + 0xD6, 0xEA, 0x76, 0x25, 0x4A, 0x5E, 0x3F, 0x1D, 0x21, 0x21, 0x0C, 0x22, + 0x84, 0x20, 0x9C, 0x67, 0xAB, 0xB5, 0x39, 0x77, 0xF3, 0xFD, 0xCD, 0xBE, + 0xC8, 0xEB, 0xCB, 0x65, 0xD0, 0xDA, 0x00, 0x08, 0x16, 0xA9, 0xB8, 0x10, + 0x84, 0x89, 0x2A, 0xCF, 0xB6, 0x6D, 0x69, 0xB4, 0x31, 0xD6, 0xBE, 0x7B, + 0x7D, 0xAF, 0xAC, 0xEE, 0x07, 0xD5, 0x34, 0x3B, 0x69, 0x0C, 0x2E, 0x73, + 0xF2, 0x7A, 0x5F, 0x3F, 0xBD, 0x74, 0xDA, 0x9A, 0xED, 0x26, 0x1B, 0x87, + 0x5E, 0x29, 0x9B, 0xE7, 0x62, 0x18, 0xE6, 0xBA, 0xC9, 0xB4, 0x8E, 0xC6, + 0x68, 0xE7, 0xDD, 0x6F, 0xBF, 0x7E, 0xCB, 0x68, 0xF6, 0xF3, 0xC7, 0xE3, + 0xFB, 0x8F, 0x4F, 0xFF, 0xE5, 0xBF, 0xFE, 0x55, 0x2A, 0xA3, 0x8C, 0xFE, + 0xF8, 0xF9, 0x49, 0x2E, 0x3A, 0x86, 0xB8, 0x6E, 0x6B, 0xC6, 0x88, 0x77, + 0xF1, 0xA7, 0x9F, 0x1F, 0xA5, 0x4D, 0x3F, 0xBE, 0x3F, 0x12, 0x2C, 0x22, + 0x40, 0xFB, 0x5D, 0xBB, 0xDB, 0x14, 0x18, 0x43, 0x02, 0x80, 0x60, 0x3C, + 0xA4, 0xB4, 0xAE, 0x6A, 0x41, 0xD0, 0xF5, 0xA6, 0x3C, 0xF4, 0x8B, 0x71, + 0x01, 0x22, 0x30, 0xCF, 0xB2, 0xEF, 0xE6, 0x73, 0x3F, 0xB4, 0x65, 0x09, + 0x11, 0xB1, 0x3E, 0x42, 0x88, 0xA6, 0x59, 0x96, 0x82, 0xFF, 0xE6, 0xEB, + 0xAF, 0x7D, 0x84, 0xA7, 0x7E, 0x34, 0xD6, 0x77, 0xC3, 0xB4, 0x2C, 0x52, + 0x08, 0x74, 0xBD, 0x6B, 0x9A, 0xBA, 0xF8, 0xF0, 0xF1, 0xF4, 0xFC, 0x74, + 0x60, 0x8C, 0xB7, 0x6D, 0xCB, 0x38, 0x23, 0x34, 0x0F, 0x9E, 0x5C, 0xCE, + 0xDD, 0x22, 0x97, 0x97, 0x73, 0xFF, 0x72, 0x1E, 0x45, 0xC1, 0x21, 0x22, + 0x72, 0xD1, 0x10, 0x21, 0xC2, 0x28, 0x42, 0x28, 0xCB, 0x32, 0x4A, 0x29, + 0x48, 0x00, 0xC4, 0x04, 0x00, 0xE8, 0x86, 0x69, 0x9C, 0x96, 0x49, 0xAB, + 0x98, 0xC2, 0xA6, 0xAE, 0xAF, 0xD6, 0x5B, 0x29, 0xD5, 0x62, 0xAD, 0x89, + 0x09, 0x23, 0x8C, 0x31, 0xC5, 0x24, 0x2B, 0xCA, 0x76, 0xB7, 0xDB, 0xD7, + 0x55, 0x96, 0x65, 0x62, 0x1A, 0xFA, 0xFD, 0xF5, 0x7E, 0x7F, 0xB5, 0x32, + 0xDA, 0xF8, 0x90, 0x04, 0xE3, 0x31, 0x42, 0x08, 0x61, 0x53, 0x97, 0x79, + 0x26, 0x52, 0xF4, 0xDE, 0x07, 0x6D, 0xAD, 0xD2, 0x92, 0x33, 0x08, 0x63, + 0xD8, 0x6F, 0x9B, 0xAB, 0x4D, 0xFD, 0xC5, 0xDD, 0xEE, 0x9F, 0xFF, 0xF0, + 0x05, 0x42, 0xA8, 0xEB, 0xE7, 0x7E, 0x5A, 0x3E, 0x3D, 0x5F, 0xEA, 0x5A, + 0x30, 0x4A, 0x05, 0xE7, 0xD6, 0xB8, 0xF5, 0xBA, 0x94, 0xD2, 0x38, 0x1F, + 0xE7, 0x45, 0x01, 0x08, 0x21, 0x00, 0x9C, 0x63, 0x4A, 0x89, 0xB3, 0xDE, + 0x18, 0x97, 0x00, 0x48, 0x20, 0x1D, 0x4E, 0x43, 0xDF, 0xCF, 0x98, 0x41, + 0xE3, 0x9C, 0xB7, 0x0E, 0xA6, 0x30, 0x8E, 0xB3, 0x54, 0x1E, 0x61, 0x94, + 0x92, 0x43, 0x29, 0x7E, 0xF8, 0xBC, 0x28, 0x1D, 0x9D, 0x4D, 0x6D, 0x89, + 0x53, 0x82, 0x65, 0x21, 0xB6, 0xDB, 0x3A, 0x04, 0xEB, 0x5D, 0x00, 0x00, + 0x06, 0x17, 0xBD, 0x4F, 0x97, 0xCB, 0x40, 0x19, 0x25, 0x04, 0x6E, 0xB6, + 0xEB, 0xD5, 0x7A, 0x35, 0x2B, 0x33, 0x0F, 0x0B, 0x40, 0xF0, 0x74, 0xEA, + 0x7F, 0x11, 0x93, 0x8C, 0xD3, 0x6C, 0xBD, 0xCF, 0xCA, 0xF2, 0xE1, 0xF1, + 0x19, 0x13, 0x66, 0xBD, 0x87, 0x08, 0x97, 0x55, 0x91, 0x62, 0xC8, 0xB9, + 0x38, 0x0F, 0x4B, 0x3F, 0x2E, 0x87, 0x73, 0x0F, 0x11, 0x3E, 0x9C, 0xFA, + 0x71, 0x5E, 0x9C, 0x07, 0xFD, 0x28, 0x87, 0x79, 0x59, 0xB4, 0x6A, 0xEB, + 0x7C, 0xB5, 0xA9, 0x06, 0x2D, 0x6F, 0x6F, 0x76, 0xBB, 0x4D, 0x83, 0x11, + 0x72, 0x11, 0x58, 0xEF, 0x43, 0x82, 0x31, 0x24, 0x00, 0x60, 0x56, 0x8A, + 0xAA, 0x64, 0xDE, 0xFA, 0xC3, 0x61, 0x9C, 0x16, 0x7D, 0x3C, 0x5E, 0xB4, + 0xB5, 0xC3, 0xA2, 0xC7, 0x45, 0x8F, 0x83, 0x4A, 0x09, 0x33, 0x26, 0xAC, + 0xF5, 0x75, 0x59, 0xDF, 0x5E, 0xDD, 0xAC, 0xDA, 0x6A, 0xBD, 0x6A, 0xDB, + 0x66, 0xC5, 0x18, 0x2B, 0xAB, 0x66, 0x7B, 0x75, 0xF7, 0xFA, 0xEE, 0x1A, + 0x27, 0xF5, 0x78, 0x7C, 0xE4, 0x3C, 0xAF, 0x44, 0xA1, 0xB5, 0x11, 0x19, + 0x82, 0x00, 0x1A, 0x13, 0x29, 0x82, 0x29, 0x18, 0x42, 0x50, 0x91, 0xE5, + 0x4A, 0xCE, 0xBF, 0xFE, 0xE2, 0xEA, 0x6A, 0xDB, 0x70, 0x41, 0xDA, 0x2A, + 0x63, 0xD0, 0xB7, 0x55, 0x89, 0xB1, 0x48, 0x88, 0x6A, 0xEB, 0x3F, 0x7C, + 0xFA, 0x0C, 0x00, 0xC4, 0x08, 0x58, 0x1F, 0x2F, 0xFD, 0x94, 0x67, 0x05, + 0xC6, 0xF0, 0xDC, 0x4D, 0x98, 0xF0, 0xB2, 0xAC, 0x44, 0xD9, 0x9E, 0x5E, + 0x9E, 0x7E, 0xF5, 0x87, 0x7F, 0x91, 0xE7, 0x4F, 0xFB, 0x0A, 0x7F, 0xF9, + 0xF6, 0xCD, 0x97, 0xF7, 0xD7, 0x99, 0x20, 0xBF, 0x9C, 0x81, 0x38, 0x25, + 0x9C, 0x33, 0x4E, 0x59, 0x59, 0x66, 0x77, 0xD7, 0xDB, 0xEB, 0xAB, 0x0D, + 0x63, 0xD4, 0x99, 0xB8, 0xDF, 0x6D, 0x18, 0xE7, 0x4C, 0x70, 0x1F, 0xE2, + 0xF3, 0xE3, 0xF1, 0x70, 0xEE, 0x21, 0x86, 0x4A, 0x5B, 0x6D, 0x9C, 0xB5, + 0xC1, 0x39, 0x0F, 0x31, 0x14, 0x22, 0x83, 0x10, 0x22, 0x08, 0xA7, 0x59, + 0x2B, 0xEB, 0x09, 0xC1, 0x0F, 0xCF, 0x97, 0xE0, 0xE3, 0x34, 0x2F, 0xC3, + 0x6C, 0x16, 0x69, 0x3F, 0x7C, 0xFC, 0x1C, 0x7C, 0x2C, 0x72, 0xEA, 0x9D, + 0x7B, 0x39, 0x0D, 0x09, 0x02, 0xE7, 0xE3, 0x22, 0x2D, 0x23, 0xB8, 0xAD, + 0xF3, 0x14, 0x63, 0x5E, 0x70, 0x8C, 0x41, 0xD3, 0x54, 0x55, 0x59, 0x1A, + 0x6D, 0xBF, 0x7C, 0xBB, 0xDB, 0x6E, 0xF9, 0x77, 0x5F, 0xBF, 0xFB, 0xD5, + 0xD7, 0x77, 0xCE, 0x4A, 0x6D, 0x8C, 0x33, 0x29, 0x00, 0x68, 0x23, 0x3C, + 0x5F, 0xE6, 0x45, 0xD9, 0xCB, 0xF1, 0xA0, 0xC6, 0xE1, 0x78, 0x99, 0x62, + 0x74, 0x4D, 0x5D, 0xC5, 0x60, 0xF3, 0x2C, 0xE7, 0x2C, 0x0B, 0x2E, 0x2E, + 0xE3, 0xD2, 0x5D, 0xA6, 0x18, 0xE3, 0xE1, 0xD8, 0xF5, 0xE3, 0xF8, 0x72, + 0x1C, 0xFE, 0xF2, 0xD7, 0x9F, 0x30, 0x84, 0x97, 0x7E, 0x96, 0x32, 0x50, + 0xCA, 0xA4, 0x36, 0x52, 0x49, 0xA5, 0x6D, 0x02, 0xC0, 0xFB, 0xA8, 0xA5, + 0x15, 0x94, 0x82, 0x04, 0x86, 0x69, 0xB1, 0xC6, 0x2B, 0x69, 0x17, 0x6D, + 0x20, 0x82, 0x19, 0xE5, 0x4D, 0x51, 0x34, 0x6D, 0x53, 0xE6, 0x02, 0x13, + 0x3A, 0x2F, 0x5A, 0x6B, 0x27, 0x17, 0x9D, 0x67, 0x8C, 0x40, 0xF8, 0x72, + 0x38, 0x57, 0x45, 0x8E, 0x21, 0x3A, 0x74, 0xA3, 0xD1, 0xD6, 0x3B, 0x1B, + 0x42, 0x14, 0x04, 0x6A, 0xD9, 0xCB, 0x90, 0xB4, 0xF7, 0x00, 0x42, 0x04, + 0x63, 0xC4, 0x4E, 0x5A, 0x44, 0x28, 0x9E, 0xC6, 0x81, 0xE3, 0x74, 0x7F, + 0x7B, 0xBB, 0x28, 0xD3, 0xF7, 0xBD, 0x94, 0x6A, 0x9A, 0x25, 0x04, 0x20, + 0xC5, 0xE0, 0x9D, 0x45, 0x04, 0x8F, 0x93, 0x34, 0x26, 0xFC, 0xEE, 0x57, + 0xDF, 0x7D, 0xF3, 0xEA, 0xFA, 0xDD, 0xAB, 0xAB, 0xDB, 0xAB, 0xCD, 0x66, + 0xB3, 0xD9, 0xAC, 0x77, 0x59, 0x56, 0x34, 0x75, 0xDD, 0xD4, 0x0D, 0xE3, + 0x39, 0xFC, 0x97, 0x7F, 0xFA, 0x66, 0x1C, 0xD4, 0x30, 0xEB, 0xFB, 0xFB, + 0x35, 0xE3, 0xA8, 0xBB, 0xCC, 0x10, 0x53, 0x8A, 0x11, 0xC6, 0xF0, 0xCD, + 0xDB, 0x77, 0xDF, 0xFF, 0xF5, 0xA9, 0xCA, 0xD3, 0xEB, 0x9B, 0x5B, 0x42, + 0x2A, 0x63, 0xFD, 0xE7, 0xE7, 0xD3, 0xD3, 0xCB, 0xCB, 0xF1, 0x7C, 0xB8, + 0xBF, 0xDE, 0xB5, 0x4D, 0xB9, 0x48, 0x35, 0xCF, 0x92, 0x13, 0xF6, 0xED, + 0xD7, 0xEF, 0x38, 0x67, 0xE3, 0xAC, 0xBA, 0x71, 0x76, 0x09, 0x50, 0xCA, + 0xB5, 0x36, 0x55, 0x91, 0x55, 0x05, 0xAE, 0x0A, 0xD1, 0x75, 0x27, 0x39, + 0x8D, 0xBB, 0xCD, 0xF6, 0x3C, 0x5C, 0x28, 0x26, 0xC6, 0x9A, 0xC3, 0x49, + 0x76, 0x8B, 0x36, 0xC6, 0x42, 0x98, 0x38, 0x25, 0x04, 0x23, 0xE7, 0x42, + 0x5B, 0xD7, 0xE7, 0x61, 0xE2, 0x9C, 0x9F, 0x2F, 0xFD, 0xD7, 0xAF, 0xF7, + 0xFB, 0xED, 0x55, 0x96, 0x37, 0xC3, 0xBC, 0xF4, 0xE3, 0x30, 0xCF, 0x13, + 0x00, 0x31, 0x84, 0x74, 0x7F, 0x53, 0xA7, 0x18, 0x21, 0x24, 0xBB, 0x55, + 0x3B, 0x0E, 0x13, 0x44, 0x6C, 0xB3, 0x5B, 0x69, 0xB3, 0x44, 0x18, 0x87, + 0x61, 0x9E, 0x26, 0x17, 0x13, 0xEE, 0xC7, 0xFF, 0x7F, 0x68, 0x8D, 0x05, + 0xFB, 0x9B, 0xDB, 0xAE, 0x7B, 0xB2, 0x5A, 0x95, 0x65, 0x0E, 0x11, 0x92, + 0x8B, 0x66, 0x8C, 0x12, 0x84, 0xB4, 0x54, 0xC3, 0x38, 0x59, 0xE7, 0x42, + 0x0A, 0x77, 0xFB, 0x16, 0x06, 0x68, 0x7C, 0x1C, 0xE6, 0x99, 0x95, 0x39, + 0x4C, 0xC8, 0x59, 0x87, 0x10, 0xBA, 0xBA, 0xBA, 0x65, 0x9C, 0xDF, 0x6D, + 0xF2, 0x60, 0x34, 0x13, 0xB4, 0xAA, 0x32, 0x48, 0x60, 0x0C, 0xC1, 0x19, + 0x97, 0x30, 0x52, 0xD2, 0x29, 0x15, 0xBE, 0xFF, 0xE1, 0xC3, 0xBA, 0xA9, + 0xEB, 0x4A, 0x0C, 0xE3, 0xBC, 0x28, 0xB3, 0x6D, 0xAB, 0xBB, 0xFD, 0xEA, + 0xF5, 0xF5, 0x1A, 0x00, 0xD4, 0x36, 0x19, 0x84, 0xD0, 0x18, 0x6F, 0x6C, + 0x50, 0xDA, 0xAD, 0x56, 0x15, 0xC1, 0xC0, 0x58, 0x0B, 0x20, 0x32, 0xCE, + 0x3C, 0x1E, 0x3A, 0x80, 0x62, 0x88, 0xA1, 0xEB, 0xF5, 0xDF, 0x7E, 0xF8, + 0xBC, 0x5E, 0x97, 0x75, 0x53, 0xF4, 0xBD, 0x2C, 0xDB, 0x92, 0xC0, 0x94, + 0x12, 0x54, 0xD2, 0x20, 0x00, 0x01, 0xC5, 0x98, 0xD2, 0x69, 0x18, 0x9A, + 0x26, 0x5B, 0x94, 0x53, 0x8B, 0x45, 0x20, 0xCC, 0x72, 0x02, 0x08, 0xAC, + 0xB7, 0xD5, 0x32, 0xC9, 0x79, 0xD4, 0x97, 0xC1, 0xDF, 0xBD, 0xDD, 0xF4, + 0xA7, 0x29, 0xE7, 0x10, 0x02, 0x78, 0xE9, 0x4C, 0x5D, 0xA1, 0xAA, 0xE6, + 0x10, 0x12, 0xE3, 0xC0, 0x34, 0xBA, 0xB2, 0x10, 0x7D, 0x3F, 0x32, 0x46, + 0x40, 0x4C, 0xBB, 0xCD, 0xBA, 0xA8, 0x0A, 0x65, 0xA3, 0x33, 0xDE, 0x3B, + 0x13, 0x01, 0x8C, 0x09, 0x32, 0x8C, 0x32, 0xCE, 0xA4, 0x36, 0x09, 0xC2, + 0x87, 0xC7, 0xA7, 0x2C, 0x2B, 0xF2, 0x9C, 0x07, 0x1F, 0x04, 0xE7, 0x19, + 0x27, 0x85, 0x10, 0xEF, 0x1F, 0x5E, 0x8C, 0x35, 0x14, 0x13, 0x2E, 0x38, + 0xC2, 0x60, 0x9E, 0x15, 0xA5, 0x2C, 0xC6, 0xC8, 0x19, 0xFE, 0xE6, 0xDD, + 0x4D, 0x5B, 0x14, 0x3C, 0x2F, 0x28, 0x49, 0x14, 0x83, 0xBA, 0xCA, 0x52, + 0xCA, 0x4E, 0xA7, 0xA9, 0x2C, 0xD0, 0xB2, 0x38, 0xCE, 0x29, 0x04, 0x40, + 0x14, 0x74, 0x59, 0xBA, 0x4F, 0x9F, 0x4E, 0x8B, 0x8C, 0xED, 0xAA, 0xEC, + 0xC7, 0xC9, 0x1A, 0x6F, 0x9C, 0x9F, 0x95, 0xAE, 0xCA, 0x9A, 0x50, 0xEA, + 0x8C, 0x69, 0xEB, 0x55, 0xDB, 0x34, 0x6D, 0xC9, 0x31, 0x8E, 0x4C, 0xD0, + 0x22, 0xE3, 0x14, 0x01, 0xEB, 0xBC, 0xB3, 0x61, 0x99, 0x2E, 0xF3, 0x74, + 0x0E, 0x10, 0x62, 0xCC, 0x9A, 0xB2, 0x06, 0x18, 0xEA, 0x20, 0xBD, 0xC1, + 0x6A, 0xF6, 0x3E, 0x18, 0x51, 0xD0, 0xDD, 0xAE, 0x1A, 0x7B, 0xAD, 0xA4, + 0xDA, 0x6C, 0x1A, 0x4A, 0xF0, 0xF9, 0x32, 0x12, 0x42, 0x8A, 0x4C, 0xF8, + 0xC0, 0x23, 0x10, 0xE7, 0xCB, 0xA5, 0xBA, 0x7A, 0xF3, 0xF4, 0xF0, 0x11, + 0x98, 0x09, 0xC2, 0xF4, 0x74, 0x38, 0x24, 0xDA, 0x2D, 0x89, 0x00, 0x00, + 0x20, 0x00, 0x49, 0x44, 0x41, 0x54, 0xD5, 0x6D, 0x5B, 0xB4, 0x57, 0x0F, + 0x1F, 0xFE, 0x76, 0x1E, 0xA6, 0xA2, 0xA8, 0xBE, 0xFE, 0xF5, 0x1F, 0x78, + 0x92, 0xFB, 0x75, 0xB9, 0xC0, 0x5D, 0x03, 0xCE, 0xD7, 0x9B, 0xEC, 0x78, + 0x99, 0xC6, 0x49, 0x95, 0x4D, 0xDD, 0x77, 0x87, 0x22, 0x2F, 0x10, 0x84, + 0xD6, 0x39, 0x42, 0x10, 0xC6, 0xA9, 0xAA, 0x2B, 0xEF, 0x1D, 0xC6, 0x38, + 0xC6, 0x64, 0x5D, 0xBC, 0xB9, 0x6E, 0x3F, 0x3D, 0x1F, 0x1F, 0x3E, 0x9F, + 0x21, 0x84, 0xCA, 0xBA, 0xE0, 0x2C, 0x46, 0x44, 0x99, 0xE0, 0x9C, 0x17, + 0x82, 0xC5, 0x18, 0xCA, 0x32, 0x8F, 0x21, 0x08, 0x41, 0x1F, 0x0F, 0xDD, + 0x22, 0xED, 0xFD, 0x5D, 0x7B, 0xEC, 0xC6, 0xDD, 0x66, 0xE5, 0x8C, 0x63, + 0x94, 0xAC, 0xDB, 0x22, 0xA6, 0x24, 0x38, 0x05, 0x20, 0x44, 0x17, 0x94, + 0x0D, 0xE7, 0x61, 0x5C, 0x94, 0x4D, 0x29, 0x61, 0x10, 0x53, 0x8C, 0x79, + 0x91, 0x5F, 0xEF, 0xAB, 0xB6, 0xCC, 0x86, 0xD9, 0xB6, 0xED, 0x55, 0x93, + 0xE7, 0xD3, 0x70, 0x71, 0xD1, 0x81, 0xC0, 0xBA, 0x7E, 0xEA, 0x47, 0x59, + 0x95, 0xB0, 0xCE, 0xB9, 0x4D, 0xD0, 0x78, 0xD0, 0x0D, 0x0A, 0x62, 0x54, + 0x66, 0x28, 0x98, 0x79, 0x91, 0x8E, 0x67, 0x1B, 0xE7, 0xE6, 0xAB, 0x2D, + 0xAD, 0xCB, 0xAD, 0x35, 0xE8, 0xE5, 0xF0, 0xD2, 0x8F, 0x23, 0x43, 0xD9, + 0xD5, 0x7E, 0xFF, 0xF9, 0xF9, 0x45, 0x5B, 0xEB, 0x5C, 0xA8, 0x8A, 0xE2, + 0xFE, 0x6A, 0x63, 0xAD, 0xCB, 0x8A, 0x4C, 0x2A, 0xDB, 0xAE, 0xEA, 0xA7, + 0xC3, 0xCB, 0x8F, 0x1F, 0x1E, 0x31, 0xC6, 0x08, 0xA1, 0xAB, 0x75, 0x5B, + 0x16, 0xB9, 0xF7, 0xBE, 0x28, 0x85, 0x73, 0x8E, 0x60, 0x4C, 0x18, 0xD1, + 0xDA, 0x30, 0xC6, 0x00, 0x48, 0x79, 0x2E, 0x04, 0x63, 0x18, 0x13, 0xA5, + 0x4D, 0xD7, 0x8F, 0xC1, 0x87, 0x04, 0x40, 0x51, 0xB2, 0xBF, 0xBF, 0x7F, + 0x7E, 0xF7, 0xE6, 0xFE, 0xF1, 0xA5, 0xF3, 0x09, 0x28, 0xA9, 0x08, 0x8C, + 0x5F, 0xBC, 0x6A, 0xB7, 0x8D, 0xF8, 0xE1, 0xE7, 0xE7, 0xD9, 0xF9, 0x10, + 0x5D, 0x91, 0x91, 0xBB, 0xFD, 0xFE, 0x2F, 0x3F, 0x3E, 0x42, 0x9C, 0xD7, + 0x05, 0xA5, 0x38, 0x6A, 0x8D, 0x8C, 0x67, 0x31, 0xE1, 0xBE, 0xBF, 0x00, + 0x90, 0xF6, 0xDB, 0xCD, 0xD3, 0xF3, 0xD3, 0xCD, 0x7E, 0xA3, 0xD4, 0xD2, + 0x4F, 0x8B, 0x52, 0xFA, 0x8B, 0xB7, 0x5F, 0x5D, 0xEF, 0xAE, 0x09, 0xB0, + 0x79, 0x4E, 0x43, 0x0C, 0xCF, 0xC7, 0xA9, 0xAC, 0x6A, 0x0C, 0x01, 0xA5, + 0x78, 0x56, 0x26, 0xA5, 0x88, 0x7F, 0xF5, 0xCD, 0x0D, 0x84, 0xE9, 0xF5, + 0xFD, 0x2E, 0x2F, 0x09, 0xC1, 0x50, 0x08, 0xBE, 0xDD, 0xAD, 0x8B, 0x8C, + 0x34, 0x55, 0x61, 0x55, 0x7C, 0xF7, 0xEA, 0xFA, 0xED, 0xED, 0xEE, 0x74, + 0x1C, 0xC7, 0xD9, 0x18, 0xE7, 0x0F, 0xE7, 0x33, 0x44, 0x68, 0xB3, 0xD9, + 0x5C, 0xFA, 0x4E, 0x29, 0x6D, 0x5C, 0x38, 0x9D, 0xFB, 0xD7, 0xAF, 0xEE, + 0x7C, 0x4C, 0xE3, 0x34, 0x23, 0x84, 0x66, 0x39, 0x9F, 0x2F, 0x03, 0x42, + 0x68, 0x5E, 0x96, 0x75, 0x5B, 0x72, 0xCE, 0xE7, 0x51, 0x2D, 0xF3, 0xC5, + 0x7B, 0x3B, 0xCC, 0x23, 0x25, 0xC4, 0xA7, 0x38, 0x2C, 0x53, 0xC6, 0xD9, + 0xFD, 0xED, 0x55, 0xC5, 0xE9, 0xD5, 0xAA, 0xE1, 0x8C, 0x73, 0x42, 0x6F, + 0xF6, 0x1B, 0x00, 0x60, 0x55, 0x88, 0xB6, 0x2A, 0xEF, 0xAE, 0x76, 0x77, + 0x37, 0xD7, 0x88, 0x8A, 0x9F, 0x1F, 0x4F, 0xE3, 0x22, 0xE7, 0x45, 0x0A, + 0x4E, 0xBC, 0xF7, 0x21, 0x81, 0xC7, 0xC3, 0x10, 0x22, 0xE4, 0x94, 0xDC, + 0x5C, 0x6F, 0x56, 0xDB, 0x86, 0x30, 0x02, 0x10, 0xD2, 0xCE, 0xCE, 0x4A, + 0x43, 0x42, 0x16, 0x63, 0x13, 0x06, 0x4C, 0x88, 0xE7, 0xE7, 0x23, 0xA1, + 0x54, 0xCA, 0x29, 0xCB, 0xAB, 0xE0, 0xBD, 0x35, 0x7A, 0x91, 0xCB, 0xE9, + 0x74, 0x81, 0x08, 0x10, 0x82, 0xA5, 0x92, 0x4A, 0xE9, 0x22, 0x23, 0xDA, + 0xBA, 0xBB, 0xEB, 0xD5, 0xF5, 0x76, 0xF5, 0xE1, 0xA5, 0x53, 0x3E, 0x66, + 0x82, 0xE5, 0x59, 0xAE, 0xB5, 0x5D, 0x16, 0xC5, 0x18, 0x8B, 0x29, 0x54, + 0x65, 0xEE, 0xB5, 0xC7, 0x30, 0xCD, 0x6A, 0xE9, 0xC7, 0xB1, 0xEF, 0x26, + 0x6B, 0x1C, 0x84, 0x40, 0x2E, 0x0A, 0x82, 0x84, 0x18, 0xBC, 0xBE, 0xD9, + 0x13, 0x04, 0x6F, 0xAF, 0x57, 0x5A, 0xEB, 0xA6, 0xCC, 0xBF, 0x7A, 0x75, + 0x9B, 0xF1, 0x1C, 0x20, 0x16, 0x02, 0x18, 0xA7, 0x65, 0x1C, 0x25, 0x48, + 0x29, 0x26, 0x68, 0xB4, 0x1F, 0x97, 0xF9, 0x70, 0xBE, 0x18, 0xE7, 0xA5, + 0x75, 0xA7, 0x61, 0xCA, 0x0A, 0x21, 0xF2, 0x0C, 0x00, 0xB0, 0x5A, 0x95, + 0x77, 0xD7, 0xF5, 0xBB, 0x2F, 0xF7, 0x84, 0x20, 0x82, 0x60, 0x5E, 0x65, + 0x65, 0x53, 0x54, 0x95, 0x90, 0x52, 0x07, 0xEF, 0x57, 0xFB, 0xFA, 0xF0, + 0x72, 0xD8, 0x6E, 0xCA, 0x22, 0xE3, 0x84, 0x10, 0x00, 0xE2, 0xB4, 0x18, + 0x1F, 0xED, 0xEB, 0xFB, 0x3A, 0x44, 0x78, 0x3C, 0xCC, 0x8B, 0x0A, 0x18, + 0xA3, 0x10, 0x02, 0x26, 0xD0, 0xBA, 0x18, 0x13, 0xA0, 0x14, 0x0A, 0x4E, + 0x18, 0x46, 0x2E, 0x00, 0x65, 0x42, 0x4A, 0x40, 0x64, 0xA4, 0x6D, 0x85, + 0x92, 0x56, 0x70, 0x92, 0x0B, 0xFA, 0xF1, 0xF1, 0x02, 0x12, 0x7A, 0x7E, + 0x39, 0x8A, 0x4C, 0x6C, 0x76, 0x2B, 0xC2, 0xA8, 0x31, 0x76, 0x1C, 0x17, + 0xEB, 0xFC, 0xE9, 0x72, 0xF9, 0xA5, 0x93, 0xD6, 0x39, 0xE7, 0x43, 0x70, + 0x3E, 0x28, 0x29, 0xA9, 0xE0, 0x97, 0x7E, 0xE4, 0x9C, 0xAD, 0xD7, 0xF5, + 0x76, 0x53, 0x12, 0x0A, 0x01, 0x84, 0x45, 0x91, 0x19, 0x6D, 0x41, 0x8A, + 0xEF, 0xEE, 0xAF, 0x1F, 0x5E, 0xFA, 0x71, 0x32, 0x46, 0x1B, 0x67, 0x2C, + 0x44, 0xFE, 0xE9, 0xF9, 0x72, 0xE9, 0xCE, 0xCE, 0xDA, 0x97, 0xE3, 0x80, + 0x11, 0x7A, 0x79, 0x79, 0x9E, 0xC6, 0xC1, 0x78, 0x33, 0x2E, 0xF2, 0x78, + 0x9E, 0xAC, 0x4F, 0x11, 0xA6, 0xE3, 0x65, 0xE2, 0x22, 0x23, 0x94, 0x0E, + 0xA3, 0xF2, 0x3E, 0xAD, 0xD6, 0x5B, 0xC2, 0x78, 0x3F, 0xAB, 0x9F, 0x3E, + 0x7C, 0x9E, 0xFE, 0x3F, 0x9A, 0xEE, 0x6B, 0x57, 0xB3, 0x23, 0x4D, 0x13, + 0x73, 0x78, 0xB3, 0xEC, 0xEF, 0xB7, 0xCB, 0x9D, 0x4C, 0xB2, 0x58, 0xC5, + 0x62, 0x57, 0x75, 0xCF, 0x4C, 0x0B, 0x1A, 0x08, 0x3A, 0xD2, 0xA9, 0xEE, + 0x5B, 0x3A, 0x19, 0xA0, 0x31, 0x18, 0xA8, 0xBB, 0x7A, 0xBA, 0x48, 0x26, + 0xD3, 0x6E, 0xF3, 0xBB, 0xE5, 0xC3, 0x1B, 0x1D, 0xA4, 0x74, 0x0F, 0x11, + 0x40, 0xBC, 0x9F, 0x79, 0x62, 0x99, 0x43, 0x0C, 0xA7, 0x4B, 0x77, 0xEA, + 0xE6, 0x4B, 0xBF, 0x08, 0x0A, 0xCB, 0x42, 0x60, 0x42, 0x8C, 0x37, 0x94, + 0xE3, 0xA6, 0x2E, 0xB4, 0x9B, 0x9F, 0x8F, 0xE7, 0xB6, 0xAA, 0xEF, 0xF7, + 0xBB, 0xED, 0xA6, 0x06, 0x10, 0xEB, 0x25, 0xC2, 0x0C, 0xAA, 0x4A, 0x32, + 0x4E, 0xAC, 0x32, 0x4A, 0xC5, 0xA2, 0x5C, 0x53, 0xCC, 0x11, 0x62, 0x93, + 0x0A, 0xD6, 0xAA, 0xFE, 0x7A, 0x92, 0xED, 0x7E, 0xB3, 0x3D, 0x4C, 0xC3, + 0x70, 0xB9, 0x5E, 0x76, 0xFB, 0xBD, 0x28, 0xEB, 0xEE, 0x72, 0x64, 0x94, + 0xD5, 0x75, 0x85, 0x11, 0x7D, 0x7B, 0xBB, 0x99, 0xA7, 0x65, 0xBD, 0xBB, + 0x3D, 0x3E, 0x7F, 0xFD, 0xF8, 0xE9, 0xCB, 0x38, 0xCF, 0x29, 0x87, 0x45, + 0x19, 0x6B, 0xCC, 0x38, 0x2D, 0x0F, 0x77, 0x7B, 0xE3, 0x96, 0xDD, 0xB6, + 0x2D, 0x04, 0x6F, 0x9B, 0x22, 0xE7, 0x94, 0x11, 0x48, 0x30, 0x1B, 0x6F, + 0x87, 0x49, 0x01, 0x00, 0xB7, 0x9B, 0xFA, 0xBB, 0xC7, 0xC3, 0x7E, 0x55, + 0x39, 0x63, 0x61, 0x02, 0xA5, 0x64, 0x4D, 0x5D, 0x6A, 0x63, 0x00, 0xCC, + 0xF3, 0x34, 0x97, 0x25, 0x87, 0x28, 0x0D, 0xB3, 0x82, 0x10, 0x15, 0x25, + 0xDE, 0x6C, 0x6A, 0xE7, 0xEC, 0x5F, 0x7F, 0x7A, 0xF8, 0x87, 0xEF, 0xEF, + 0x1F, 0x6F, 0xB6, 0x9B, 0x55, 0x5D, 0x57, 0x42, 0x10, 0xBE, 0xDB, 0xAC, + 0x9A, 0xB2, 0x6C, 0xAB, 0x4A, 0x72, 0xC6, 0x28, 0x32, 0xCA, 0xEC, 0x1B, + 0x49, 0x09, 0x64, 0x14, 0x63, 0x8C, 0x52, 0x46, 0xD7, 0x6B, 0xFF, 0xFE, + 0xF3, 0x07, 0x13, 0x80, 0x0F, 0x41, 0x5B, 0x7D, 0x3C, 0x8F, 0x28, 0x87, + 0x4D, 0x2B, 0x28, 0xE1, 0x97, 0x4E, 0x2D, 0xB3, 0xED, 0xBA, 0x41, 0xCD, + 0x0B, 0xA3, 0x99, 0x61, 0x9C, 0x73, 0x06, 0x6C, 0xE5, 0xCD, 0xB8, 0x2C, + 0x76, 0x59, 0xD2, 0x3C, 0x0E, 0xBF, 0x7D, 0x7C, 0x4A, 0x08, 0xBD, 0x7D, + 0x78, 0x93, 0x01, 0x52, 0x46, 0x21, 0x00, 0x00, 0x00, 0x9C, 0xF1, 0xC7, + 0xBB, 0x03, 0xC2, 0x30, 0xA4, 0xE8, 0x63, 0x10, 0x82, 0x5F, 0xFB, 0x81, + 0x51, 0x2E, 0x04, 0x3F, 0x1C, 0xD6, 0x30, 0x03, 0xE7, 0x7C, 0xCE, 0xB9, + 0x90, 0xCC, 0x5A, 0x6F, 0xAC, 0xFB, 0x56, 0x0D, 0x18, 0xA7, 0x39, 0x82, + 0x64, 0xB4, 0x53, 0xDA, 0x9D, 0x2F, 0x3D, 0xC2, 0x68, 0xB7, 0x59, 0x55, + 0x25, 0x07, 0xD9, 0x58, 0x3B, 0x41, 0x04, 0x6E, 0xB7, 0x4D, 0x3F, 0x4C, + 0xCE, 0xC7, 0xA9, 0x1F, 0xCA, 0xB2, 0xDA, 0xEF, 0x77, 0x1F, 0xBE, 0x7E, + 0xB0, 0x31, 0x6D, 0x57, 0x07, 0x82, 0x13, 0x48, 0x38, 0x03, 0x9A, 0x20, + 0x26, 0x84, 0x2A, 0x1D, 0xA7, 0x25, 0x6F, 0xD6, 0x5B, 0xE7, 0xD3, 0xA2, + 0x34, 0xC1, 0x64, 0xBD, 0xDE, 0x2C, 0x6A, 0xF1, 0xDE, 0x05, 0x1F, 0xEE, + 0x0F, 0xFB, 0xDD, 0xE6, 0xB0, 0xDE, 0xDC, 0x0A, 0x21, 0xE7, 0x69, 0x9C, + 0xE7, 0x79, 0x54, 0xEE, 0xE9, 0xD8, 0x2B, 0x6D, 0x16, 0x6D, 0xB4, 0xB5, + 0xD3, 0xBC, 0x28, 0xED, 0x42, 0x82, 0x44, 0x08, 0x56, 0xD5, 0xB2, 0x2C, + 0xEA, 0x79, 0x9E, 0xC6, 0xC5, 0x10, 0x2E, 0x62, 0xF0, 0xBB, 0x55, 0x43, + 0x09, 0x8B, 0x01, 0x5B, 0xE3, 0xFE, 0xE3, 0xEB, 0xF1, 0x7C, 0xEE, 0xEE, + 0xEE, 0xDF, 0xDA, 0x10, 0x10, 0x42, 0x37, 0xBB, 0x83, 0xF3, 0x3E, 0xA4, + 0xE4, 0xD4, 0x54, 0x57, 0xE5, 0xA2, 0xF4, 0xB5, 0x1F, 0xEE, 0xEE, 0x6E, + 0xBA, 0x61, 0xFC, 0xA6, 0x83, 0x37, 0x15, 0x87, 0xC9, 0xE5, 0xE8, 0x7E, + 0xF9, 0xF5, 0xC3, 0x7A, 0xBD, 0x12, 0x04, 0xE6, 0x8C, 0x5E, 0x8E, 0xD7, + 0xD5, 0xAA, 0x46, 0x38, 0x8C, 0xB3, 0xE2, 0x8C, 0xF9, 0xA0, 0x40, 0x20, + 0xDF, 0xDD, 0x6D, 0xB5, 0x8F, 0xCB, 0xEB, 0x78, 0x77, 0xD8, 0x08, 0xCE, + 0xE2, 0xF5, 0x7A, 0xD8, 0xB6, 0x20, 0x03, 0x6D, 0xC3, 0xCB, 0x79, 0x44, + 0x54, 0x9C, 0xCE, 0x2F, 0x29, 0xE5, 0x9C, 0x93, 0x35, 0x20, 0x84, 0xE0, + 0x43, 0x68, 0x9B, 0x6A, 0xBB, 0x6A, 0x6F, 0x76, 0x87, 0x45, 0xE3, 0x8A, + 0x50, 0x80, 0x7C, 0x37, 0x8C, 0xE3, 0xB4, 0x00, 0x98, 0x5D, 0x48, 0x19, + 0x00, 0x8C, 0xD0, 0xEB, 0xCB, 0x39, 0xA6, 0x94, 0x12, 0x34, 0xC6, 0x0E, + 0xFD, 0xA8, 0xF5, 0x64, 0xF4, 0x74, 0x38, 0xDC, 0xBF, 0xFB, 0xEE, 0x50, + 0x55, 0x45, 0xF0, 0xB6, 0x1F, 0x7A, 0x4A, 0x49, 0x4E, 0x71, 0xBD, 0x56, + 0xFF, 0xF8, 0xC7, 0xC7, 0xE7, 0xCB, 0xB0, 0xDE, 0x6D, 0x25, 0x23, 0x4D, + 0xC3, 0xAD, 0x0B, 0x00, 0x64, 0xCA, 0x68, 0x55, 0xF2, 0x61, 0x9C, 0x9C, + 0xAD, 0xEE, 0xEF, 0x6F, 0xBC, 0x31, 0x3E, 0x92, 0x00, 0xFC, 0xF1, 0xD4, + 0x17, 0x52, 0x14, 0x15, 0x9F, 0x86, 0x45, 0xCA, 0xC2, 0x38, 0x0D, 0x11, + 0x24, 0x18, 0xFF, 0xDB, 0x7F, 0x9C, 0x41, 0x84, 0x9C, 0xF2, 0xD7, 0xD3, + 0x20, 0xB8, 0xF4, 0x61, 0xF4, 0xC1, 0x77, 0xFD, 0xD0, 0x14, 0xF4, 0xC7, + 0x1F, 0x1E, 0x8E, 0xE7, 0xA3, 0xB1, 0x0E, 0x13, 0x18, 0x73, 0xB6, 0xC7, + 0x1E, 0x53, 0x02, 0x31, 0xB8, 0x76, 0x13, 0xA5, 0xE8, 0xE6, 0xCD, 0x0D, + 0x48, 0xA1, 0x59, 0x15, 0xB2, 0x94, 0x75, 0x55, 0xDE, 0xED, 0xDB, 0x94, + 0x61, 0xD9, 0xB4, 0xE3, 0x30, 0x34, 0x92, 0x03, 0x88, 0x42, 0xF4, 0x24, + 0xED, 0xC7, 0x51, 0xBF, 0x9E, 0x2F, 0x84, 0x51, 0xCA, 0x49, 0x51, 0x60, + 0xEC, 0x98, 0x32, 0xF9, 0xE5, 0x75, 0xB4, 0x2E, 0xAE, 0x56, 0xDC, 0x87, + 0x94, 0x73, 0x0E, 0x21, 0xC7, 0x10, 0xAB, 0xB6, 0xA8, 0x4B, 0x9A, 0x1C, + 0xA8, 0x2A, 0x36, 0x99, 0xA0, 0x8C, 0x86, 0x30, 0x8F, 0xC3, 0x52, 0x95, + 0x1C, 0x23, 0xC4, 0x28, 0x59, 0xB4, 0x29, 0x2A, 0xF1, 0xAD, 0xDA, 0x25, + 0x04, 0x31, 0xF3, 0x3C, 0xCF, 0x3A, 0x43, 0xA8, 0x8D, 0xCE, 0x19, 0x40, + 0x08, 0x31, 0xC6, 0x94, 0x12, 0xEF, 0x03, 0x21, 0xB8, 0x6E, 0x8A, 0xD3, + 0xEB, 0x69, 0x9E, 0x67, 0x4A, 0x10, 0x04, 0x49, 0x72, 0xD2, 0x94, 0x55, + 0xC9, 0xE8, 0xBA, 0x6A, 0xCA, 0x46, 0xFE, 0x06, 0x9C, 0x37, 0x11, 0xE6, + 0x38, 0xCE, 0x53, 0x55, 0x53, 0xDD, 0x79, 0x4E, 0xA2, 0x72, 0xA1, 0xBF, + 0x0C, 0x6D, 0xC3, 0xDE, 0x7F, 0xEC, 0x62, 0x42, 0xC6, 0xFA, 0xE8, 0x95, + 0x2C, 0x88, 0xB9, 0xC4, 0x94, 0x73, 0xCA, 0x79, 0x51, 0x76, 0xB5, 0x2E, + 0xB5, 0xB1, 0x31, 0x81, 0x52, 0x8A, 0x87, 0xBB, 0xDB, 0x0C, 0xC8, 0x38, + 0x2F, 0xC3, 0xF0, 0xDC, 0x36, 0xF5, 0x9B, 0xBB, 0x1B, 0xEB, 0x96, 0x69, + 0x36, 0xDE, 0xFB, 0x7E, 0x54, 0x84, 0x30, 0xEF, 0x13, 0xA7, 0x68, 0x55, + 0x17, 0x2E, 0x92, 0xA7, 0xAF, 0xE7, 0xF3, 0x75, 0xB8, 0x76, 0xDD, 0xB6, + 0x6D, 0x9D, 0xB5, 0xB9, 0x4E, 0xE3, 0x14, 0xAE, 0x57, 0x1B, 0x93, 0xB7, + 0xD6, 0x72, 0x86, 0x71, 0xB2, 0x75, 0x53, 0x97, 0x75, 0x63, 0x5D, 0x2A, + 0x65, 0x31, 0x0C, 0x03, 0x84, 0xB0, 0xDD, 0x94, 0x54, 0x4D, 0x28, 0xF7, + 0x11, 0x3E, 0x12, 0x26, 0x0A, 0x81, 0xC7, 0xA1, 0x47, 0xBC, 0x99, 0x17, + 0xFD, 0xD7, 0x9F, 0xDE, 0xFC, 0xE5, 0xA7, 0x1F, 0xFE, 0xFB, 0x2F, 0xFD, + 0xA7, 0xE7, 0xAE, 0x24, 0x29, 0x65, 0xD8, 0x0D, 0x33, 0x4A, 0xC1, 0x38, + 0x9B, 0x52, 0xDA, 0x6F, 0xAA, 0xC7, 0xFB, 0x4D, 0xD3, 0x36, 0x10, 0x00, + 0xC2, 0xD8, 0xC7, 0xA7, 0x17, 0x4E, 0x49, 0x7A, 0x89, 0x52, 0x16, 0xDA, + 0x46, 0xCA, 0xA9, 0x94, 0x4C, 0x70, 0x9A, 0x52, 0x22, 0x08, 0x06, 0xE3, + 0x1B, 0x29, 0xFE, 0xE1, 0xCF, 0x8F, 0x6A, 0x89, 0x18, 0xE0, 0x98, 0x93, + 0x52, 0xAB, 0x04, 0x23, 0x44, 0x68, 0x55, 0x17, 0x94, 0xC2, 0x87, 0xC3, + 0xF4, 0xFE, 0xF3, 0x71, 0xB7, 0x2A, 0xEE, 0xF6, 0x5B, 0x8C, 0x48, 0x5B, + 0xC9, 0x18, 0x92, 0xC9, 0x11, 0x51, 0x4C, 0x30, 0x64, 0x09, 0xA6, 0x04, + 0x08, 0x26, 0x6D, 0x55, 0x57, 0x65, 0x81, 0x40, 0x96, 0x3F, 0x93, 0xF3, + 0xCB, 0xEB, 0xF1, 0x7A, 0x79, 0x79, 0xED, 0x5C, 0x08, 0xBB, 0xDD, 0xFA, + 0x7C, 0xBE, 0x6E, 0xF7, 0x87, 0xBA, 0x2C, 0x00, 0x08, 0x31, 0x65, 0x8C, + 0x13, 0x82, 0xF9, 0xD2, 0x69, 0x4C, 0x53, 0x4A, 0x28, 0xB8, 0xE5, 0x61, + 0x5F, 0x95, 0x6D, 0xA5, 0x96, 0x05, 0x44, 0x88, 0x11, 0x6C, 0xAB, 0x18, + 0x69, 0xBD, 0x2C, 0xF6, 0x66, 0xDF, 0xCC, 0xCB, 0xFC, 0xFD, 0x0F, 0xF7, + 0xEB, 0xA6, 0xC1, 0x10, 0x65, 0x04, 0xDF, 0x7D, 0x77, 0x4B, 0x10, 0xD0, + 0x4A, 0x95, 0x45, 0xDD, 0x0F, 0x43, 0x37, 0xCC, 0x98, 0x20, 0x65, 0xF5, + 0xB9, 0x9F, 0xA4, 0x94, 0xCB, 0xB2, 0x2C, 0xC6, 0x9D, 0x2E, 0x53, 0x5B, + 0xF2, 0xFD, 0xBA, 0xC9, 0x00, 0x3C, 0xBF, 0x5E, 0x33, 0x80, 0x04, 0xC3, + 0xD3, 0xB9, 0x67, 0x9C, 0x62, 0x82, 0xF3, 0x62, 0xCA, 0x42, 0x30, 0x8E, + 0x00, 0x42, 0xFD, 0x30, 0x1B, 0xE3, 0xB8, 0xE4, 0x84, 0xF2, 0xA9, 0xBB, + 0x4E, 0x8B, 0xED, 0xE7, 0xCB, 0xBA, 0x81, 0xFE, 0x1A, 0xB6, 0xFB, 0xFD, + 0x61, 0x7F, 0xFF, 0xEB, 0x87, 0x57, 0x02, 0xC9, 0xC3, 0xED, 0x83, 0x60, + 0xD5, 0x94, 0x74, 0xBB, 0xDD, 0xFC, 0xFA, 0xF1, 0xB4, 0xDB, 0x57, 0xC7, + 0xCB, 0x25, 0x45, 0x2F, 0xE5, 0x66, 0x19, 0xA7, 0xBE, 0x1B, 0x04, 0x27, + 0x65, 0xD5, 0xFE, 0xFD, 0xF7, 0xDF, 0x36, 0x6D, 0xF5, 0xF6, 0xFE, 0x56, + 0x6B, 0x27, 0x8A, 0xE2, 0xF5, 0xD8, 0xE7, 0x0C, 0x63, 0x06, 0xD1, 0xAB, + 0x75, 0x53, 0x20, 0x18, 0xD7, 0xAD, 0xB8, 0xDD, 0x55, 0x98, 0xE1, 0xF3, + 0x79, 0x79, 0x38, 0x6C, 0xAD, 0x0B, 0x75, 0xDD, 0xE2, 0x77, 0xDF, 0x1D, + 0xAE, 0xDD, 0x04, 0x20, 0x1A, 0xA6, 0xD1, 0x87, 0x94, 0x32, 0x28, 0x28, + 0x5D, 0xD7, 0xED, 0xA2, 0x5C, 0x3F, 0xCE, 0xC7, 0xD3, 0x88, 0x10, 0x5D, + 0x94, 0x6A, 0xDA, 0x95, 0xB1, 0x1E, 0x13, 0xE6, 0x83, 0xEF, 0xFA, 0xAB, + 0xD1, 0x06, 0x62, 0x72, 0xB3, 0xDB, 0x55, 0x65, 0x29, 0x05, 0x2B, 0x0B, + 0xD1, 0x0F, 0xBD, 0xB3, 0xFE, 0xCF, 0x7F, 0xFE, 0x73, 0x53, 0x17, 0xE7, + 0xF3, 0xC5, 0xDA, 0x40, 0x18, 0xBB, 0x5E, 0xAF, 0xEB, 0xB6, 0x41, 0x84, + 0x21, 0x08, 0x62, 0xF4, 0x31, 0x46, 0x08, 0xE1, 0xDB, 0x87, 0xFB, 0x71, + 0x52, 0x20, 0x02, 0x0C, 0xE9, 0x75, 0x54, 0xEB, 0xBA, 0xFC, 0xE1, 0xF1, + 0x16, 0x13, 0xF8, 0xF6, 0xE1, 0x66, 0x9E, 0x17, 0x08, 0x93, 0x75, 0x69, + 0x52, 0xFE, 0xF7, 0xDF, 0xDF, 0x2B, 0xB3, 0xCC, 0xCB, 0x64, 0xAC, 0xB6, + 0xCE, 0xFB, 0x10, 0x19, 0x21, 0xDF, 0xDF, 0xED, 0x10, 0xC4, 0xEB, 0xF5, + 0x96, 0xF2, 0x42, 0xEB, 0xF8, 0xE9, 0xD3, 0x57, 0x6B, 0x5D, 0x02, 0x40, + 0x6B, 0x37, 0x8E, 0x4B, 0x8C, 0x71, 0x1C, 0x97, 0x79, 0x56, 0x39, 0xE7, + 0x10, 0xA3, 0x73, 0x0E, 0x41, 0x3C, 0xF4, 0x17, 0x00, 0xD0, 0xCD, 0xCD, + 0x63, 0x8C, 0xB9, 0x28, 0x56, 0xF7, 0xF7, 0xEF, 0x76, 0xBB, 0xDB, 0x94, + 0x41, 0xDB, 0x6C, 0xEF, 0x76, 0x6B, 0x90, 0xB2, 0xCE, 0xB4, 0xEB, 0x2F, + 0x88, 0x60, 0xEB, 0x02, 0x42, 0x44, 0x6B, 0xBD, 0x6E, 0xC4, 0x7F, 0xFD, + 0xCF, 0x3F, 0xDC, 0xDF, 0xAC, 0xD6, 0xAB, 0xC2, 0xAA, 0xE5, 0x7C, 0xE9, + 0x8D, 0xF3, 0x5C, 0x30, 0x4C, 0x18, 0x46, 0x28, 0x81, 0x08, 0xA9, 0xF0, + 0x09, 0x58, 0xE3, 0xA6, 0xD9, 0x5A, 0x17, 0x62, 0x02, 0xCF, 0xC7, 0xEE, + 0xEB, 0xEB, 0x25, 0x03, 0x28, 0x18, 0x3B, 0x77, 0x7D, 0x08, 0x51, 0x08, + 0x72, 0xD8, 0xB7, 0x4F, 0xAF, 0xD7, 0xFF, 0xF9, 0xFE, 0x6B, 0xCA, 0xB1, + 0x6D, 0x4B, 0xE7, 0xC3, 0xA2, 0xCC, 0xF9, 0xD4, 0xCB, 0x52, 0xCC, 0xCB, + 0x32, 0x4D, 0xB3, 0x51, 0x3A, 0xA7, 0x94, 0x73, 0x5E, 0x66, 0x65, 0x4C, + 0xC8, 0x08, 0xA5, 0x98, 0x42, 0x48, 0x4A, 0xBB, 0x1C, 0x43, 0x74, 0x0E, + 0x82, 0x2C, 0x04, 0xDB, 0x6E, 0xB7, 0x82, 0x53, 0xC6, 0xF0, 0xD0, 0x0F, + 0x6A, 0x31, 0x08, 0x02, 0x8C, 0x70, 0xCA, 0x30, 0xC6, 0xB4, 0x2C, 0x3E, + 0xA5, 0x5C, 0x57, 0xF4, 0x7A, 0x31, 0x87, 0x5D, 0x9D, 0x33, 0x1C, 0x07, + 0x55, 0x15, 0x6C, 0xBB, 0xDF, 0x9F, 0x2F, 0x93, 0xD2, 0x3E, 0x67, 0x60, + 0xB4, 0x33, 0xC6, 0x53, 0x42, 0x18, 0xE5, 0xC6, 0x45, 0x2E, 0xE9, 0xBC, + 0x68, 0xAD, 0x94, 0x10, 0x08, 0x42, 0x30, 0x5C, 0xE7, 0xAA, 0x12, 0xDE, + 0x07, 0x26, 0x48, 0x08, 0x31, 0xA7, 0xBC, 0x5A, 0x37, 0x10, 0xC1, 0x1C, + 0xB2, 0x73, 0x9E, 0x53, 0x54, 0x4B, 0x96, 0x20, 0x68, 0x9A, 0x2D, 0xC1, + 0x48, 0x30, 0xEE, 0x4C, 0xF0, 0x21, 0x5D, 0xAF, 0x7D, 0x0C, 0xFE, 0x9F, + 0xFE, 0xF4, 0xC3, 0x7F, 0xFC, 0xF6, 0x55, 0x48, 0x51, 0xCA, 0x02, 0x62, + 0xEA, 0x7C, 0x4C, 0x89, 0xCC, 0xCB, 0x7C, 0xED, 0xA6, 0x63, 0x37, 0xB9, + 0x10, 0xA5, 0x20, 0xDE, 0xC7, 0x10, 0xF3, 0xF1, 0x32, 0x42, 0x08, 0x76, + 0x9B, 0x75, 0xCE, 0x59, 0x19, 0x83, 0xF1, 0x37, 0xDE, 0xBA, 0x8B, 0x09, + 0x1A, 0x67, 0xFB, 0xBE, 0xD3, 0x7A, 0x06, 0x39, 0x73, 0xCE, 0xE6, 0xC5, + 0xFC, 0xF2, 0xFB, 0xA7, 0x45, 0xBB, 0x45, 0x29, 0x84, 0x21, 0xA7, 0x0C, + 0x61, 0xA8, 0xB4, 0x45, 0x88, 0xC0, 0x0C, 0x82, 0x0F, 0x87, 0xCD, 0xEE, + 0x66, 0xB7, 0xDB, 0xAC, 0xF7, 0x18, 0xD2, 0x79, 0xB1, 0x19, 0xA4, 0xE0, + 0x0D, 0xA3, 0x70, 0xDD, 0xC8, 0x4D, 0xC3, 0x01, 0x84, 0x9C, 0x33, 0xAB, + 0x17, 0x42, 0x32, 0x15, 0x10, 0xA0, 0x44, 0x08, 0x91, 0x82, 0x97, 0xD5, + 0xC6, 0x5B, 0x15, 0x32, 0xAE, 0x9B, 0x4D, 0x48, 0x64, 0xB5, 0x3D, 0x04, + 0xDB, 0x3F, 0x1C, 0xDA, 0x62, 0xFD, 0xE6, 0xE9, 0xB5, 0x5F, 0x15, 0x14, + 0x82, 0x84, 0x8A, 0x75, 0x77, 0x7A, 0x82, 0x20, 0xF7, 0xE3, 0x72, 0xBB, + 0x5B, 0xFD, 0xF1, 0xED, 0x9E, 0x31, 0xFC, 0xF4, 0x72, 0xFE, 0xFB, 0xC7, + 0xD7, 0x59, 0x5B, 0x63, 0x9C, 0xF5, 0xD1, 0xFA, 0x34, 0x2E, 0xFE, 0x78, + 0xEA, 0xAD, 0x0F, 0xFD, 0xA8, 0x27, 0x65, 0x16, 0x63, 0x87, 0x7E, 0xCC, + 0x40, 0x0F, 0xCB, 0xF4, 0xEB, 0x2F, 0xC7, 0x61, 0x34, 0xCF, 0xA7, 0xFE, + 0xF9, 0xD4, 0xBD, 0x9E, 0x87, 0xAF, 0x2F, 0xD7, 0x97, 0x53, 0xD7, 0xF5, + 0x4B, 0xF0, 0x49, 0x32, 0x7E, 0xB3, 0x5D, 0x1D, 0xD6, 0x1B, 0x82, 0x28, + 0x41, 0x44, 0x2F, 0xFE, 0xDA, 0x2B, 0xE7, 0xD3, 0xF1, 0x38, 0x1E, 0x4F, + 0xF3, 0xEB, 0xEB, 0xEC, 0x42, 0x9E, 0x17, 0xE7, 0x5D, 0x84, 0x08, 0x35, + 0x95, 0x54, 0x46, 0x8D, 0xCA, 0xDC, 0xDF, 0xDF, 0x4A, 0xCA, 0xDB, 0xBA, + 0x52, 0xD6, 0x50, 0xCE, 0xF6, 0x9B, 0xED, 0x66, 0xDD, 0x4E, 0xD3, 0x04, + 0x12, 0xF8, 0xEE, 0xF1, 0x6E, 0xB3, 0x5D, 0xE5, 0x04, 0xB9, 0xC4, 0xB2, + 0xE4, 0xAB, 0xF5, 0xCE, 0x85, 0x9C, 0x12, 0x48, 0x99, 0x00, 0x00, 0xBE, + 0x7B, 0x7B, 0x0F, 0x61, 0x6C, 0xEB, 0xAA, 0x6D, 0x6A, 0xC6, 0xA8, 0xAC, + 0x8A, 0xEF, 0xBF, 0xBB, 0xC9, 0x20, 0x51, 0x4A, 0x00, 0x88, 0x39, 0xFB, + 0x97, 0xF3, 0xEB, 0xAC, 0xBA, 0x4B, 0x3F, 0x3F, 0x1D, 0x7B, 0xE3, 0xE3, + 0xF3, 0xF9, 0x7A, 0xED, 0x17, 0x6D, 0x22, 0x21, 0x6C, 0x59, 0xA6, 0xAA, + 0x60, 0xB7, 0x7B, 0xB6, 0x5D, 0xA3, 0xAE, 0xD7, 0xB3, 0xF2, 0xE7, 0x6E, + 0x99, 0x95, 0xE6, 0x9C, 0xC9, 0x42, 0x5A, 0xE7, 0xAD, 0x71, 0x98, 0x51, + 0x63, 0xAC, 0xD6, 0x0E, 0x42, 0x38, 0xCD, 0x6A, 0x9C, 0x96, 0x04, 0x40, + 0x0C, 0x40, 0xF2, 0x8A, 0x20, 0x74, 0xEE, 0xA6, 0x9C, 0x20, 0x2D, 0xB6, + 0x55, 0xB5, 0x01, 0x61, 0xD9, 0xB6, 0xF2, 0xB0, 0xDE, 0x5B, 0x97, 0xE6, + 0x79, 0x6A, 0xAA, 0x86, 0x52, 0x1E, 0x33, 0x92, 0x42, 0xBC, 0xBE, 0x76, + 0x77, 0x2B, 0xF6, 0xE5, 0xF9, 0x7A, 0x58, 0x37, 0xD3, 0xB2, 0x3C, 0x1E, + 0x76, 0xC6, 0x85, 0x73, 0x77, 0x7D, 0xF7, 0x70, 0x2B, 0xB8, 0xB0, 0x3E, + 0x11, 0xCC, 0xBB, 0x7E, 0x28, 0x8B, 0xB2, 0x94, 0xFC, 0x61, 0x5B, 0x7E, + 0xFF, 0xB8, 0xBD, 0xBF, 0x6D, 0x82, 0xF7, 0x6A, 0x59, 0x30, 0x04, 0x9B, + 0xBA, 0x44, 0x30, 0x11, 0x06, 0xA2, 0xD7, 0xF8, 0x70, 0xA8, 0x01, 0x00, + 0xD6, 0x98, 0x79, 0x56, 0x6D, 0xDB, 0x6C, 0x57, 0xAB, 0x75, 0x59, 0x7F, + 0xF9, 0x7A, 0xFE, 0xFD, 0xD3, 0xE9, 0xC3, 0xA7, 0x67, 0x08, 0x11, 0xC8, + 0xB0, 0x90, 0x05, 0x2B, 0x37, 0x65, 0xDD, 0xCC, 0x8B, 0xD2, 0xC6, 0xF4, + 0x43, 0x37, 0x4D, 0xE3, 0xBB, 0x77, 0xDF, 0x33, 0xC6, 0x16, 0xB5, 0x18, + 0x63, 0x42, 0xF4, 0x7F, 0x7F, 0xFF, 0x7B, 0x37, 0xCD, 0x00, 0x30, 0xA3, + 0xB5, 0xB1, 0xDA, 0x18, 0x5B, 0x55, 0x92, 0x31, 0x62, 0xAD, 0x2B, 0x0B, + 0xE9, 0x9D, 0x0D, 0xCE, 0x49, 0x5E, 0x50, 0x4C, 0xAE, 0x7D, 0xD7, 0x56, + 0xC5, 0xB6, 0x5E, 0x2F, 0x8B, 0x29, 0x84, 0xBC, 0xDD, 0xB5, 0xD6, 0x6B, + 0x46, 0x71, 0xDF, 0x8D, 0x3E, 0x47, 0x4C, 0x91, 0xF6, 0xE1, 0x74, 0x3E, + 0x83, 0xEC, 0x72, 0xCE, 0x5C, 0xCA, 0xB6, 0xAD, 0xAA, 0x82, 0xDE, 0xDF, + 0xEE, 0x7F, 0x78, 0xFB, 0x6E, 0xBF, 0xBB, 0x79, 0x73, 0xFF, 0xD0, 0xD4, + 0x72, 0xB5, 0xC1, 0x75, 0x4D, 0xEE, 0x6F, 0x37, 0x10, 0x61, 0xAD, 0xDD, + 0xF1, 0xD4, 0x89, 0x42, 0xE4, 0x9C, 0xAE, 0x97, 0x2E, 0x23, 0x4C, 0x09, + 0x4B, 0x29, 0x7C, 0x7B, 0x02, 0x04, 0x67, 0x09, 0xA1, 0x39, 0x27, 0xAD, + 0x97, 0xF5, 0x6A, 0x9B, 0x52, 0xFC, 0xF5, 0xD7, 0xBF, 0x3F, 0x3D, 0x3F, + 0xF5, 0x7D, 0x3F, 0x4D, 0xC3, 0xC7, 0xAF, 0x5F, 0x12, 0x70, 0x36, 0x04, + 0x1F, 0x40, 0x0A, 0x11, 0x23, 0xFA, 0xF6, 0x7E, 0xFD, 0x5F, 0xFE, 0xE1, + 0x91, 0x52, 0xE2, 0x42, 0xD6, 0xDA, 0xF5, 0xDD, 0x80, 0x29, 0xB2, 0x31, + 0x69, 0xED, 0x60, 0xCE, 0xA7, 0x6B, 0x6F, 0x7D, 0x9C, 0x16, 0xDD, 0x0D, + 0xE3, 0xF9, 0x3A, 0x40, 0xCC, 0xB4, 0x35, 0xD6, 0x79, 0x4E, 0xF1, 0xBA, + 0x91, 0x29, 0x43, 0x1F, 0x61, 0x0C, 0xF6, 0xCD, 0xDD, 0x9E, 0x60, 0x94, + 0x40, 0x72, 0x3E, 0x18, 0x6B, 0x1F, 0x1E, 0xF6, 0xD6, 0x04, 0xEF, 0xA3, + 0xF3, 0xB1, 0x5D, 0xD7, 0x29, 0x06, 0xEB, 0xDC, 0xA2, 0x3C, 0xA5, 0x94, + 0x31, 0xD6, 0x75, 0x63, 0x4A, 0xF9, 0x74, 0x1A, 0xAF, 0xA3, 0x1E, 0xC6, + 0xE5, 0xF8, 0x7A, 0x5D, 0xB4, 0xE5, 0x42, 0x6A, 0x1B, 0x8C, 0x09, 0x00, + 0x82, 0xEB, 0xE9, 0xCA, 0x05, 0x5F, 0xAD, 0x2A, 0x42, 0xA9, 0x36, 0x41, + 0x1B, 0x7F, 0xED, 0x66, 0x88, 0x30, 0x17, 0x88, 0x12, 0xE8, 0x5C, 0xD2, + 0x3A, 0x00, 0x00, 0x8B, 0x82, 0x5A, 0x6B, 0x43, 0x48, 0x75, 0x53, 0x2C, + 0x8B, 0x3A, 0x5F, 0x67, 0x4C, 0x48, 0x5D, 0xD7, 0xC6, 0x38, 0x08, 0xF2, + 0x7A, 0xDD, 0x30, 0x4E, 0x00, 0x84, 0x10, 0xC2, 0xB2, 0x14, 0x6D, 0x5D, + 0x94, 0x95, 0x64, 0x04, 0x57, 0x85, 0x68, 0x9A, 0x82, 0x09, 0xCC, 0x18, + 0xE9, 0x7B, 0xC5, 0x25, 0x33, 0xCA, 0x70, 0x4E, 0xBF, 0x11, 0x09, 0xC1, + 0xC7, 0xAA, 0x10, 0xEB, 0xF5, 0x7A, 0x9A, 0x4D, 0x21, 0x8B, 0x45, 0x29, + 0xAD, 0xAD, 0x0B, 0xC1, 0xB9, 0x30, 0x4D, 0xBE, 0x94, 0xFC, 0xDF, 0xDF, + 0x7F, 0xA2, 0x84, 0x5A, 0xA3, 0x97, 0x65, 0x56, 0x5A, 0x1D, 0xCF, 0x27, + 0x29, 0x4B, 0x00, 0x90, 0x2C, 0x2A, 0x84, 0xD0, 0x7E, 0xD3, 0x68, 0x63, + 0xAC, 0x0F, 0x19, 0xE4, 0x6F, 0x9F, 0xB0, 0xCD, 0x8B, 0xFA, 0xE6, 0x53, + 0x60, 0x8C, 0x94, 0x31, 0xCE, 0x39, 0x00, 0x00, 0x84, 0x08, 0x22, 0xB4, + 0x59, 0xAF, 0x87, 0x69, 0xB2, 0x3E, 0x42, 0x84, 0x18, 0x63, 0x3E, 0x84, + 0xC3, 0xA6, 0xF9, 0xE7, 0xBF, 0xFC, 0x50, 0x49, 0xBE, 0xAA, 0x9B, 0xBB, + 0xFD, 0x5E, 0xB0, 0xF2, 0xF1, 0xEE, 0xF1, 0xCD, 0xED, 0x5D, 0x5D, 0xB5, + 0x85, 0x28, 0x05, 0x25, 0x87, 0x4D, 0xF5, 0xF6, 0x6E, 0xC5, 0x71, 0xBE, + 0xBD, 0x69, 0x21, 0x41, 0xCB, 0x32, 0x63, 0xC6, 0x09, 0x25, 0xEB, 0x9D, + 0xA4, 0x9C, 0xAC, 0x77, 0xAD, 0x2C, 0x59, 0x8E, 0xA1, 0x2C, 0x28, 0x24, + 0x25, 0x65, 0x70, 0x53, 0xE9, 0xD5, 0x5A, 0x12, 0x2A, 0x2F, 0xBD, 0xF9, + 0xFE, 0x96, 0x6F, 0xB7, 0x37, 0x1A, 0xDF, 0x74, 0xA7, 0xE7, 0xE3, 0xD7, + 0xDF, 0x23, 0x29, 0x5C, 0xC8, 0xBF, 0xFE, 0xFD, 0x5F, 0xAB, 0x32, 0xF6, + 0xE3, 0xB4, 0x6A, 0x9A, 0xB6, 0x6E, 0x3F, 0x3C, 0x1D, 0x33, 0x4E, 0xDD, + 0x55, 0x4D, 0x8B, 0xB6, 0x36, 0x5A, 0x9B, 0x87, 0x51, 0xA7, 0x9C, 0x43, + 0xCC, 0xB3, 0x32, 0x8B, 0xD6, 0xE3, 0x38, 0xE7, 0x1C, 0x09, 0x05, 0xFB, + 0x3D, 0x57, 0x66, 0xB1, 0x0E, 0x68, 0xED, 0x63, 0x8C, 0x8C, 0x92, 0x98, + 0x13, 0x22, 0xE4, 0xDA, 0x4D, 0xA5, 0x28, 0xBE, 0xFF, 0xEE, 0xCD, 0xC7, + 0x2F, 0xAF, 0x31, 0xA2, 0x7E, 0x74, 0xC6, 0xA7, 0x8C, 0xE0, 0xA4, 0x6C, + 0x37, 0xAA, 0xE3, 0x65, 0x5C, 0x66, 0x45, 0x19, 0x19, 0x16, 0xFD, 0x7C, + 0xBC, 0x4E, 0xCB, 0xAC, 0xBD, 0x87, 0xD1, 0x76, 0xC3, 0xF4, 0xF7, 0x0F, + 0x5F, 0x5E, 0xCF, 0xD7, 0x94, 0x48, 0x21, 0xCB, 0xC3, 0x7E, 0x4B, 0x08, + 0x46, 0x84, 0x40, 0x88, 0x7D, 0x08, 0xC6, 0x98, 0x55, 0xDB, 0x70, 0x4E, + 0xAD, 0x71, 0x20, 0x41, 0x00, 0xE0, 0xF3, 0xCB, 0xF5, 0xEB, 0x4B, 0xFF, + 0x7A, 0xBA, 0x52, 0x4A, 0x2B, 0x29, 0xD7, 0xAB, 0xCA, 0x1A, 0x35, 0x4F, + 0xEA, 0x78, 0x1C, 0xBE, 0xC5, 0x14, 0x90, 0xC1, 0xD8, 0x2F, 0xC3, 0xB0, + 0x9C, 0xCF, 0xC3, 0xE5, 0xDC, 0x7D, 0xF8, 0xFA, 0x12, 0x21, 0xF1, 0x1E, + 0x0C, 0x83, 0xE1, 0x52, 0x40, 0x84, 0x42, 0xCC, 0x42, 0x8A, 0xB6, 0xE1, + 0x82, 0xB8, 0xA6, 0xA4, 0xB3, 0xD6, 0x85, 0x08, 0xD6, 0xD9, 0x0F, 0x4F, + 0x33, 0xC2, 0x94, 0x30, 0xF1, 0x72, 0x3A, 0x52, 0x4C, 0x05, 0x67, 0x19, + 0xA1, 0x45, 0x99, 0x6F, 0x19, 0x13, 0x00, 0x88, 0x31, 0x86, 0x18, 0x66, + 0x00, 0x63, 0x4C, 0x3E, 0x04, 0x90, 0x61, 0x55, 0x14, 0x18, 0x4B, 0xE5, + 0x0B, 0x8E, 0x81, 0x60, 0x71, 0xDD, 0x56, 0x9C, 0x42, 0xE7, 0x35, 0x02, + 0x46, 0x72, 0xD8, 0x36, 0x35, 0x24, 0xF4, 0xF1, 0xE1, 0xE0, 0xED, 0xB2, + 0x6E, 0x85, 0x10, 0xAD, 0x10, 0x4D, 0x59, 0x8A, 0x7D, 0x5B, 0x65, 0x00, + 0x37, 0xEB, 0x46, 0x1B, 0xB7, 0x6E, 0x1A, 0xE3, 0xD2, 0xBA, 0x2E, 0x2E, + 0x5D, 0xBF, 0x68, 0xBD, 0xAA, 0x9B, 0xF5, 0xAA, 0x39, 0xAC, 0xA5, 0xD1, + 0xF3, 0x6F, 0x9F, 0x8E, 0xC3, 0x38, 0xBF, 0x7B, 0xB8, 0xF3, 0x1E, 0x58, + 0x17, 0xCE, 0xD7, 0x7E, 0x98, 0xD4, 0x38, 0xCE, 0xC4, 0x58, 0x07, 0x21, + 0x3A, 0x9F, 0x3A, 0x98, 0xD0, 0x5F, 0x7E, 0xFC, 0x99, 0x22, 0xA2, 0x6D, + 0x84, 0x88, 0x16, 0x85, 0x30, 0xDE, 0x60, 0x02, 0x9B, 0x5A, 0x0A, 0xD9, + 0xDC, 0xDE, 0xEF, 0x9C, 0x73, 0xD3, 0xC4, 0x52, 0x4E, 0x45, 0x51, 0x2B, + 0x6D, 0xB2, 0x9F, 0x75, 0x80, 0x19, 0x78, 0xE3, 0xCD, 0xB9, 0xBB, 0x18, + 0xEB, 0x24, 0x17, 0xC7, 0xD3, 0x13, 0x02, 0xB9, 0x6D, 0xEA, 0x75, 0x5B, + 0x2F, 0x6A, 0xC1, 0x98, 0x50, 0xCA, 0xBC, 0xB7, 0x21, 0x04, 0x8C, 0x68, + 0x0C, 0xA1, 0x2A, 0x85, 0x36, 0x66, 0x5D, 0x71, 0x4A, 0xB0, 0x04, 0x4D, + 0x21, 0x48, 0x48, 0xEE, 0xDA, 0xF5, 0xE3, 0xA4, 0x43, 0x08, 0x4C, 0xF2, + 0xD9, 0xFA, 0x18, 0x52, 0xDB, 0x14, 0xEB, 0xB6, 0x26, 0xB4, 0x90, 0x55, + 0xED, 0xED, 0xFC, 0xE6, 0x6E, 0xAF, 0x6D, 0x7C, 0x7E, 0xE9, 0x08, 0x21, + 0x1F, 0x3F, 0x7F, 0x5A, 0xB4, 0x82, 0x38, 0x6E, 0x37, 0x35, 0x22, 0x28, + 0x46, 0x70, 0xFF, 0xD0, 0x82, 0x1C, 0xC7, 0x49, 0x7F, 0x3C, 0x5E, 0x32, + 0x84, 0x20, 0x85, 0x45, 0x2F, 0x8C, 0x4B, 0x90, 0x13, 0x48, 0x2E, 0x83, + 0x0C, 0x00, 0x30, 0xC6, 0xFC, 0xF9, 0xA7, 0xBF, 0x08, 0xCE, 0xCF, 0xE7, + 0xF3, 0x34, 0x2F, 0xCE, 0x79, 0xE7, 0xF4, 0x34, 0x99, 0xBA, 0xE1, 0x2F, + 0xAF, 0x47, 0x59, 0x94, 0xBB, 0xB6, 0xBC, 0x3F, 0x34, 0x4D, 0x2B, 0xCC, + 0xA2, 0x8F, 0xE7, 0xBE, 0x1B, 0x66, 0x48, 0x44, 0x4E, 0x09, 0x31, 0xD6, + 0x0D, 0xC3, 0xB5, 0x5B, 0x6C, 0x00, 0x04, 0xC3, 0xED, 0x6E, 0x93, 0xBC, + 0xF3, 0xC1, 0xCD, 0xB3, 0xCA, 0x00, 0x4D, 0x43, 0xCF, 0x09, 0x32, 0x2E, + 0x3C, 0xDC, 0x6E, 0xDE, 0xDC, 0xAC, 0x57, 0xED, 0x16, 0x40, 0x5C, 0x30, + 0x08, 0x01, 0xFE, 0xF5, 0xE3, 0x55, 0x70, 0x4C, 0x09, 0xA6, 0x94, 0xBC, + 0xFF, 0xF0, 0x62, 0xAD, 0x2F, 0xA4, 0xB8, 0x39, 0xAC, 0x8D, 0x35, 0xF3, + 0xA2, 0x28, 0xA7, 0x87, 0x87, 0xED, 0x32, 0xEA, 0x97, 0xD7, 0x4E, 0x4A, + 0x82, 0x4C, 0x28, 0x9A, 0xCA, 0x3A, 0x3F, 0xF4, 0x23, 0x41, 0x98, 0x23, + 0x3C, 0x4E, 0x9A, 0x73, 0x52, 0xAD, 0x1B, 0xB3, 0xA8, 0x72, 0xB5, 0xF1, + 0xCE, 0x77, 0xBD, 0x76, 0x1E, 0x3C, 0xBE, 0x7D, 0x30, 0xC6, 0x9C, 0x2F, + 0x97, 0x18, 0x3D, 0xC8, 0x19, 0x49, 0x70, 0x77, 0x53, 0xF8, 0x10, 0x9B, + 0xA6, 0x4E, 0x21, 0x30, 0x82, 0xBE, 0x3E, 0x1F, 0x83, 0xB3, 0x08, 0x24, + 0x46, 0x80, 0xF1, 0x7E, 0xE8, 0xC7, 0xB2, 0x64, 0xDB, 0x4D, 0xDD, 0x36, + 0xF5, 0x38, 0xCC, 0x9B, 0x8D, 0x74, 0x36, 0x6C, 0x37, 0x0D, 0x42, 0x28, + 0xE5, 0x5C, 0x08, 0xF6, 0x6D, 0x20, 0x9B, 0x20, 0xD2, 0x8F, 0x73, 0x0A, + 0x29, 0x26, 0x60, 0xB5, 0xEF, 0xC6, 0x59, 0x08, 0xC6, 0x29, 0x8D, 0x10, + 0x12, 0x42, 0x11, 0xA2, 0x21, 0x44, 0xEB, 0xF3, 0x34, 0x2A, 0x98, 0x63, + 0x55, 0x97, 0x18, 0xD3, 0x87, 0xDB, 0xF6, 0xF5, 0x32, 0xB4, 0x4D, 0xAD, + 0x8D, 0x5D, 0x92, 0x87, 0x10, 0x7A, 0x97, 0x8A, 0xAA, 0x60, 0x82, 0x2F, + 0x4B, 0xCA, 0x00, 0x3A, 0x1F, 0x7E, 0xFD, 0xF4, 0xE2, 0x9C, 0x53, 0xD6, + 0x02, 0x00, 0x00, 0x00, 0xD6, 0xA7, 0x42, 0xF2, 0x65, 0xD1, 0x3E, 0x44, + 0xC2, 0x08, 0x25, 0x14, 0x21, 0x4A, 0x08, 0x8D, 0x31, 0x16, 0x45, 0x99, + 0x01, 0x1A, 0xE7, 0xD1, 0x18, 0x53, 0x55, 0x0D, 0x44, 0x98, 0x51, 0x2C, + 0x28, 0x9A, 0xA7, 0x99, 0x31, 0x16, 0x62, 0xEC, 0x86, 0x25, 0x67, 0x30, + 0x2E, 0xF6, 0x3A, 0x0C, 0x8C, 0x42, 0xEF, 0x33, 0x42, 0x40, 0x70, 0xBA, + 0x5D, 0xB5, 0xB2, 0xDA, 0xA6, 0x1C, 0x9C, 0x33, 0x80, 0xC9, 0x7A, 0xD3, + 0x82, 0x1C, 0xAD, 0x77, 0x19, 0x82, 0x0F, 0xFF, 0xF3, 0x98, 0x21, 0x0C, + 0x31, 0x54, 0xB5, 0x8C, 0xA1, 0x7F, 0x7A, 0x9E, 0x7F, 0xFC, 0xE1, 0xBB, + 0x60, 0xC7, 0x75, 0x23, 0x5F, 0xCE, 0x9A, 0x49, 0xE2, 0xE8, 0xEE, 0xF8, + 0x7A, 0x8C, 0x76, 0x34, 0xCE, 0xD5, 0x72, 0x73, 0x7A, 0x7D, 0xEA, 0xA7, + 0xF9, 0x3F, 0xFD, 0x24, 0x28, 0x29, 0x8A, 0xA2, 0x18, 0x97, 0x29, 0xA6, + 0xB0, 0x4C, 0xB9, 0x9F, 0x4D, 0x08, 0x51, 0x4A, 0x1A, 0x82, 0xAB, 0x1B, + 0x1A, 0x63, 0xC4, 0xC0, 0xDF, 0xDE, 0xAF, 0x5E, 0xCF, 0xB3, 0xF7, 0x2E, + 0x85, 0x25, 0x39, 0x76, 0x7D, 0xD1, 0x31, 0x01, 0x08, 0x19, 0xC6, 0x04, + 0x12, 0x80, 0x08, 0xA2, 0x89, 0x79, 0xE3, 0x1F, 0x6E, 0xB6, 0xBB, 0xF5, + 0xE6, 0xFF, 0xFE, 0x6F, 0x7F, 0xEB, 0x86, 0xF1, 0x1F, 0x7F, 0xFA, 0x11, + 0x40, 0x70, 0xEE, 0xE7, 0xF5, 0x6A, 0xE5, 0xA3, 0x8D, 0x39, 0x1B, 0xEB, + 0xB7, 0x4D, 0xE1, 0xBC, 0xC1, 0x2C, 0x8B, 0x88, 0x8C, 0xB1, 0xE6, 0x3C, + 0x47, 0x45, 0x7D, 0xE2, 0x31, 0x0B, 0x46, 0xB8, 0xB1, 0xE0, 0x92, 0x74, + 0x37, 0xD9, 0xB2, 0xE4, 0x4D, 0xC3, 0x9C, 0xF1, 0x53, 0x3F, 0xB4, 0xED, + 0x0A, 0x41, 0xFC, 0xFC, 0xE5, 0xEC, 0x8C, 0x8F, 0x08, 0xBF, 0x9C, 0x8E, + 0x10, 0x02, 0x6B, 0x83, 0xE4, 0xB8, 0x29, 0xE4, 0xB6, 0x29, 0x6D, 0xB0, + 0x3E, 0xA6, 0xB2, 0x96, 0xAB, 0x5D, 0x93, 0x63, 0x46, 0x00, 0x4E, 0xE3, + 0x72, 0xBE, 0x0E, 0x21, 0x24, 0x1F, 0xBF, 0xAD, 0x3A, 0x41, 0xEA, 0x53, + 0xF2, 0x19, 0x63, 0x82, 0x20, 0xA8, 0xAB, 0x22, 0xE7, 0x24, 0x4B, 0xA2, + 0x94, 0xFA, 0x7A, 0xD4, 0x05, 0x67, 0x39, 0xA3, 0x0F, 0x5F, 0x55, 0x55, + 0x60, 0x65, 0x3D, 0x80, 0x8A, 0xD2, 0xD0, 0x54, 0x35, 0xC1, 0x68, 0x98, + 0x16, 0x08, 0x90, 0x10, 0x22, 0xA6, 0xA0, 0xB5, 0x75, 0x2E, 0xE4, 0x04, + 0x08, 0xC1, 0xAB, 0x75, 0x93, 0x62, 0xF4, 0x3E, 0xE8, 0x0C, 0x19, 0xA3, + 0x29, 0xA7, 0xDD, 0x8A, 0x57, 0x1C, 0x87, 0x9C, 0xB4, 0x9E, 0xAB, 0x92, + 0x03, 0xE0, 0xDA, 0xA6, 0xDE, 0x54, 0xC5, 0x30, 0x4D, 0xB2, 0xA4, 0xC1, + 0x86, 0xBB, 0x43, 0x35, 0xCE, 0x29, 0x27, 0xD4, 0x34, 0x8D, 0xF5, 0x91, + 0xE3, 0x44, 0x31, 0x1D, 0x66, 0x87, 0x31, 0x29, 0x64, 0x11, 0xA2, 0x2A, + 0x18, 0xAE, 0x38, 0xDA, 0xD5, 0xBB, 0x77, 0x6F, 0x36, 0x2A, 0xC4, 0xF7, + 0xAF, 0xE3, 0xFB, 0xDF, 0x7E, 0x81, 0x10, 0xFC, 0xF8, 0xDD, 0xDD, 0xB9, + 0xEB, 0xB5, 0xB3, 0xCB, 0xE2, 0x73, 0x02, 0x94, 0xE1, 0x94, 0x23, 0x31, + 0x26, 0x18, 0x6D, 0xEF, 0xB6, 0xBB, 0x7F, 0xFE, 0x87, 0x9F, 0x33, 0x64, + 0x8C, 0x53, 0x1F, 0x01, 0x22, 0x62, 0xB3, 0xDD, 0xFD, 0x53, 0xF3, 0xC7, + 0x69, 0x5A, 0x40, 0x02, 0x52, 0x08, 0x0A, 0x17, 0xE5, 0xF4, 0xC3, 0x6D, + 0x15, 0x63, 0xF1, 0xAF, 0x7A, 0x26, 0x39, 0xD1, 0x6C, 0x9D, 0xF7, 0x7F, + 0xFE, 0xD3, 0x63, 0x44, 0xE8, 0x78, 0xBA, 0xBE, 0xD5, 0x7B, 0xC6, 0xE8, + 0x6A, 0x53, 0x9F, 0x5F, 0x7B, 0xA3, 0x7D, 0x21, 0xB9, 0x3F, 0x5A, 0x63, + 0x6C, 0x06, 0xF0, 0x74, 0x9A, 0xFE, 0xF0, 0xDD, 0xE3, 0xEB, 0xE5, 0x92, + 0x40, 0xA8, 0x0B, 0x99, 0x42, 0x7E, 0x7E, 0x59, 0x08, 0xCB, 0x09, 0xC4, + 0xE0, 0xA8, 0x8F, 0xC9, 0x98, 0xD8, 0xCF, 0x81, 0x50, 0x08, 0x12, 0xFC, + 0xF2, 0x74, 0xD9, 0xAC, 0xD6, 0x0F, 0x77, 0xF7, 0x04, 0x22, 0x1B, 0xF3, + 0x7A, 0x53, 0x60, 0xDC, 0x5C, 0xCE, 0x73, 0x70, 0xE6, 0xF1, 0x61, 0x55, + 0x14, 0xE9, 0xF7, 0x8F, 0xE3, 0x75, 0x9A, 0x1E, 0xEE, 0xB7, 0xCE, 0x05, + 0x10, 0x91, 0xB6, 0x76, 0x31, 0xA6, 0x69, 0x8A, 0xF5, 0xBA, 0xEE, 0xE7, + 0xA1, 0x10, 0xA2, 0x1B, 0x26, 0x4C, 0x78, 0xBD, 0xDA, 0x78, 0x63, 0x96, + 0xE9, 0x82, 0x10, 0x72, 0xDE, 0xEE, 0xF7, 0xB7, 0x29, 0xE5, 0xD3, 0xF9, + 0xA8, 0xAD, 0x0D, 0x39, 0x5A, 0xAB, 0x01, 0xF0, 0x82, 0xE1, 0x65, 0xD6, + 0x8F, 0x6F, 0xF6, 0xDB, 0x75, 0x9B, 0x83, 0x5B, 0xA6, 0x31, 0x46, 0xF3, + 0xFA, 0xDC, 0x03, 0x8C, 0xB5, 0xB6, 0xDB, 0x1D, 0x14, 0x82, 0xFF, 0xF6, + 0xFB, 0x69, 0x9C, 0x16, 0x59, 0x0A, 0x41, 0xF1, 0x70, 0x9D, 0xBF, 0x3B, + 0x80, 0x28, 0x48, 0x59, 0x6C, 0x32, 0x20, 0x29, 0x47, 0x8E, 0x93, 0xA0, + 0x74, 0xD3, 0xCA, 0xDB, 0xC3, 0xBA, 0xA9, 0x57, 0x41, 0xC5, 0x71, 0x9C, + 0x26, 0x9D, 0x72, 0x46, 0x4D, 0x5D, 0xA4, 0x9C, 0xB4, 0xD6, 0xD3, 0xB7, + 0x7B, 0x8B, 0xD1, 0x38, 0x2B, 0x0C, 0x51, 0x48, 0x31, 0x01, 0xD0, 0x8D, + 0x53, 0xD7, 0x2F, 0x94, 0xB1, 0xE8, 0x63, 0x4C, 0xB2, 0x1F, 0xD4, 0xE1, + 0xF6, 0x1B, 0x87, 0x92, 0x58, 0x29, 0x13, 0x40, 0xAF, 0xAF, 0x1D, 0x25, + 0x08, 0x93, 0x1E, 0xE6, 0xCC, 0x28, 0x2D, 0xAA, 0x02, 0x13, 0x52, 0x71, + 0x11, 0x53, 0xC6, 0x98, 0xDC, 0xDD, 0xDD, 0x50, 0x8A, 0x09, 0x44, 0xCB, + 0xE2, 0x21, 0x04, 0x08, 0x82, 0x98, 0x80, 0x28, 0x58, 0x51, 0xF0, 0xA6, + 0xA8, 0x65, 0x41, 0x10, 0x81, 0xBF, 0x7D, 0x7C, 0x09, 0x11, 0x7C, 0xFA, + 0xFC, 0x72, 0xD8, 0x35, 0x9B, 0x55, 0x9D, 0x12, 0xAC, 0xCA, 0x02, 0x13, + 0x4C, 0x20, 0x0A, 0x21, 0x7A, 0x67, 0xB9, 0xE0, 0x08, 0x21, 0xC6, 0x28, + 0xC8, 0x20, 0xC6, 0x54, 0x17, 0xC5, 0xFF, 0xF2, 0x4F, 0x3F, 0x2D, 0xB3, + 0xFE, 0xF5, 0xFD, 0xF3, 0xB5, 0x9F, 0x96, 0xC5, 0xCC, 0x39, 0x11, 0x8C, + 0xB7, 0x6D, 0xD2, 0x5A, 0x43, 0x08, 0xB5, 0x56, 0x08, 0x93, 0x94, 0xB0, + 0x36, 0x01, 0xA4, 0xD0, 0x56, 0xB5, 0xB1, 0x6E, 0xB3, 0x6E, 0x10, 0x42, + 0x5F, 0xBF, 0xBE, 0x5A, 0xEF, 0x9B, 0xAA, 0x12, 0x9C, 0x3F, 0x3F, 0x3F, + 0xC7, 0x94, 0x33, 0x00, 0x08, 0x22, 0x84, 0x10, 0x61, 0x82, 0xA7, 0xCC, + 0x05, 0x93, 0x5C, 0x30, 0x8E, 0x86, 0x71, 0x09, 0x31, 0xB4, 0x6D, 0x39, + 0x4E, 0x06, 0x42, 0x68, 0xAD, 0x06, 0x00, 0x00, 0x90, 0x8D, 0x51, 0xD3, + 0x34, 0xE4, 0x9C, 0x01, 0x00, 0xD6, 0x1A, 0x67, 0xCD, 0xB6, 0xAD, 0x04, + 0xE3, 0xD6, 0x3A, 0x90, 0x01, 0x44, 0xA4, 0xEB, 0x47, 0x8C, 0x09, 0x44, + 0x60, 0x5A, 0x94, 0xD6, 0xFA, 0xEE, 0xB0, 0xA6, 0x94, 0x28, 0xE3, 0xCE, + 0xBD, 0x66, 0x8C, 0x34, 0x05, 0xE7, 0x52, 0x7A, 0x95, 0x9F, 0x9F, 0x4F, + 0x21, 0xC5, 0x45, 0xF9, 0x4B, 0x37, 0x13, 0x4E, 0xA6, 0xF9, 0xFF, 0x0B, + 0x07, 0x04, 0xE3, 0x98, 0xC5, 0xCB, 0x79, 0xE6, 0x8C, 0x8E, 0x16, 0x87, + 0x18, 0x46, 0x5B, 0x33, 0x8D, 0x74, 0xFF, 0x9E, 0x20, 0xB3, 0xBD, 0x7D, + 0x44, 0x29, 0x1D, 0xDA, 0xEE, 0xE6, 0x7F, 0xDD, 0x30, 0x80, 0x1F, 0x6F, + 0x2A, 0x48, 0x72, 0x4E, 0x66, 0xD5, 0xF2, 0x59, 0xF9, 0xFF, 0xF4, 0x97, + 0x07, 0x00, 0xBC, 0x52, 0xE1, 0xF8, 0xDA, 0xDD, 0xDD, 0x35, 0xC3, 0x10, + 0x18, 0x0C, 0x6F, 0x6F, 0xA1, 0xB5, 0x31, 0x45, 0x52, 0x11, 0xB8, 0x5B, + 0x71, 0x97, 0xCB, 0xBE, 0x9B, 0xFE, 0xC7, 0xDF, 0xBE, 0x38, 0x9F, 0xD6, + 0xAB, 0x82, 0x33, 0x52, 0x97, 0xCD, 0x75, 0x98, 0x18, 0x86, 0xD6, 0xC5, + 0x73, 0xD7, 0xB5, 0x75, 0x05, 0x10, 0x84, 0x29, 0x6E, 0x56, 0x72, 0x98, + 0xC6, 0xE7, 0xD7, 0x63, 0x51, 0xC8, 0xB7, 0x77, 0xBB, 0x10, 0xE3, 0xC7, + 0xCF, 0xD7, 0x0C, 0xFC, 0x8F, 0x3F, 0x3C, 0x2C, 0x0A, 0xE7, 0x24, 0xBC, + 0x55, 0x90, 0x42, 0x0C, 0xC0, 0x30, 0xE8, 0x59, 0xFB, 0x55, 0x5B, 0x63, + 0x0C, 0xB4, 0xF3, 0x85, 0xA3, 0x04, 0x81, 0xBA, 0xAE, 0x05, 0x15, 0xA7, + 0xD7, 0x4B, 0x3F, 0x2C, 0x00, 0xA2, 0x5F, 0x3F, 0x7F, 0x9A, 0x94, 0xFE, + 0xF9, 0x87, 0x7B, 0x2A, 0xC9, 0x62, 0x1D, 0xC0, 0xB1, 0x59, 0x17, 0xB3, + 0x86, 0x12, 0xCA, 0xAA, 0x14, 0x31, 0x04, 0xAB, 0x83, 0x10, 0xBC, 0xAC, + 0x2B, 0xE7, 0x03, 0x84, 0x10, 0x33, 0x5C, 0xD7, 0xB2, 0xAE, 0x0B, 0x46, + 0xF1, 0x38, 0xCE, 0x9B, 0xB6, 0x6A, 0xCA, 0x6A, 0xB5, 0x6E, 0x66, 0x6D, + 0xFA, 0x69, 0x2A, 0xB8, 0xF0, 0x11, 0xBC, 0xFF, 0xFD, 0xB3, 0xF5, 0xE1, + 0xE5, 0x38, 0xF4, 0x83, 0x29, 0x4B, 0xF9, 0xE6, 0xB0, 0xE9, 0x27, 0xB5, + 0x69, 0xD7, 0x39, 0xE5, 0x69, 0x51, 0x10, 0x42, 0xE4, 0x73, 0x51, 0x49, + 0x4A, 0x89, 0x36, 0x53, 0xCA, 0xD9, 0x5B, 0x97, 0xAE, 0x63, 0x51, 0x4A, + 0x90, 0x52, 0x0E, 0x4E, 0x51, 0xE4, 0x9C, 0x65, 0x02, 0x75, 0x53, 0x4C, + 0x21, 0x12, 0x42, 0xA6, 0x71, 0xE4, 0x38, 0x49, 0x26, 0x4E, 0xDD, 0x98, + 0x61, 0xB2, 0x73, 0x00, 0x29, 0x5F, 0xAF, 0xA3, 0xB6, 0xB6, 0x90, 0x6C, + 0x18, 0x35, 0xC1, 0x14, 0x22, 0x74, 0xBB, 0xDF, 0xF8, 0x98, 0x6F, 0x0F, + 0x05, 0xE5, 0xE8, 0xA1, 0x68, 0x63, 0x88, 0xBB, 0x4D, 0xBD, 0xAD, 0x0B, + 0x4E, 0xD3, 0x97, 0xD7, 0xA7, 0xFE, 0x32, 0x21, 0x4A, 0x7F, 0xFE, 0xC3, + 0x4D, 0x25, 0x58, 0x4C, 0xF9, 0x3A, 0x69, 0x2E, 0x98, 0xF3, 0xF1, 0xD4, + 0xF5, 0x65, 0x21, 0xE0, 0xFF, 0xF9, 0x7F, 0xFC, 0x6F, 0xDF, 0xDD, 0xEF, + 0x09, 0x26, 0x39, 0x81, 0x51, 0x99, 0x98, 0x53, 0x08, 0x91, 0x60, 0xEC, + 0x43, 0x4E, 0x39, 0xBF, 0x1C, 0xCF, 0x4F, 0xCF, 0xE7, 0x1F, 0x7F, 0xB8, + 0x87, 0x19, 0x94, 0x85, 0xA0, 0x82, 0x13, 0x02, 0x30, 0xA6, 0xAF, 0x4F, + 0x2F, 0xA5, 0xE0, 0x00, 0x86, 0x0C, 0x01, 0x16, 0x4C, 0x7B, 0x07, 0x10, + 0xF2, 0x3E, 0x54, 0x85, 0x28, 0xEB, 0x02, 0x03, 0x58, 0x0A, 0x06, 0x21, + 0xE8, 0x7A, 0xFD, 0xE5, 0xEB, 0xD9, 0x2C, 0x76, 0xB7, 0xD9, 0x28, 0x1B, + 0x73, 0x76, 0x05, 0x4B, 0x18, 0xA2, 0xE7, 0x97, 0x11, 0x63, 0x4C, 0x49, + 0xC6, 0x18, 0x0B, 0x51, 0x9C, 0xCE, 0xC3, 0x79, 0xB2, 0x46, 0xAB, 0x90, + 0x33, 0x21, 0x6C, 0xB7, 0xD9, 0x1C, 0xB6, 0x4D, 0x74, 0x7A, 0xBD, 0xAB, + 0xB8, 0x80, 0xD3, 0x64, 0x95, 0x72, 0x14, 0x23, 0xA5, 0xCC, 0x76, 0xD7, + 0xC6, 0x04, 0x62, 0x8A, 0x7F, 0xF8, 0xE1, 0x2E, 0x65, 0xB0, 0x68, 0xC3, + 0x39, 0xBD, 0x9E, 0xC7, 0x79, 0x52, 0x42, 0xF2, 0x9C, 0xA1, 0xE0, 0xE8, + 0x7F, 0xFC, 0xEB, 0xFB, 0x0F, 0x9F, 0x5E, 0x28, 0x2F, 0x21, 0x04, 0x5A, + 0x4D, 0x94, 0x09, 0xC6, 0xC4, 0xFD, 0xDD, 0x3D, 0x42, 0x40, 0x9B, 0x59, + 0x1B, 0x15, 0x73, 0x0E, 0x21, 0x04, 0xE7, 0x41, 0x0A, 0x31, 0x84, 0x3F, + 0xFD, 0x70, 0xBF, 0x6E, 0xAA, 0x45, 0x29, 0xAD, 0x34, 0xA5, 0xB8, 0xA8, + 0x0A, 0xCA, 0x18, 0xC8, 0x40, 0x29, 0xB7, 0xD8, 0x70, 0x68, 0xAB, 0xFF, + 0xF6, 0xFF, 0xFC, 0x92, 0x00, 0x7A, 0xF7, 0xF6, 0xE6, 0xE5, 0xE9, 0xF4, + 0xE7, 0x1F, 0xDF, 0x7E, 0x79, 0x39, 0x95, 0x42, 0xEC, 0xF7, 0xEB, 0xBF, + 0xFC, 0x7C, 0xDF, 0x75, 0xD7, 0xDD, 0xBA, 0xAE, 0x0B, 0x36, 0xCE, 0x06, + 0x41, 0x3E, 0x5E, 0xCD, 0xF1, 0xD8, 0x05, 0x1F, 0x20, 0x21, 0x2F, 0xE7, + 0x4E, 0x72, 0x7E, 0xEE, 0x06, 0xC6, 0x48, 0x5D, 0xCA, 0x4B, 0x37, 0xBD, + 0x7B, 0x3C, 0xBC, 0x9C, 0x86, 0x73, 0x3F, 0x33, 0x41, 0x11, 0x84, 0xEB, + 0x55, 0xBB, 0xD9, 0xD6, 0x97, 0xEB, 0x80, 0x31, 0x46, 0x04, 0x52, 0x08, + 0x32, 0x04, 0xCE, 0x87, 0x69, 0x54, 0x18, 0x13, 0xCE, 0x28, 0xA2, 0x78, + 0xEC, 0xC7, 0x42, 0xB2, 0xA6, 0xAD, 0xBA, 0xD3, 0xD8, 0xAC, 0x1B, 0x17, + 0xE2, 0x32, 0x2F, 0x75, 0x29, 0x33, 0x04, 0x19, 0x40, 0xBD, 0x58, 0x42, + 0xA9, 0x77, 0x69, 0x9E, 0xF5, 0xAC, 0xD4, 0xDD, 0x61, 0xF3, 0xF8, 0xE6, + 0x40, 0x30, 0x76, 0xDE, 0xC9, 0x92, 0x61, 0x88, 0x42, 0x4A, 0x29, 0xC5, + 0x9C, 0x72, 0x0A, 0xF1, 0xD3, 0x97, 0xA7, 0x45, 0x39, 0x59, 0x08, 0xEF, + 0xE3, 0x38, 0xA8, 0xAA, 0x14, 0xB7, 0x87, 0xB5, 0x5A, 0x4C, 0x51, 0x70, + 0x00, 0x40, 0xF0, 0x49, 0xCA, 0x42, 0x08, 0x52, 0x57, 0xA5, 0xD6, 0xF6, + 0xFD, 0xE7, 0x97, 0xEB, 0xB0, 0x74, 0xFD, 0xB0, 0xDF, 0xB6, 0x82, 0x92, + 0x90, 0xA1, 0xF5, 0x00, 0x13, 0xE6, 0x9D, 0x2B, 0x8A, 0x32, 0xE5, 0x5C, + 0xD2, 0x64, 0xAD, 0x1F, 0xE6, 0x49, 0x0A, 0xD2, 0xAE, 0x9A, 0xE7, 0x97, + 0x1E, 0x60, 0x08, 0xA2, 0xAF, 0xCB, 0x72, 0x9C, 0x4D, 0x02, 0x30, 0xE7, + 0x44, 0x30, 0x09, 0xC1, 0x31, 0xC6, 0xB5, 0xD6, 0x94, 0xA0, 0xA6, 0x2A, + 0xB5, 0xD1, 0x84, 0xE0, 0x14, 0x63, 0xCE, 0xD9, 0xFA, 0x10, 0x33, 0x40, + 0x88, 0x33, 0xC6, 0xBD, 0x37, 0x8C, 0xA2, 0x42, 0xF2, 0x45, 0x19, 0x4A, + 0xE5, 0x34, 0x4D, 0x55, 0xC1, 0x1E, 0x0E, 0x37, 0x8C, 0x52, 0x4A, 0xD0, + 0xE9, 0x72, 0x05, 0x10, 0x72, 0x46, 0xAD, 0x73, 0x29, 0x67, 0xC1, 0x58, + 0xCE, 0x69, 0xBB, 0x2E, 0x73, 0xCA, 0x75, 0xDD, 0x68, 0x6D, 0x01, 0x04, + 0x82, 0x51, 0x42, 0x80, 0xF3, 0x7E, 0x56, 0xCB, 0xD3, 0xCB, 0x79, 0x9C, + 0x2D, 0x21, 0x68, 0xB3, 0x6B, 0xBB, 0x6E, 0xC2, 0x18, 0x71, 0x4E, 0x9D, + 0xF5, 0xDE, 0x27, 0x88, 0x68, 0x06, 0x89, 0x89, 0xBA, 0x59, 0xDF, 0xDC, + 0xDD, 0x3F, 0x0E, 0xDD, 0xB5, 0x7F, 0xF9, 0xD7, 0xC3, 0xED, 0x1D, 0x65, + 0x75, 0x05, 0x9E, 0x4C, 0xBC, 0xCE, 0x01, 0x8F, 0xD7, 0x28, 0x05, 0x69, + 0x1B, 0xD1, 0x56, 0x92, 0x73, 0xC6, 0x68, 0x91, 0x92, 0x82, 0x28, 0x97, + 0xE5, 0x8D, 0x0B, 0x13, 0x00, 0x65, 0x34, 0x21, 0x44, 0x8D, 0x91, 0x3A, + 0x0F, 0xEE, 0x74, 0xD1, 0x8F, 0x37, 0xE2, 0xA7, 0x3F, 0xFC, 0xF0, 0xE5, + 0x69, 0xFC, 0xF0, 0xF2, 0xF5, 0xE3, 0x93, 0x75, 0x36, 0x34, 0xA5, 0x90, + 0xB2, 0x2A, 0x04, 0xDD, 0x6D, 0x57, 0xC1, 0x07, 0x8C, 0xB1, 0xE4, 0xB4, + 0xAE, 0xE4, 0xE5, 0xDA, 0x2F, 0x8B, 0x32, 0xCE, 0x85, 0x08, 0x19, 0xE3, + 0x1F, 0x3F, 0x1F, 0xD7, 0xAB, 0xB6, 0x9F, 0x26, 0x21, 0xE5, 0x76, 0x55, + 0x34, 0x25, 0x99, 0xB4, 0xED, 0xC6, 0x9E, 0x61, 0x08, 0x11, 0x49, 0x19, + 0x0D, 0x93, 0xA3, 0x54, 0x2C, 0xB3, 0xA9, 0x2A, 0x71, 0x77, 0xB7, 0x8B, + 0xDE, 0x31, 0x8E, 0x2B, 0xC9, 0x09, 0xC0, 0xDD, 0x75, 0x9C, 0xE6, 0x05, + 0x12, 0x7C, 0xBE, 0x5E, 0xD6, 0xAB, 0x42, 0x72, 0xE1, 0x6C, 0xDC, 0x6E, + 0x9A, 0xBB, 0x9B, 0xDD, 0xC7, 0x8F, 0xCF, 0x98, 0xD2, 0xB6, 0x69, 0x97, + 0xC5, 0xA4, 0x18, 0xA2, 0x8F, 0x6D, 0x53, 0x63, 0x02, 0x95, 0xB6, 0x84, + 0x82, 0xF5, 0xAA, 0x64, 0x94, 0x2E, 0xDA, 0x64, 0x08, 0x38, 0x47, 0x20, + 0x67, 0x90, 0xD1, 0xA4, 0x6C, 0x5D, 0x96, 0x5A, 0x2D, 0x75, 0x59, 0xC9, + 0xAA, 0xD0, 0xD6, 0xCD, 0x4A, 0x3D, 0x3D, 0x5F, 0xDE, 0x7F, 0x78, 0x65, + 0x04, 0x15, 0x42, 0xC4, 0x84, 0x16, 0x13, 0x0E, 0xFB, 0xCD, 0xE9, 0x7C, + 0xEA, 0xC7, 0xA9, 0xAE, 0x2A, 0xCE, 0x49, 0xCE, 0x59, 0xDB, 0x00, 0x20, + 0x04, 0x20, 0x75, 0xD7, 0x81, 0x32, 0xCA, 0x19, 0x2D, 0x38, 0xF7, 0xC1, + 0xED, 0x0F, 0x2D, 0x25, 0x78, 0x99, 0x16, 0xEF, 0xA2, 0x94, 0x45, 0x0C, + 0xBE, 0xE4, 0x58, 0x19, 0x8F, 0x09, 0x29, 0x0B, 0xC1, 0x29, 0xF2, 0xCE, + 0x5E, 0x87, 0x21, 0x02, 0x28, 0x05, 0x87, 0x10, 0x46, 0x17, 0x00, 0x04, + 0x9C, 0x53, 0x26, 0xF9, 0x30, 0x2D, 0x45, 0xD1, 0xDE, 0xAE, 0x1B, 0x8C, + 0xC9, 0xB8, 0x2C, 0x35, 0x47, 0xDD, 0x68, 0xBF, 0x9E, 0x15, 0x4E, 0xEA, + 0x4F, 0xDF, 0xBF, 0x09, 0x31, 0x74, 0xE3, 0x70, 0xBC, 0x2C, 0x65, 0x21, + 0xA5, 0xE4, 0xDD, 0xB4, 0x7C, 0xF3, 0x87, 0xF1, 0xFF, 0xFE, 0x5F, 0xFE, + 0x3A, 0x4C, 0xF6, 0x3C, 0xCC, 0xBF, 0xBE, 0xFF, 0xE2, 0x42, 0xBA, 0xF4, + 0xD3, 0xCB, 0xF1, 0x9C, 0x40, 0xBE, 0x0E, 0xD3, 0xD0, 0x8F, 0xB3, 0x56, + 0xBF, 0x7F, 0xF9, 0x5A, 0xCA, 0xB2, 0x2C, 0x04, 0xA5, 0x54, 0x2D, 0xF6, + 0xDA, 0x4F, 0xDA, 0x99, 0x1C, 0x43, 0xDD, 0x36, 0xA2, 0xA8, 0x28, 0x61, + 0x4D, 0x51, 0x79, 0xED, 0x82, 0x77, 0x7A, 0x54, 0x66, 0xB2, 0x95, 0x10, + 0x1C, 0xE3, 0x60, 0xBC, 0x60, 0x1C, 0x02, 0xB4, 0x5D, 0xD5, 0x0F, 0x0F, + 0xBB, 0x76, 0x23, 0xF7, 0xFB, 0x76, 0xBF, 0x6F, 0x09, 0x23, 0xFB, 0xDB, + 0xCD, 0xFE, 0x66, 0x05, 0x41, 0xE4, 0x05, 0x59, 0x94, 0x1A, 0xA6, 0x89, + 0x20, 0xE8, 0x63, 0x26, 0x84, 0xEC, 0xD6, 0xAB, 0xFD, 0x66, 0xF3, 0x78, + 0xD7, 0x80, 0x6C, 0x19, 0x05, 0x45, 0x41, 0xC6, 0x49, 0x9F, 0xCF, 0x3D, + 0x86, 0x80, 0x12, 0x1C, 0x02, 0xAA, 0xCA, 0x52, 0x96, 0x05, 0x25, 0xEC, + 0xCB, 0x97, 0xEB, 0xE7, 0x8F, 0x67, 0xCE, 0x48, 0x8E, 0x20, 0xBA, 0x48, + 0x31, 0xE1, 0x82, 0xA5, 0x0C, 0x7E, 0xFD, 0xF5, 0xE9, 0xB0, 0x5D, 0x31, + 0x8A, 0xCE, 0xDD, 0x82, 0x10, 0x8C, 0x21, 0x84, 0x10, 0x76, 0xDB, 0x75, + 0x55, 0x17, 0xDD, 0xF8, 0xEA, 0xBD, 0xF3, 0xC1, 0xC5, 0xE0, 0xEA, 0x52, + 0x96, 0x05, 0x8F, 0xD1, 0x97, 0x92, 0xE5, 0x90, 0x53, 0x4C, 0xD3, 0xAC, + 0x9D, 0x0F, 0x00, 0x82, 0xFD, 0x6E, 0x9D, 0x52, 0x76, 0x2E, 0x0C, 0x83, + 0x72, 0xD6, 0x4A, 0xC1, 0x4F, 0xDD, 0xF4, 0xD7, 0x9F, 0xEE, 0xF7, 0xAB, + 0xBA, 0x1F, 0x15, 0x13, 0xFC, 0x76, 0x55, 0xAE, 0xEB, 0xEA, 0x76, 0x5F, + 0x23, 0x90, 0x5F, 0x5E, 0xAF, 0x7D, 0xBF, 0xBC, 0xBC, 0xAA, 0x97, 0xAF, + 0xA3, 0xD1, 0xEE, 0xB5, 0xEB, 0x27, 0x35, 0xC6, 0x0C, 0x8B, 0xB2, 0x46, + 0x28, 0x07, 0xA7, 0x52, 0x06, 0xEB, 0xBA, 0x2E, 0x0B, 0x19, 0x42, 0x74, + 0x21, 0x76, 0xB3, 0x5E, 0xB4, 0xB1, 0xCE, 0xBF, 0x7B, 0xBC, 0x1B, 0xC6, + 0x65, 0xE8, 0x07, 0xC6, 0xB0, 0xD1, 0x06, 0x13, 0x94, 0x72, 0x86, 0x00, + 0xA4, 0x94, 0x29, 0x67, 0xC3, 0x30, 0x83, 0x9C, 0x01, 0x00, 0x8C, 0x13, + 0x4A, 0xB0, 0x37, 0x9E, 0x50, 0x72, 0xB9, 0xF4, 0xC6, 0x3A, 0x88, 0x00, + 0x04, 0x20, 0x43, 0x38, 0x8D, 0x4B, 0xCA, 0x39, 0xC6, 0xE4, 0xAC, 0xAF, + 0xDB, 0xA2, 0x90, 0x64, 0xBD, 0x96, 0x39, 0x03, 0xEF, 0xD3, 0x34, 0x2A, + 0xAD, 0xAC, 0x75, 0xD6, 0xFB, 0xA0, 0x66, 0x6B, 0x8C, 0x23, 0x8C, 0x12, + 0x46, 0xB5, 0x32, 0xC3, 0xA8, 0xAE, 0xDD, 0x42, 0x28, 0x69, 0x9A, 0x0A, + 0x02, 0xA8, 0x9D, 0xC3, 0x98, 0x58, 0xEB, 0x01, 0xC0, 0x31, 0x81, 0x14, + 0xF3, 0xEB, 0xF1, 0xEA, 0x43, 0xDC, 0xAC, 0x9A, 0x42, 0xF2, 0x6B, 0x3F, + 0xE5, 0x94, 0x8D, 0x71, 0x8C, 0x49, 0xCA, 0xB8, 0xD6, 0x1A, 0x82, 0x9C, + 0x21, 0x40, 0x10, 0x30, 0x94, 0xBB, 0x61, 0xF4, 0x21, 0x28, 0xA5, 0x43, + 0xC8, 0x31, 0xE5, 0x9C, 0x62, 0x51, 0xF0, 0xA2, 0x28, 0x21, 0x11, 0x4A, + 0xCD, 0x10, 0xC2, 0x0C, 0x80, 0x35, 0x06, 0x42, 0x10, 0x53, 0xCC, 0x29, + 0x21, 0x88, 0x9D, 0xB5, 0x19, 0x66, 0x65, 0x9C, 0xD2, 0x8E, 0x52, 0x01, + 0x21, 0x01, 0x39, 0x63, 0x42, 0x11, 0x44, 0x8C, 0x7E, 0x5B, 0xE9, 0xE5, + 0x5A, 0x1B, 0x29, 0x58, 0x29, 0x25, 0xA6, 0x42, 0xC8, 0xEA, 0xF3, 0xD7, + 0x2F, 0xB3, 0x52, 0x21, 0xC6, 0x59, 0xDB, 0xEB, 0x30, 0x29, 0x6D, 0x84, + 0x90, 0xC7, 0xEB, 0x60, 0x5C, 0x48, 0x19, 0x0D, 0xE3, 0xA4, 0xB5, 0x45, + 0x18, 0x5D, 0xBB, 0x71, 0x18, 0x97, 0x6F, 0x60, 0xFA, 0xF1, 0x3A, 0x1A, + 0x1F, 0x20, 0x84, 0xCE, 0x85, 0x0C, 0xA0, 0x60, 0x94, 0x52, 0x52, 0xD6, + 0x7C, 0x9E, 0x8D, 0xB6, 0x01, 0x42, 0x50, 0xD5, 0x2B, 0xCE, 0xAB, 0xA1, + 0xBF, 0x2E, 0xC3, 0xC7, 0xC7, 0x3B, 0x81, 0x11, 0xC7, 0xF6, 0xC9, 0x86, + 0x4E, 0x7B, 0x71, 0xEA, 0xC1, 0xCB, 0x79, 0x11, 0x1C, 0x08, 0x01, 0xBF, + 0xBC, 0x5E, 0xFB, 0x71, 0x99, 0x8C, 0x7D, 0x3A, 0xBD, 0xC4, 0x9C, 0x5F, + 0xCE, 0xC7, 0x4F, 0xCF, 0x27, 0x41, 0xA9, 0x31, 0xC3, 0x38, 0x6B, 0x46, + 0x4B, 0xC1, 0xA1, 0x2C, 0x73, 0x21, 0x57, 0xD1, 0x51, 0x84, 0x5C, 0x51, + 0xE2, 0x77, 0x6F, 0x6F, 0xDF, 0x1C, 0xE4, 0xF7, 0x77, 0xEB, 0xF5, 0xBA, + 0x7D, 0x73, 0xBF, 0x95, 0x94, 0xDF, 0xEC, 0x5B, 0x0C, 0x32, 0xA7, 0x18, + 0x81, 0x1C, 0xFC, 0xC2, 0x45, 0x02, 0x30, 0x3E, 0xDE, 0xED, 0x1F, 0x1F, + 0xF6, 0x55, 0x45, 0x0F, 0xAB, 0xFA, 0xC7, 0x77, 0x77, 0xBB, 0x4D, 0xFD, + 0x78, 0xB3, 0x8D, 0x01, 0x71, 0xC1, 0x01, 0x88, 0x6A, 0x54, 0x04, 0xE1, + 0x61, 0x74, 0x82, 0xD2, 0x1C, 0x6C, 0x21, 0xF0, 0x62, 0x82, 0xD1, 0xCE, + 0x1A, 0x3B, 0x0C, 0xB3, 0x75, 0x21, 0x23, 0x08, 0x39, 0xE5, 0x05, 0x87, + 0xD9, 0xDF, 0x3D, 0x1C, 0x36, 0xDB, 0x75, 0x55, 0x17, 0x6F, 0xDF, 0xDE, + 0x96, 0x52, 0x20, 0x80, 0x64, 0x59, 0x59, 0x1B, 0x4E, 0xE7, 0x6E, 0x98, + 0x26, 0x67, 0x6C, 0xDB, 0x96, 0x31, 0xA5, 0xAE, 0x9F, 0x3F, 0x3E, 0x1D, + 0x5D, 0xF0, 0xFB, 0x4D, 0xF3, 0xE5, 0xE9, 0x05, 0x33, 0xCC, 0x28, 0x3B, + 0x5E, 0xFB, 0x61, 0x52, 0x2F, 0xA7, 0x2B, 0xA7, 0x1C, 0xE6, 0x14, 0x43, + 0xB2, 0x2E, 0x12, 0x4A, 0x8D, 0xB5, 0xB3, 0xD2, 0x45, 0x21, 0xDB, 0xB6, + 0x3A, 0x5D, 0x7A, 0x26, 0x59, 0xCA, 0x30, 0x02, 0xB4, 0xA8, 0x25, 0xE5, + 0xB8, 0x6A, 0x6B, 0x00, 0x81, 0xD2, 0x56, 0x1B, 0x97, 0x12, 0x48, 0x31, + 0x95, 0x25, 0x4F, 0x11, 0xC4, 0x18, 0x29, 0xC6, 0x84, 0x90, 0x69, 0x9A, + 0x0B, 0xC9, 0x29, 0x46, 0x3E, 0x64, 0xE3, 0xC2, 0xF9, 0x3A, 0x0D, 0xD3, + 0x92, 0x01, 0xF6, 0x21, 0xF8, 0x14, 0xC6, 0x69, 0xC9, 0x08, 0x26, 0x88, + 0x74, 0x88, 0x36, 0x26, 0x00, 0x91, 0x75, 0xCE, 0x3A, 0x8B, 0x28, 0x24, + 0x84, 0x74, 0x93, 0x32, 0x2E, 0x41, 0x04, 0x11, 0x82, 0xF3, 0xA2, 0x39, + 0x45, 0xE3, 0x30, 0x7E, 0xF8, 0x72, 0xAC, 0x0A, 0x7C, 0x77, 0xD8, 0x71, + 0x2E, 0xFF, 0xFE, 0xFE, 0x8B, 0xF6, 0x20, 0x67, 0x1C, 0x62, 0x9C, 0x94, + 0xF6, 0x3E, 0x2C, 0xDA, 0x12, 0x8C, 0xF1, 0x61, 0xB7, 0x1E, 0x46, 0xF5, + 0xFE, 0xD3, 0xD3, 0xD7, 0xD7, 0xF3, 0xAC, 0x4C, 0xC8, 0xE8, 0xF3, 0xF3, + 0x29, 0x24, 0x00, 0x20, 0x94, 0x82, 0x33, 0x46, 0x56, 0xEB, 0xA6, 0x28, + 0xE5, 0x38, 0x0D, 0xCB, 0xB2, 0x8C, 0x8B, 0x0A, 0x29, 0x32, 0x86, 0xBE, + 0xF1, 0xB0, 0x08, 0x61, 0x1F, 0x00, 0xC8, 0x84, 0x12, 0xD6, 0x54, 0xD5, + 0x76, 0xDB, 0x60, 0x84, 0x19, 0x26, 0x20, 0x26, 0x08, 0xA1, 0xD1, 0x6E, + 0x9C, 0xEC, 0x30, 0xDB, 0x71, 0x5C, 0x7C, 0x06, 0xC6, 0xBA, 0x45, 0xE9, + 0xE7, 0xCF, 0xA7, 0xF1, 0xA2, 0xAC, 0xCB, 0x21, 0x01, 0xED, 0xA3, 0x28, + 0x24, 0xA3, 0x08, 0x40, 0xF0, 0xEE, 0xCD, 0xFD, 0x5F, 0x7F, 0xFE, 0xE1, + 0xF6, 0x66, 0xCD, 0x49, 0xAA, 0x6B, 0x9E, 0x73, 0x16, 0x42, 0x20, 0x4C, + 0x56, 0x9B, 0xB6, 0x2C, 0xEA, 0x9C, 0xC1, 0xCD, 0xDD, 0x81, 0x30, 0x36, + 0x2D, 0xF6, 0xE5, 0xE5, 0x1A, 0x53, 0x3C, 0x5F, 0xC6, 0xF5, 0xBA, 0xDE, + 0xEE, 0xDA, 0xC5, 0xDA, 0x0C, 0x91, 0xB1, 0x1E, 0x22, 0xE8, 0x9D, 0x0B, + 0x31, 0xBD, 0x9E, 0x3A, 0x40, 0xF0, 0x34, 0x8C, 0x00, 0xC2, 0x0C, 0x61, + 0x53, 0x95, 0x84, 0x44, 0x17, 0xEC, 0x37, 0x6D, 0x26, 0xA5, 0x44, 0x29, + 0xFE, 0xF1, 0xDD, 0xDD, 0xD7, 0x97, 0x33, 0x45, 0x19, 0xE6, 0x8C, 0x29, + 0xDA, 0xEF, 0xDB, 0xAA, 0x96, 0xDA, 0x2C, 0x0F, 0x37, 0xBB, 0x10, 0xE2, + 0xE5, 0x7A, 0x19, 0xC7, 0x85, 0x60, 0xB4, 0x69, 0x38, 0x93, 0xEC, 0xC7, + 0x1F, 0xEE, 0x9A, 0x92, 0x0B, 0xC1, 0xD7, 0xEB, 0x6A, 0x9C, 0xFB, 0x6D, + 0x53, 0x2B, 0x13, 0x21, 0xE2, 0x7F, 0x7F, 0xFF, 0xF5, 0xC3, 0xD7, 0xF3, + 0x38, 0xA9, 0x98, 0x51, 0x37, 0xCE, 0x1F, 0x9F, 0x9E, 0x3F, 0xBD, 0x74, + 0xA3, 0xB6, 0x75, 0x5D, 0x5B, 0x6F, 0x94, 0xD1, 0xD3, 0x62, 0x18, 0xE7, + 0xD6, 0xF9, 0x79, 0x59, 0x76, 0x9B, 0xD5, 0x64, 0x1C, 0xC2, 0xB8, 0x1F, + 0xA6, 0xBB, 0xBB, 0x83, 0xD1, 0xEE, 0xF5, 0x7C, 0xDE, 0x6C, 0x1B, 0x1F, + 0x42, 0xCE, 0x29, 0x65, 0x18, 0x43, 0x36, 0xDA, 0xAC, 0xD6, 0x95, 0xD6, + 0xA6, 0x6C, 0x4A, 0x21, 0x59, 0x59, 0x17, 0x29, 0xA5, 0x14, 0x93, 0xF3, + 0x3E, 0x85, 0xE4, 0x63, 0x0A, 0x21, 0x72, 0x4E, 0x8D, 0xB6, 0x00, 0xE4, + 0x65, 0x36, 0xCE, 0x85, 0x71, 0x5C, 0x0A, 0x41, 0x1F, 0xEE, 0x57, 0x87, + 0xDB, 0xF6, 0xB0, 0x6F, 0x28, 0x86, 0x4D, 0x23, 0x8D, 0xB1, 0x21, 0x44, + 0x46, 0xC9, 0xC7, 0x4F, 0xC7, 0x18, 0x13, 0x63, 0xD4, 0x1A, 0x13, 0x42, + 0xD8, 0xEE, 0xD7, 0xCE, 0xC7, 0x94, 0xF2, 0x6E, 0xBB, 0xB6, 0xC6, 0x4D, + 0xB3, 0xC2, 0x14, 0x1B, 0xE3, 0x7C, 0x48, 0x00, 0x43, 0x6B, 0x83, 0x8F, + 0x89, 0x10, 0x92, 0x33, 0x50, 0x4A, 0x37, 0x4D, 0x21, 0x05, 0x3F, 0x5D, + 0x07, 0x84, 0x60, 0xCE, 0x49, 0xCA, 0x62, 0x5E, 0x66, 0x6B, 0x15, 0xC6, + 0xA8, 0x29, 0x28, 0xC2, 0x48, 0x19, 0xA3, 0x8D, 0x0D, 0x29, 0x69, 0x6B, + 0xBD, 0xF7, 0xD6, 0x39, 0x8A, 0x71, 0x51, 0xD6, 0xD3, 0x34, 0x3B, 0xAB, + 0x39, 0x97, 0x10, 0x02, 0x90, 0x53, 0x88, 0x11, 0x42, 0x48, 0x30, 0xF6, + 0x31, 0xE6, 0x1C, 0x33, 0x00, 0x19, 0xE2, 0xB2, 0x5A, 0xA5, 0x94, 0x21, + 0x84, 0x08, 0x61, 0xC6, 0x05, 0x21, 0xC4, 0x59, 0xEB, 0x43, 0x4A, 0x10, + 0x21, 0x04, 0x56, 0xB5, 0x4C, 0x19, 0xAF, 0xB7, 0xB7, 0xC3, 0x70, 0x2D, + 0x04, 0xBB, 0xDD, 0xAD, 0x53, 0x8A, 0x4F, 0xC7, 0x73, 0x4C, 0x29, 0xA4, + 0xD4, 0x34, 0x6B, 0xA5, 0x15, 0x00, 0x80, 0x10, 0x4C, 0x09, 0x1E, 0xA6, + 0xE5, 0xDB, 0x59, 0x2D, 0x8B, 0xC2, 0xD8, 0xE0, 0xBD, 0x5F, 0x8C, 0xCD, + 0x00, 0x40, 0x84, 0x18, 0xC1, 0x82, 0xD1, 0x79, 0x31, 0x14, 0xE3, 0x7E, + 0x50, 0x39, 0xE5, 0x14, 0x23, 0x26, 0xB8, 0x2A, 0x1B, 0x6B, 0xBC, 0xA4, + 0x79, 0xE8, 0x5F, 0x21, 0x4A, 0xDE, 0x99, 0x7E, 0x72, 0x2E, 0x96, 0x21, + 0xA1, 0x59, 0xEB, 0xE0, 0x23, 0xC6, 0xF0, 0x3C, 0xD8, 0xD3, 0xC5, 0x2B, + 0x03, 0x5E, 0x4F, 0xD3, 0xEB, 0xD9, 0x53, 0x02, 0x86, 0xC9, 0x5E, 0xBA, + 0x70, 0xEE, 0x47, 0xE3, 0xF4, 0xCB, 0x69, 0xD6, 0xDE, 0x09, 0x9A, 0x97, + 0xC5, 0x0A, 0xBE, 0xFA, 0xFA, 0x72, 0x89, 0x04, 0x5B, 0x17, 0xBD, 0x27, + 0x97, 0x6E, 0x1E, 0x86, 0x79, 0x9C, 0x96, 0x53, 0x3F, 0xC7, 0x94, 0xA3, + 0xCB, 0xD7, 0xEE, 0xF2, 0xEB, 0xC7, 0x97, 0x98, 0xE1, 0xA4, 0xD4, 0xEB, + 0x75, 0xBA, 0x3D, 0xEC, 0xC6, 0xD1, 0x7C, 0xFC, 0x7C, 0xBC, 0xDB, 0xD7, + 0x21, 0xE5, 0x6B, 0xA7, 0x39, 0x13, 0xDD, 0xE0, 0x16, 0xA5, 0x36, 0xEB, + 0x02, 0xE7, 0xFC, 0xFD, 0x9B, 0xB7, 0x87, 0xC3, 0xCD, 0x66, 0xDD, 0x6C, + 0x77, 0xED, 0x30, 0xCC, 0x2E, 0x38, 0x08, 0x53, 0x21, 0xC4, 0x38, 0x1B, + 0x00, 0x21, 0x40, 0xD8, 0x19, 0x4F, 0x39, 0x4D, 0xC1, 0x57, 0x45, 0x25, + 0x45, 0x05, 0x11, 0xE1, 0x82, 0x3B, 0x1F, 0x12, 0xC8, 0x77, 0x37, 0x1B, + 0x97, 0x12, 0x13, 0x54, 0x14, 0x5C, 0x08, 0xCE, 0x38, 0xED, 0xBB, 0xE1, + 0xD2, 0x8D, 0xA7, 0x6E, 0x08, 0xD1, 0x3F, 0xDC, 0x6D, 0xAA, 0x42, 0x9C, + 0xAF, 0x03, 0xC4, 0x70, 0x98, 0x96, 0xCB, 0x75, 0xB4, 0xCA, 0x37, 0x65, + 0xB1, 0xAA, 0xEB, 0x9C, 0x41, 0x3F, 0x2D, 0x31, 0xE5, 0xCF, 0x4F, 0xA7, + 0x41, 0xE9, 0xD3, 0x79, 0x9A, 0x95, 0x49, 0x00, 0xD4, 0x75, 0x91, 0x73, + 0x56, 0xDA, 0x14, 0xFB, 0x09, 0x8A, 0x00, 0x00, 0x20, 0x00, 0x49, 0x44, + 0x41, 0x54, 0x18, 0x67, 0x66, 0x35, 0x3B, 0xE7, 0x57, 0xAB, 0xAA, 0xAE, + 0x4B, 0xE7, 0xFC, 0xA5, 0x1B, 0x42, 0xF0, 0x00, 0x82, 0xF5, 0xBA, 0xF4, + 0x21, 0x21, 0x80, 0xCA, 0x42, 0xCC, 0x8B, 0xDA, 0x6E, 0xDB, 0x18, 0xC2, + 0xF1, 0xD8, 0xC7, 0x0C, 0x28, 0xA3, 0xA7, 0xCB, 0xB5, 0x28, 0x64, 0x4C, + 0xC1, 0x85, 0x20, 0x4A, 0xB6, 0x3B, 0x6C, 0x79, 0x21, 0x98, 0xE0, 0x37, + 0x87, 0x6D, 0x5D, 0x16, 0x65, 0x59, 0x96, 0x65, 0x49, 0x05, 0x3F, 0x5D, + 0x06, 0x42, 0xA8, 0xB1, 0x8E, 0x33, 0xAE, 0xB5, 0x31, 0xDA, 0x50, 0x84, + 0x9D, 0x8B, 0xD6, 0x04, 0x2E, 0x84, 0x60, 0x9C, 0x51, 0x76, 0xBA, 0x4E, + 0x2F, 0xA7, 0x73, 0xDB, 0x36, 0x29, 0x84, 0x94, 0x53, 0x5D, 0x0B, 0xE3, + 0x03, 0x21, 0x38, 0xC5, 0x84, 0xDB, 0xB2, 0x9E, 0x95, 0xE9, 0x26, 0x45, + 0xB9, 0xC8, 0x10, 0x66, 0x00, 0xC6, 0x69, 0x68, 0x57, 0x8D, 0x5A, 0xB4, + 0xB5, 0xD6, 0x47, 0x4F, 0x09, 0x89, 0x31, 0x5A, 0x6B, 0x11, 0xC6, 0xC6, + 0x7A, 0x98, 0xC1, 0xCD, 0xBE, 0x81, 0x08, 0x38, 0xEB, 0x01, 0xC8, 0xDD, + 0x30, 0x7E, 0xF8, 0xF2, 0xF2, 0x74, 0x7C, 0x55, 0x66, 0xBE, 0x76, 0x83, + 0xB5, 0x21, 0xF8, 0x9C, 0x00, 0x9C, 0x16, 0xF3, 0xF2, 0x32, 0x84, 0x10, + 0xA6, 0x59, 0x19, 0xED, 0x7D, 0xCA, 0xDA, 0xB8, 0x9C, 0xE0, 0x3C, 0xCD, + 0x00, 0x00, 0x6D, 0x93, 0x77, 0x81, 0x0B, 0x5A, 0x16, 0xFC, 0xF1, 0xF1, + 0xAE, 0x59, 0x6D, 0x62, 0xC8, 0x39, 0x26, 0x00, 0x72, 0x53, 0x56, 0x98, + 0x50, 0x59, 0xC8, 0x69, 0x32, 0x2E, 0x04, 0xAD, 0x74, 0x55, 0x49, 0x4C, + 0xA8, 0xF3, 0xDE, 0x07, 0xA7, 0xB4, 0x02, 0x39, 0xDD, 0x3F, 0xEC, 0x05, + 0xA7, 0x84, 0xC1, 0x6B, 0x37, 0x0C, 0xDD, 0xEC, 0xBD, 0x8F, 0x31, 0x86, + 0x10, 0x01, 0x00, 0x8C, 0x91, 0x7E, 0x9C, 0xC6, 0x41, 0x51, 0x42, 0x94, + 0x52, 0x31, 0x86, 0x77, 0x6F, 0xEE, 0x94, 0x35, 0x93, 0x52, 0x39, 0x67, + 0x08, 0x53, 0x25, 0xF1, 0x77, 0x77, 0x6B, 0xA3, 0x67, 0x4C, 0xD0, 0x5F, + 0x7F, 0xFC, 0xEE, 0xDD, 0xE3, 0x2D, 0x40, 0xA0, 0x6E, 0xCA, 0x9B, 0xC3, + 0x7A, 0xBB, 0x2E, 0xDF, 0xBE, 0x3D, 0x20, 0xC2, 0xF6, 0xFB, 0xF5, 0xFE, + 0xB0, 0xAD, 0xEB, 0xB2, 0x28, 0xC4, 0xAA, 0x29, 0xF4, 0x64, 0xE7, 0x29, + 0xFA, 0xE0, 0x43, 0xF2, 0x31, 0x44, 0x1F, 0xD3, 0xA4, 0x86, 0x6E, 0x9A, + 0x23, 0x80, 0xCE, 0x85, 0xBB, 0xBB, 0x83, 0x0F, 0xEE, 0xDC, 0xF5, 0xC3, + 0x62, 0x84, 0x14, 0x00, 0xA2, 0x9C, 0xFC, 0x30, 0x8E, 0x2E, 0x84, 0x42, + 0x16, 0x00, 0xD3, 0x7E, 0x18, 0x0F, 0xDB, 0x86, 0x32, 0xF6, 0x7A, 0xBE, + 0x96, 0x52, 0x52, 0x82, 0x37, 0xAB, 0xF6, 0xEF, 0xEF, 0x3F, 0xDD, 0x1E, + 0xB6, 0x8C, 0xD1, 0xCB, 0x79, 0xF4, 0x3E, 0x32, 0xC6, 0x32, 0xC8, 0xD6, + 0x38, 0x1F, 0x22, 0x00, 0x80, 0x60, 0x04, 0x31, 0xF4, 0xC6, 0xF8, 0x10, + 0x97, 0x59, 0xE7, 0x0C, 0xB4, 0x71, 0xDE, 0xBB, 0xDD, 0xB6, 0xC6, 0x28, + 0x4B, 0x4E, 0x60, 0x4C, 0x95, 0xA4, 0xEB, 0x9A, 0xDE, 0x6E, 0xDB, 0xBB, + 0x7D, 0x43, 0x28, 0x20, 0x14, 0x07, 0x1F, 0x31, 0xC9, 0x8C, 0x41, 0x59, + 0x32, 0x26, 0x28, 0x21, 0x78, 0xBB, 0xAD, 0xB8, 0x60, 0x10, 0xA0, 0xA2, + 0x28, 0x28, 0x25, 0x94, 0x52, 0x21, 0xB8, 0x94, 0xEC, 0xF9, 0xEB, 0x89, + 0x10, 0x9C, 0x33, 0x48, 0x29, 0xA7, 0x94, 0x33, 0x00, 0x29, 0xA7, 0x14, + 0x73, 0x08, 0x01, 0x62, 0xB8, 0x2C, 0xAA, 0xAC, 0xAA, 0x10, 0x22, 0x42, + 0x19, 0x82, 0x84, 0x40, 0xCE, 0x31, 0xD6, 0x4D, 0x6D, 0xBC, 0x63, 0x94, + 0xD6, 0x55, 0x99, 0x53, 0x82, 0x18, 0x2D, 0x5A, 0x43, 0x08, 0xDB, 0xB6, + 0x11, 0x82, 0x42, 0x04, 0x18, 0xA7, 0x9C, 0xD3, 0x71, 0x1C, 0x87, 0x71, + 0xC4, 0x18, 0x23, 0x08, 0xAC, 0x77, 0x21, 0x86, 0x94, 0x12, 0x04, 0x30, + 0xE6, 0x04, 0x21, 0x74, 0x3E, 0x38, 0x1F, 0x28, 0x15, 0x20, 0x27, 0x6B, + 0x14, 0x21, 0x4C, 0x16, 0xB5, 0x52, 0x33, 0x04, 0x29, 0x04, 0x47, 0x99, + 0xD0, 0x5A, 0x97, 0x05, 0xC5, 0x10, 0x51, 0xCA, 0x31, 0x46, 0xCB, 0x32, + 0x2F, 0xCB, 0x2C, 0x19, 0xFF, 0x7A, 0x3C, 0x87, 0x98, 0x38, 0xE3, 0x10, + 0x82, 0x18, 0xA3, 0x0F, 0x5E, 0x0A, 0x56, 0x08, 0xB6, 0x28, 0x1D, 0x62, + 0x38, 0x5E, 0x7B, 0x6B, 0xE3, 0xA2, 0x0D, 0x00, 0x80, 0x12, 0xDC, 0x0F, + 0x43, 0xBB, 0xAA, 0x63, 0x8C, 0x82, 0x73, 0x02, 0x91, 0xF1, 0x61, 0x9C, + 0x4D, 0x4C, 0x29, 0xC4, 0x9C, 0x40, 0xB6, 0xD6, 0x57, 0x55, 0xDB, 0x75, + 0x97, 0xF5, 0xF6, 0x9E, 0xD0, 0xE2, 0xF7, 0xDF, 0x3F, 0x4A, 0x2E, 0x57, + 0xEB, 0x52, 0x2D, 0x97, 0xD3, 0xB5, 0x77, 0x21, 0x53, 0x0A, 0x7D, 0xC8, + 0xCB, 0x92, 0xBC, 0x07, 0x18, 0x61, 0xEF, 0x01, 0xC1, 0xA0, 0x92, 0x84, + 0x60, 0x7A, 0xBC, 0x68, 0xA3, 0xB3, 0xF7, 0x68, 0x5C, 0x62, 0x51, 0x96, + 0x42, 0x34, 0xDA, 0xE6, 0x6E, 0xB6, 0x9F, 0x5E, 0x2F, 0x4F, 0xAF, 0xCF, + 0x31, 0x25, 0x8C, 0x99, 0x0B, 0x5E, 0x96, 0xE2, 0xDA, 0x2F, 0xB3, 0x0D, + 0xDB, 0x6D, 0xB3, 0x5E, 0x8B, 0xD7, 0xEB, 0x79, 0xB3, 0x6F, 0x17, 0xAD, + 0x7F, 0xFD, 0xF0, 0xBC, 0xDF, 0xDF, 0x72, 0x88, 0x97, 0x6F, 0x7D, 0xE1, + 0x94, 0x08, 0x25, 0x55, 0x25, 0x19, 0x95, 0xDD, 0xA4, 0x73, 0x36, 0x97, + 0xEB, 0xAB, 0x77, 0x00, 0xE0, 0xE2, 0xD3, 0xD3, 0x05, 0x64, 0x58, 0x96, + 0x42, 0x16, 0xEC, 0xF9, 0xB5, 0x2F, 0x8B, 0x02, 0xC4, 0xE4, 0x42, 0x30, + 0xDA, 0x81, 0x0C, 0xA4, 0x60, 0x14, 0xA1, 0x9C, 0x50, 0x59, 0x54, 0xC6, + 0xDA, 0x65, 0x36, 0x39, 0xC1, 0xE7, 0xAF, 0x57, 0x8C, 0xB0, 0xD1, 0xFE, + 0xD3, 0xD7, 0xEB, 0xB2, 0x18, 0x4C, 0x19, 0x15, 0x54, 0xD6, 0x85, 0xAC, + 0x24, 0xC0, 0xF0, 0xD3, 0xE7, 0xD7, 0xD5, 0xAA, 0x2C, 0x38, 0xED, 0xC7, + 0xB9, 0xEB, 0x67, 0xEF, 0xE3, 0x38, 0xEB, 0xF3, 0x75, 0x2A, 0x4A, 0xC1, + 0x28, 0x7E, 0x3E, 0x1E, 0x9F, 0x5E, 0x07, 0x6B, 0xC3, 0xD3, 0xA9, 0x9B, + 0xB5, 0x63, 0x8C, 0x85, 0x98, 0xB5, 0x75, 0x10, 0xC2, 0x18, 0x22, 0xE3, + 0xCC, 0x85, 0xA0, 0x16, 0x43, 0x28, 0x89, 0x31, 0x8D, 0xE3, 0xDC, 0x75, + 0x23, 0x80, 0x08, 0xE4, 0x8C, 0x31, 0x8E, 0x31, 0xE5, 0x98, 0x53, 0x4A, + 0x3E, 0xC4, 0x94, 0x01, 0xC8, 0x30, 0x86, 0xF8, 0xAD, 0x25, 0x1D, 0x63, + 0x8C, 0x31, 0xA6, 0xF8, 0xCD, 0x01, 0xCB, 0xED, 0xAA, 0x12, 0x82, 0x05, + 0x1F, 0x72, 0x4C, 0x6A, 0x36, 0xDD, 0x75, 0xC8, 0x20, 0x6F, 0xDB, 0x4D, + 0x2D, 0x18, 0x82, 0xA0, 0xAA, 0x8A, 0x18, 0x3C, 0xA7, 0x44, 0x6B, 0x7B, + 0xBC, 0x8C, 0x20, 0x67, 0xCE, 0xD0, 0xA8, 0xB5, 0xF7, 0x11, 0x61, 0x3C, + 0x2B, 0xBD, 0x6A, 0x8B, 0x0C, 0x81, 0xF7, 0x7E, 0xBB, 0xAA, 0x4A, 0xC9, + 0xCB, 0x4A, 0x52, 0x46, 0xAA, 0xBA, 0xD8, 0xB4, 0xAB, 0x10, 0x12, 0xBE, + 0xDD, 0xEF, 0x7D, 0x0C, 0xC6, 0x7A, 0x6D, 0x2D, 0x63, 0x0C, 0x02, 0xE0, + 0x9D, 0x33, 0xD6, 0xCE, 0xF3, 0x52, 0x96, 0x22, 0xE6, 0xA4, 0x94, 0xC5, + 0x88, 0x86, 0x10, 0xCB, 0xB2, 0x20, 0x84, 0x38, 0xEF, 0xC6, 0x59, 0x75, + 0xDD, 0x64, 0xBD, 0x33, 0xD6, 0x61, 0x0A, 0x79, 0x81, 0x7D, 0x74, 0xD7, + 0x6E, 0x20, 0x88, 0x38, 0x97, 0x4E, 0xD7, 0x69, 0xD1, 0xBE, 0x1B, 0xE6, + 0xCB, 0x30, 0xBE, 0x9E, 0x3B, 0x63, 0x1D, 0x22, 0xC4, 0xDA, 0x40, 0x28, + 0x8D, 0x29, 0xCA, 0x82, 0x07, 0x00, 0x84, 0x94, 0x87, 0x9B, 0x36, 0xC5, + 0x2C, 0x6B, 0x39, 0x4D, 0x36, 0x86, 0xA4, 0x8D, 0x7B, 0x7A, 0x3A, 0x4E, + 0x93, 0x02, 0x99, 0x18, 0x1B, 0x2E, 0xFD, 0xF0, 0xCB, 0xFB, 0xAF, 0xFD, + 0x30, 0x6B, 0x1D, 0x3E, 0x7D, 0x3A, 0x2E, 0xDA, 0x34, 0x4D, 0xA9, 0x94, + 0xF6, 0x3E, 0x5C, 0xAE, 0x7D, 0x86, 0x70, 0x98, 0xD5, 0x34, 0x2B, 0xC6, + 0xA5, 0x5A, 0x74, 0xCA, 0xD9, 0x68, 0x67, 0x8C, 0xA3, 0x8C, 0x2C, 0xB3, + 0x12, 0x05, 0x4B, 0x31, 0x75, 0xC3, 0xE4, 0xBC, 0x47, 0x08, 0x11, 0x8A, + 0xB5, 0x35, 0x84, 0x62, 0xC9, 0xE0, 0xED, 0x56, 0x3C, 0xDE, 0xD6, 0x08, + 0x3A, 0x29, 0xF0, 0x4F, 0x3F, 0x7E, 0xDF, 0x16, 0xA5, 0x2C, 0x4A, 0x51, + 0x15, 0x4C, 0x96, 0x43, 0x37, 0x6E, 0xB7, 0x35, 0xE7, 0x52, 0x08, 0x59, + 0x08, 0x09, 0x32, 0xA2, 0x8C, 0x2E, 0xD6, 0xBC, 0xBE, 0xF6, 0x8C, 0x15, + 0x43, 0xDF, 0x0F, 0x7A, 0x91, 0x3C, 0x69, 0x65, 0x65, 0x19, 0x30, 0xF1, + 0x37, 0x87, 0xFB, 0xCD, 0xA6, 0xDE, 0x6E, 0x57, 0x08, 0x21, 0x46, 0xF1, + 0xED, 0x6E, 0xE5, 0x42, 0x0A, 0x29, 0x32, 0x42, 0x16, 0x6D, 0x7C, 0x4C, + 0x9C, 0x12, 0x90, 0x41, 0x82, 0x90, 0x0B, 0x51, 0x70, 0xF6, 0xFC, 0x72, + 0x0A, 0x21, 0xCE, 0xF3, 0xB2, 0x69, 0xDB, 0x8F, 0x5F, 0x5F, 0x5C, 0x08, + 0x42, 0xC8, 0x71, 0x9C, 0x31, 0xC6, 0x6D, 0x53, 0xCD, 0xD3, 0x82, 0x29, + 0xC1, 0x14, 0x6B, 0x65, 0x62, 0x88, 0x18, 0x64, 0x6F, 0x9C, 0xF3, 0xDE, + 0xDB, 0xA0, 0x17, 0x83, 0x29, 0xAE, 0x1A, 0xB9, 0x6A, 0x64, 0x21, 0xE8, + 0x66, 0xD5, 0x4A, 0x81, 0xD7, 0x4D, 0xD9, 0x96, 0x94, 0x92, 0xB4, 0xDF, + 0xAD, 0x72, 0x4E, 0xE3, 0xB0, 0x74, 0x97, 0x31, 0x82, 0xD4, 0x5D, 0x26, + 0x6D, 0xFC, 0x38, 0x28, 0x1F, 0x02, 0x65, 0x58, 0x4A, 0x86, 0x29, 0x09, + 0x19, 0x8C, 0xC3, 0x3C, 0x8C, 0x4A, 0x29, 0x8F, 0x08, 0x29, 0xEB, 0x02, + 0x63, 0xD4, 0xAE, 0xEB, 0x94, 0xD2, 0x30, 0xCE, 0x94, 0x90, 0xE0, 0xC3, + 0x3C, 0x2F, 0x20, 0x03, 0x84, 0xE1, 0xF5, 0x3A, 0x50, 0x82, 0xAD, 0xF3, + 0x5A, 0x29, 0x63, 0x6C, 0x53, 0x17, 0xA7, 0x6E, 0xE4, 0x52, 0x66, 0x98, + 0x01, 0x48, 0x52, 0x4A, 0x4C, 0x28, 0xC2, 0xF0, 0x78, 0x3E, 0x43, 0x04, + 0xA5, 0xE4, 0x8C, 0x32, 0x21, 0x69, 0x51, 0x30, 0x42, 0x60, 0xD3, 0x54, + 0x10, 0x61, 0x67, 0x03, 0xC2, 0xD8, 0x3B, 0x17, 0x42, 0x40, 0x18, 0xA5, + 0x9C, 0x30, 0x46, 0x10, 0x81, 0xFC, 0x0D, 0xAD, 0xC2, 0x28, 0xE7, 0x94, + 0x41, 0xCA, 0x20, 0x53, 0xC6, 0x30, 0x46, 0x29, 0x58, 0xE7, 0xDD, 0xDD, + 0xDD, 0x77, 0x00, 0xA4, 0x14, 0xFD, 0xAA, 0xE2, 0xFB, 0x55, 0xB5, 0x5B, + 0x55, 0x4A, 0xA9, 0xE3, 0xE5, 0x1A, 0x53, 0x0C, 0xC1, 0x8F, 0x8B, 0x02, + 0x00, 0x62, 0x8C, 0x72, 0xCE, 0x5C, 0x14, 0x08, 0x21, 0x63, 0x6D, 0xCE, + 0x20, 0xE5, 0x84, 0x10, 0xD0, 0xD6, 0x61, 0x42, 0x16, 0x65, 0x18, 0x21, + 0x6D, 0x83, 0x62, 0x0A, 0xDE, 0xE5, 0x10, 0x03, 0xA3, 0x24, 0x84, 0x04, + 0x73, 0x0E, 0xD1, 0x59, 0x9F, 0x00, 0x00, 0xD6, 0xF9, 0x18, 0x53, 0x59, + 0xB6, 0x88, 0xF2, 0xED, 0x8A, 0x46, 0xFD, 0x9A, 0x12, 0x05, 0x19, 0x09, + 0x16, 0x63, 0xF4, 0x84, 0xC9, 0x69, 0xF1, 0xD6, 0x26, 0x63, 0x72, 0x8C, + 0x10, 0x61, 0x08, 0x51, 0x06, 0x39, 0xC7, 0x94, 0x01, 0x44, 0x5D, 0x6F, + 0xAA, 0x42, 0x70, 0x46, 0xE7, 0xC9, 0xEC, 0xB7, 0x35, 0x25, 0x04, 0x80, + 0xAC, 0xB4, 0x8D, 0x90, 0x32, 0x06, 0x31, 0x8A, 0x9C, 0x4B, 0x63, 0xB5, + 0xF3, 0xC6, 0x79, 0xDF, 0xAE, 0xDA, 0x87, 0x9B, 0xF6, 0x7C, 0x1E, 0xC6, + 0x79, 0xFA, 0xFC, 0xF5, 0x92, 0x23, 0xFA, 0xF2, 0xF5, 0x24, 0x8B, 0x3A, + 0x3A, 0x9F, 0x62, 0x82, 0x18, 0xF6, 0xFD, 0x92, 0x21, 0x0C, 0x01, 0x60, + 0x94, 0x27, 0x15, 0xA6, 0x79, 0xA4, 0x94, 0xED, 0xDB, 0x0A, 0x60, 0x3A, + 0x2B, 0xC7, 0x28, 0xA5, 0x84, 0x28, 0xAD, 0x63, 0x8C, 0x7F, 0xFC, 0xC3, + 0x1B, 0xA5, 0xEC, 0xDF, 0x7F, 0xFB, 0x92, 0x01, 0x24, 0x84, 0xDE, 0xEE, + 0x37, 0xAB, 0x75, 0x93, 0x42, 0x8C, 0x11, 0x7E, 0xFE, 0x7A, 0x7C, 0x7A, + 0xBD, 0x18, 0x1B, 0x8D, 0xB6, 0xE7, 0x4B, 0xD7, 0x8F, 0xDA, 0xDA, 0xAC, + 0x8C, 0x25, 0x0C, 0x2D, 0x8B, 0x7E, 0x3D, 0xF6, 0x2F, 0x2F, 0x3D, 0x65, + 0x9C, 0x12, 0xA4, 0x94, 0xFD, 0xC3, 0x1F, 0xDF, 0x2D, 0xD3, 0xF2, 0x72, + 0xBC, 0x5A, 0x17, 0x62, 0x4C, 0x21, 0x24, 0x48, 0x10, 0x63, 0xF4, 0xE3, + 0xE7, 0xD7, 0x7E, 0x34, 0x92, 0x0B, 0xB5, 0xA8, 0xC5, 0xB8, 0xB6, 0xAE, + 0xBD, 0x73, 0xE7, 0x6E, 0x19, 0x47, 0x43, 0x30, 0x0E, 0x21, 0x70, 0x82, + 0xB9, 0x60, 0xF3, 0xB4, 0xF8, 0x10, 0x21, 0x42, 0xF9, 0xFF, 0x4F, 0x57, + 0x29, 0x45, 0xC2, 0x30, 0xC1, 0xD8, 0xFB, 0xA8, 0xB5, 0xA5, 0x0C, 0xA7, + 0x0C, 0x95, 0xB1, 0xDA, 0x1A, 0xC1, 0xB9, 0xB1, 0xD6, 0x18, 0x67, 0x8D, + 0x6D, 0xDB, 0x42, 0x08, 0x2C, 0x39, 0x9B, 0xE6, 0x59, 0x2B, 0x37, 0x8F, + 0x6E, 0x9A, 0xF5, 0x38, 0x2D, 0xE3, 0xBC, 0x40, 0x00, 0x0A, 0x0A, 0x97, + 0xA9, 0x8B, 0x31, 0xCF, 0xB3, 0xAB, 0xAB, 0xDA, 0xB8, 0xA0, 0xAD, 0xC5, + 0x04, 0x23, 0x08, 0x27, 0x3D, 0x12, 0x8A, 0x7E, 0x78, 0xFB, 0xB6, 0xA9, + 0xAA, 0x42, 0xB2, 0xB7, 0xF7, 0x07, 0xE7, 0x52, 0x53, 0xD5, 0x65, 0x21, + 0x73, 0x0A, 0x31, 0xA6, 0x69, 0xD6, 0x00, 0xA6, 0x71, 0xD2, 0x4D, 0x53, + 0xE2, 0xFB, 0xC3, 0x76, 0x31, 0x66, 0xB5, 0xAA, 0xB4, 0x71, 0x04, 0x63, + 0x84, 0x50, 0x06, 0x79, 0x1A, 0x47, 0xC6, 0x68, 0x59, 0x14, 0x09, 0x80, + 0x71, 0x50, 0xD3, 0xA2, 0x65, 0x51, 0x3B, 0x17, 0x86, 0x61, 0xCC, 0x00, + 0xF8, 0x10, 0xBA, 0xEB, 0x68, 0xAC, 0x93, 0xA5, 0x34, 0xDE, 0x43, 0x9C, + 0x53, 0x8C, 0x5C, 0x88, 0x5A, 0x36, 0xCE, 0xA5, 0xCF, 0xAF, 0xAF, 0x19, + 0xE4, 0x94, 0x63, 0x3F, 0xCE, 0x29, 0xE5, 0x9C, 0xF3, 0xA8, 0x8C, 0x75, + 0x5E, 0x29, 0xF3, 0xE1, 0xD3, 0xD3, 0xF3, 0xD3, 0xB9, 0xA8, 0x8A, 0xE0, + 0xBC, 0x52, 0xD6, 0xDA, 0x30, 0x0E, 0x3A, 0xE7, 0x1C, 0xA3, 0xCB, 0x31, + 0xAE, 0x76, 0x6D, 0x0C, 0x99, 0x11, 0x96, 0x01, 0x48, 0x31, 0x7B, 0x1F, + 0x8B, 0x82, 0x51, 0x86, 0x5E, 0x5E, 0xCE, 0xF7, 0x0F, 0x37, 0xCE, 0xF8, + 0x9C, 0x53, 0xB3, 0xAE, 0xD7, 0xEB, 0x3A, 0x84, 0xE0, 0x43, 0xB4, 0xCE, + 0x07, 0xEF, 0xEB, 0x55, 0x75, 0x7A, 0xED, 0x9C, 0x0F, 0x39, 0x25, 0xE7, + 0x1C, 0x24, 0x38, 0xC3, 0xCC, 0x39, 0x59, 0x66, 0x57, 0x55, 0x25, 0xCC, + 0x71, 0xB5, 0x2A, 0x42, 0x48, 0x9B, 0xA6, 0x09, 0xDE, 0x11, 0x04, 0xFB, + 0x59, 0xF7, 0xA3, 0xC2, 0x98, 0xA1, 0xCC, 0xC7, 0xC1, 0x7C, 0xFC, 0x72, + 0x8E, 0x19, 0xF8, 0x10, 0xFB, 0x61, 0xD2, 0xCA, 0x3F, 0x3D, 0x5F, 0x94, + 0xD2, 0x5F, 0x3E, 0x5F, 0x17, 0x85, 0x8C, 0x57, 0xCA, 0x85, 0x65, 0x36, + 0x31, 0xF8, 0x61, 0x9E, 0x3F, 0xBF, 0x5E, 0x5D, 0x08, 0x4F, 0xC7, 0x59, + 0x69, 0x47, 0x41, 0x51, 0x0B, 0xF9, 0xCB, 0x6F, 0x9F, 0x97, 0x45, 0xE5, + 0x94, 0x21, 0x84, 0x4D, 0xC1, 0x09, 0xA5, 0x55, 0x29, 0x61, 0xF6, 0xFD, + 0x68, 0x4A, 0x29, 0x30, 0x40, 0xD7, 0x61, 0x7A, 0xF7, 0xDD, 0x9B, 0x42, + 0xD2, 0x10, 0xCC, 0x66, 0xD7, 0x70, 0x41, 0x64, 0x51, 0xEC, 0x0E, 0xEB, + 0x94, 0x7D, 0xDD, 0x14, 0xD3, 0xA4, 0x40, 0xCA, 0xE3, 0xA4, 0x00, 0xC8, + 0x10, 0xC1, 0x6F, 0x9F, 0xA4, 0xD6, 0x95, 0x2C, 0x0A, 0x3E, 0x8D, 0xCA, + 0x85, 0xE8, 0x43, 0x1A, 0xC7, 0xC5, 0x87, 0xE4, 0xAD, 0x77, 0xCE, 0x19, + 0xE3, 0x86, 0xC1, 0x62, 0x8C, 0x5F, 0xCF, 0x83, 0xF3, 0x3E, 0xC5, 0xA8, + 0x9D, 0xF7, 0x31, 0xC5, 0x08, 0x42, 0xCA, 0x80, 0x62, 0x6B, 0x5D, 0x77, + 0x5D, 0x5C, 0x48, 0xD6, 0x87, 0x61, 0x58, 0xBA, 0x6E, 0xBA, 0x9E, 0xA7, + 0x0C, 0x61, 0x30, 0x2E, 0xA6, 0x94, 0x00, 0x98, 0x95, 0x41, 0x14, 0x59, + 0xEB, 0x6F, 0x1F, 0x6E, 0x11, 0x82, 0xF5, 0xAA, 0xDE, 0xED, 0x37, 0x9B, + 0x6D, 0xDB, 0xB4, 0x35, 0x00, 0x70, 0x1C, 0x67, 0x98, 0x01, 0x17, 0xAC, + 0x92, 0xF2, 0x74, 0xED, 0x25, 0x67, 0x21, 0x44, 0x8C, 0x11, 0x40, 0xC8, + 0x27, 0x64, 0x9D, 0xA7, 0x94, 0x84, 0x10, 0x21, 0xA2, 0xCE, 0x98, 0xA6, + 0x6E, 0x73, 0xCE, 0x21, 0x84, 0x94, 0xB2, 0xB3, 0x8E, 0x52, 0x12, 0x7C, + 0x60, 0x5C, 0xF8, 0x90, 0xD5, 0xA2, 0x63, 0x8C, 0x29, 0x65, 0x00, 0x33, + 0xC6, 0x14, 0x42, 0x48, 0x08, 0x26, 0x18, 0x21, 0x04, 0x52, 0xCA, 0x52, + 0x72, 0x00, 0x72, 0xDB, 0x14, 0xA5, 0x64, 0xCB, 0xA2, 0x04, 0x23, 0x31, + 0xB8, 0x94, 0x81, 0x14, 0x32, 0xDA, 0xB9, 0x2C, 0x98, 0xA0, 0x6C, 0xBB, + 0xAE, 0x31, 0x04, 0x2F, 0xA7, 0x6E, 0x5A, 0x94, 0xE0, 0x9C, 0x50, 0xDC, + 0x0D, 0x73, 0x59, 0x14, 0x92, 0x51, 0x6D, 0xED, 0xA2, 0x96, 0x14, 0x83, + 0x36, 0x1A, 0x63, 0xBC, 0xAA, 0x2B, 0xEB, 0x9C, 0x94, 0x32, 0xE5, 0x4C, + 0x30, 0x72, 0xCE, 0x41, 0x08, 0x05, 0x63, 0xD7, 0x7E, 0x56, 0xD6, 0x53, + 0x80, 0xB4, 0xF5, 0x4D, 0x4B, 0x0F, 0x3B, 0xFE, 0x7A, 0x31, 0x10, 0x00, + 0x08, 0x80, 0x64, 0xF8, 0x87, 0xC7, 0xED, 0x6C, 0x51, 0x81, 0x07, 0x81, + 0x5E, 0xDB, 0xAA, 0x22, 0x88, 0x54, 0x32, 0x17, 0x12, 0xC7, 0xEC, 0x4F, + 0x9D, 0x41, 0x18, 0x03, 0x08, 0x11, 0x84, 0xC1, 0x27, 0x1F, 0xB2, 0x33, + 0x89, 0x33, 0x4A, 0x31, 0xF1, 0x11, 0xDF, 0xDF, 0xAD, 0x2A, 0x4E, 0xFE, + 0xF1, 0x2F, 0x7F, 0x7A, 0xB8, 0xBB, 0x79, 0xF7, 0x78, 0x7F, 0xD8, 0x6D, + 0xDA, 0xA6, 0x79, 0x7B, 0xBF, 0x7B, 0x7B, 0x7F, 0x38, 0xB4, 0x1B, 0x2E, + 0xA4, 0x36, 0xE1, 0x74, 0x1E, 0xDA, 0xAA, 0x41, 0x10, 0x7F, 0x7D, 0x7A, + 0x7D, 0x3D, 0x4D, 0xC7, 0xEB, 0xB4, 0xDF, 0xDD, 0x8C, 0xC3, 0xB4, 0x5E, + 0x55, 0x9B, 0xCD, 0x9A, 0x11, 0x52, 0x95, 0xD2, 0x87, 0x8C, 0x08, 0x9E, + 0x66, 0xDB, 0xF5, 0x0B, 0x97, 0xEC, 0x32, 0x1B, 0xAF, 0x15, 0x86, 0xFE, + 0x3A, 0x4E, 0xE7, 0x73, 0x97, 0x72, 0xF0, 0x21, 0xC5, 0xE8, 0x8C, 0xB3, + 0x18, 0x93, 0xAA, 0x92, 0x54, 0x30, 0x21, 0xC5, 0xE5, 0x3A, 0x60, 0x84, + 0xDA, 0xBA, 0xCC, 0x39, 0x2B, 0xAB, 0x5F, 0x5F, 0xCF, 0x19, 0x64, 0x6D, + 0x1C, 0xA3, 0x38, 0xF8, 0x18, 0x52, 0x2E, 0x8B, 0x72, 0x98, 0xA6, 0xB6, + 0xA9, 0xEA, 0xAA, 0x70, 0xD6, 0x0D, 0x93, 0xBA, 0xF6, 0x8A, 0x12, 0x8A, + 0x11, 0xDA, 0x6E, 0xD6, 0xCE, 0xFA, 0xA2, 0x92, 0xC3, 0x38, 0x5B, 0xAB, + 0x19, 0x43, 0xD3, 0x6C, 0xCA, 0x92, 0x53, 0x8C, 0xAD, 0xCD, 0x42, 0xCA, + 0x94, 0x82, 0xD6, 0x16, 0x00, 0xB4, 0x6D, 0x5B, 0xEB, 0xF3, 0xF1, 0xDA, + 0x39, 0xE7, 0x01, 0x00, 0x8C, 0x12, 0x82, 0x61, 0x48, 0xA9, 0x2C, 0x8B, + 0x14, 0x23, 0xC1, 0x24, 0xE7, 0x1C, 0x43, 0x62, 0x94, 0x22, 0x0C, 0x25, + 0x25, 0xAB, 0xBA, 0x38, 0xF7, 0x63, 0xCC, 0xA9, 0xA9, 0x1B, 0x63, 0xCD, + 0x3C, 0x4F, 0x8C, 0x71, 0xE7, 0xC2, 0xAC, 0x94, 0x8F, 0x51, 0x4A, 0x2A, + 0x24, 0x65, 0x38, 0x48, 0x0A, 0x86, 0x39, 0x58, 0xE3, 0x87, 0x59, 0xC7, + 0x14, 0x09, 0x41, 0x94, 0xC0, 0x55, 0x53, 0x2C, 0x4A, 0x0F, 0x93, 0xCB, + 0x09, 0xC8, 0xB2, 0x7C, 0xBD, 0x2E, 0xCE, 0xE7, 0xF5, 0xA6, 0xD1, 0xDA, + 0xCD, 0xCA, 0xDC, 0x6C, 0x36, 0x3F, 0xFF, 0xF0, 0x27, 0x8C, 0x0A, 0x21, + 0x24, 0xA5, 0x0C, 0x23, 0x26, 0x44, 0x55, 0x88, 0x92, 0x73, 0x9E, 0x32, + 0xB8, 0xBD, 0xDD, 0x59, 0x17, 0xC7, 0x71, 0x5A, 0x8C, 0x35, 0x2E, 0xE0, + 0x52, 0x0A, 0xEB, 0x82, 0xF7, 0xBE, 0x2C, 0xE5, 0xA2, 0xCC, 0xA5, 0xEB, + 0xA6, 0x69, 0xC8, 0x10, 0x16, 0xB2, 0x1A, 0xA6, 0xD1, 0x5B, 0x3F, 0xCE, + 0x93, 0x90, 0x0C, 0x61, 0x32, 0x4C, 0x43, 0x88, 0x3E, 0x82, 0x44, 0x29, + 0xC9, 0x09, 0xB4, 0x4D, 0x19, 0x63, 0x38, 0x9D, 0x7A, 0x6B, 0x5D, 0x4A, + 0x09, 0x02, 0xBC, 0xA8, 0x48, 0x09, 0x5D, 0xAD, 0x6B, 0xE3, 0xBC, 0xCF, + 0xD9, 0x79, 0x3F, 0x4D, 0x0B, 0x26, 0xDC, 0x58, 0xAD, 0x94, 0x31, 0xDA, + 0x2A, 0xA5, 0x43, 0xCA, 0xDE, 0xC5, 0xD3, 0xA9, 0x5B, 0x94, 0x4D, 0x31, + 0x85, 0x10, 0x52, 0x8A, 0xD6, 0x58, 0x63, 0xC3, 0xB2, 0x98, 0xE0, 0x43, + 0x3F, 0xCE, 0x55, 0x5D, 0x61, 0x88, 0xB6, 0x9B, 0x7A, 0xB7, 0xAE, 0xDF, + 0xBD, 0xDD, 0x5A, 0xED, 0x2E, 0xC3, 0x74, 0xB9, 0xF6, 0xD3, 0xAC, 0x10, + 0xC2, 0x4A, 0x59, 0x80, 0xA0, 0x56, 0x9A, 0x09, 0xEE, 0x5D, 0x38, 0x9F, + 0xFB, 0x94, 0x93, 0xD1, 0x26, 0x04, 0xB7, 0xDD, 0xDD, 0x10, 0x26, 0x41, + 0x74, 0x37, 0x87, 0xED, 0x3F, 0xFC, 0xE9, 0xFB, 0xA6, 0xAE, 0x0F, 0xB7, + 0xEB, 0xB7, 0x6F, 0x6E, 0xA3, 0x87, 0x10, 0x30, 0xA5, 0xFC, 0x34, 0xDB, + 0x61, 0xD2, 0x8B, 0x4A, 0xCF, 0xC7, 0x69, 0x99, 0xE3, 0x6E, 0xD5, 0xCE, + 0xCE, 0x4F, 0xB3, 0xA1, 0x8C, 0xEE, 0x6F, 0x76, 0x9F, 0xBF, 0x5C, 0xFA, + 0x69, 0xC6, 0x14, 0x8E, 0x2A, 0x68, 0x93, 0xAC, 0xD3, 0x00, 0x62, 0x18, + 0x53, 0x21, 0xD8, 0x4B, 0xB7, 0x58, 0x1B, 0x32, 0x20, 0x31, 0x82, 0x0C, + 0xE8, 0x6E, 0x55, 0x75, 0x57, 0xF5, 0x7A, 0x1E, 0x0F, 0x9B, 0x56, 0xCF, + 0x33, 0xA3, 0x59, 0x19, 0xEF, 0x9C, 0xCF, 0x29, 0x5A, 0x9F, 0xBD, 0x8F, + 0x29, 0x26, 0x00, 0x41, 0x55, 0x88, 0x87, 0xFB, 0xCD, 0xCD, 0x4D, 0xBD, + 0xBF, 0x6B, 0x9B, 0x4D, 0xF3, 0xE6, 0xBB, 0x87, 0xED, 0x61, 0x2D, 0x4B, + 0xF1, 0xF6, 0xF1, 0xE6, 0xE6, 0x66, 0x7B, 0x73, 0xBB, 0xBA, 0xBB, 0x5B, + 0x13, 0x8C, 0xBC, 0x0B, 0x4A, 0x99, 0xED, 0xA6, 0xBC, 0xDF, 0x6F, 0xA6, + 0x79, 0x99, 0x17, 0x37, 0x2D, 0x1A, 0x42, 0xE0, 0x7C, 0x34, 0x26, 0xC4, + 0x10, 0x09, 0xC1, 0x31, 0x26, 0xCE, 0x29, 0x61, 0x14, 0x61, 0x78, 0xBE, + 0xF4, 0x97, 0xEB, 0xAC, 0x8D, 0x83, 0x08, 0xCD, 0xCA, 0x3F, 0x9F, 0xFA, + 0x61, 0xD2, 0x5A, 0xB9, 0xF3, 0x79, 0x5E, 0x94, 0x45, 0x18, 0xC5, 0x94, + 0xF4, 0x62, 0x21, 0x44, 0x3E, 0xA4, 0x9C, 0x22, 0x21, 0x38, 0xFA, 0x14, + 0x7C, 0xA0, 0x9C, 0x84, 0x10, 0x43, 0x4C, 0xC3, 0x30, 0x41, 0x88, 0x30, + 0x21, 0xFD, 0x30, 0x82, 0x0C, 0x39, 0xA7, 0x87, 0x9B, 0x1D, 0xA5, 0xB8, + 0xEB, 0x47, 0x4E, 0x48, 0xCA, 0xC9, 0x87, 0x88, 0x10, 0x0C, 0x31, 0x02, + 0x00, 0x64, 0xC1, 0xA7, 0x45, 0x87, 0x10, 0x8D, 0xB1, 0x29, 0x01, 0x67, + 0xBD, 0x60, 0x5C, 0xF0, 0xB2, 0x1F, 0xFA, 0x7E, 0x18, 0x63, 0xCC, 0x10, + 0x82, 0x94, 0x30, 0xA5, 0x4C, 0xF0, 0xE2, 0xEB, 0xD7, 0xE7, 0x10, 0x02, + 0x67, 0x2C, 0xE5, 0x8C, 0x10, 0x86, 0x10, 0x10, 0x4C, 0xBC, 0xF7, 0x00, + 0x00, 0x42, 0x48, 0x4C, 0x19, 0x21, 0x08, 0x00, 0xD8, 0x6E, 0xEA, 0xBA, + 0x12, 0xA5, 0xA0, 0xCE, 0x85, 0x92, 0x73, 0x82, 0x31, 0x01, 0xC1, 0x7B, + 0x13, 0x42, 0xD2, 0x1E, 0x14, 0x52, 0x1A, 0xE7, 0xFB, 0x49, 0x3D, 0xDC, + 0xEE, 0xBD, 0x0F, 0x04, 0xE3, 0xDD, 0x6E, 0xD5, 0x36, 0x55, 0x8A, 0x31, + 0x86, 0x88, 0x11, 0x4A, 0x29, 0x41, 0x08, 0x73, 0x06, 0xF1, 0xDB, 0x26, + 0x44, 0x4E, 0xF3, 0xB2, 0x50, 0x82, 0x62, 0x0C, 0xD6, 0x05, 0x0C, 0xC9, + 0x69, 0x98, 0x00, 0x00, 0xAB, 0x5A, 0x50, 0x82, 0x01, 0x89, 0x55, 0x49, + 0xAD, 0xC9, 0x8C, 0x22, 0x63, 0xD3, 0x8F, 0x6F, 0xF7, 0x37, 0x87, 0xFD, + 0x32, 0x5F, 0x09, 0x58, 0xFE, 0xF8, 0xEE, 0x4F, 0x45, 0xB5, 0xDA, 0xAD, + 0x2A, 0x4A, 0x79, 0x46, 0xD8, 0x7A, 0xB4, 0x5B, 0xB7, 0xEB, 0x8A, 0x13, + 0x9C, 0xAF, 0x57, 0x03, 0x00, 0xA0, 0x94, 0xB4, 0x8D, 0x58, 0xD7, 0xAC, + 0xAE, 0xE5, 0x6E, 0x53, 0xED, 0xDB, 0xF2, 0xFB, 0xC7, 0x37, 0xEB, 0xF5, + 0x1A, 0x21, 0x60, 0x8D, 0x85, 0x00, 0xE8, 0xD1, 0x30, 0x4A, 0x73, 0x4E, + 0x8C, 0xD5, 0xAB, 0x76, 0xDD, 0xB6, 0x75, 0x59, 0x16, 0xB7, 0xFB, 0xFD, + 0x38, 0xF4, 0x82, 0x72, 0x4C, 0x88, 0x94, 0x75, 0x3F, 0x0C, 0x08, 0x66, + 0xC1, 0xD9, 0x64, 0xE6, 0x94, 0x03, 0x63, 0x66, 0x9A, 0x43, 0x0C, 0x71, + 0xDD, 0x96, 0x05, 0x27, 0x11, 0xE4, 0xE0, 0x5C, 0x21, 0x28, 0x23, 0xD9, + 0xF8, 0xC4, 0x99, 0x34, 0xCA, 0xFA, 0x10, 0x10, 0x86, 0x08, 0xE3, 0xF5, + 0xAA, 0xFD, 0xF5, 0xFD, 0xF3, 0x38, 0x2D, 0xFB, 0x7D, 0x5B, 0x48, 0x59, + 0x0A, 0xD6, 0x36, 0xC5, 0xF5, 0x72, 0x89, 0xD1, 0xBD, 0x7B, 0x3C, 0xFC, + 0xF4, 0xFD, 0x9B, 0x79, 0x5E, 0xDE, 0xDC, 0xEF, 0x87, 0x71, 0x06, 0x10, + 0xFE, 0xF0, 0xDD, 0xE3, 0x2F, 0xEF, 0x3F, 0xFA, 0x10, 0x52, 0x4A, 0x10, + 0x91, 0xA6, 0x5D, 0x2F, 0x6A, 0xF2, 0xD1, 0x95, 0x75, 0x09, 0x21, 0xBC, + 0x5E, 0x87, 0xA2, 0x10, 0x52, 0x92, 0x9B, 0x9B, 0xCD, 0xE1, 0x66, 0xBF, + 0x5A, 0x37, 0x6D, 0x5B, 0x8A, 0x42, 0x18, 0xEB, 0x11, 0xCA, 0xE3, 0x38, + 0x75, 0xC3, 0xB2, 0x5D, 0xD5, 0x9C, 0x93, 0xCB, 0xB8, 0x0C, 0xB3, 0xB2, + 0x56, 0x13, 0x4C, 0x39, 0xA5, 0x10, 0x24, 0xC6, 0x05, 0xCC, 0x89, 0x62, + 0x72, 0xB9, 0x8E, 0x8B, 0x36, 0x75, 0x59, 0x16, 0x42, 0x80, 0x14, 0x6F, + 0xD6, 0xD5, 0x75, 0x50, 0x00, 0x42, 0x63, 0x2D, 0xC6, 0xD4, 0x39, 0xFB, + 0x6D, 0x9D, 0x9E, 0x60, 0x08, 0x20, 0x20, 0x08, 0x73, 0x41, 0xC6, 0xC5, + 0x2C, 0x8B, 0xF5, 0xDE, 0xC7, 0x04, 0x31, 0x84, 0x31, 0x65, 0x42, 0x18, + 0x41, 0x50, 0x72, 0x5A, 0x95, 0x85, 0xB5, 0x3E, 0x24, 0x34, 0xCE, 0x66, + 0xD1, 0x66, 0x54, 0xC6, 0xDA, 0x28, 0xB9, 0x30, 0x46, 0x79, 0x9F, 0x7F, + 0x7A, 0xFB, 0x96, 0x20, 0x3A, 0x2B, 0x73, 0xE9, 0x26, 0xE7, 0xC3, 0xB9, + 0x1B, 0x7E, 0xFB, 0xFC, 0x72, 0x19, 0x96, 0x4B, 0x3F, 0x64, 0x04, 0x39, + 0x17, 0x95, 0xAC, 0x10, 0x46, 0xB3, 0x32, 0x8B, 0x76, 0xB0, 0x2E, 0xEB, + 0xBA, 0x12, 0x8C, 0x91, 0x9C, 0xD1, 0xB4, 0xD8, 0x65, 0x51, 0x45, 0x21, + 0xAC, 0x33, 0x00, 0x20, 0xC6, 0x88, 0xE4, 0xEC, 0xF5, 0x78, 0x6E, 0xDA, + 0xBA, 0xA9, 0x2B, 0xC6, 0xD0, 0x38, 0x4E, 0x08, 0x21, 0x84, 0x71, 0x8A, + 0xD0, 0x3B, 0xDF, 0xAE, 0x0A, 0x00, 0x40, 0x4C, 0x81, 0x33, 0xC6, 0x18, + 0x0B, 0x3E, 0xE9, 0x59, 0x11, 0xC1, 0x30, 0x63, 0x29, 0x26, 0xA5, 0xD4, + 0xE5, 0xDC, 0xAF, 0x57, 0xFB, 0x79, 0x9E, 0xAC, 0x33, 0x37, 0xFB, 0xB5, + 0x14, 0x12, 0x62, 0x7C, 0x3E, 0x77, 0xD7, 0xEE, 0x8A, 0x31, 0xB9, 0xBF, + 0xD9, 0xE7, 0x94, 0xAA, 0x5A, 0x10, 0x42, 0x40, 0xC4, 0xBB, 0xDD, 0xEA, + 0x7A, 0xBD, 0x3A, 0x17, 0x20, 0xA1, 0x8C, 0x90, 0xA6, 0x16, 0xF0, 0xDB, + 0x70, 0x5D, 0xB4, 0xFF, 0xFD, 0x6F, 0xBF, 0xD4, 0x4D, 0xC5, 0x08, 0xD3, + 0xCA, 0x61, 0x82, 0x9A, 0xB6, 0x8C, 0x31, 0xA4, 0x98, 0xA7, 0x59, 0xF7, + 0xC3, 0x74, 0xD8, 0x35, 0x8C, 0x92, 0xAE, 0x9B, 0x6E, 0x1E, 0x7E, 0xF8, + 0xE7, 0x7F, 0xFA, 0xD3, 0xDD, 0x86, 0xFC, 0xCB, 0xBF, 0xFD, 0x7B, 0x21, + 0x4B, 0xE7, 0x20, 0xC6, 0x8E, 0x12, 0x04, 0x32, 0x9E, 0x16, 0xBB, 0xCC, + 0x7A, 0x53, 0x4A, 0x88, 0xF1, 0xFF, 0xF5, 0x2F, 0x7F, 0x53, 0xC6, 0x4A, + 0x46, 0x7E, 0xFE, 0xFE, 0xFE, 0xEB, 0x45, 0xAD, 0xDA, 0x8A, 0x92, 0x2C, + 0x0B, 0xA1, 0x94, 0xBE, 0xBF, 0xDF, 0x65, 0x10, 0x52, 0x16, 0xF3, 0x34, + 0xFC, 0xFE, 0xFB, 0xE7, 0x9C, 0xD1, 0xB6, 0x95, 0x29, 0xE7, 0xCF, 0xAF, + 0x5D, 0x0C, 0x29, 0xC6, 0x20, 0x38, 0x26, 0x98, 0xAC, 0x9B, 0x02, 0x03, + 0x48, 0x45, 0xD1, 0xD6, 0xF4, 0x72, 0x3E, 0x6D, 0xD6, 0xAD, 0xB6, 0xA9, + 0x1F, 0xA7, 0x3F, 0xFD, 0xF8, 0xF8, 0x70, 0xBF, 0x1B, 0xE7, 0xC5, 0xF9, + 0x58, 0xB7, 0x75, 0xD7, 0xF5, 0x85, 0x2C, 0x10, 0x00, 0x97, 0x7E, 0x98, + 0x67, 0x0B, 0x31, 0xCE, 0x00, 0x62, 0x4C, 0xAC, 0x31, 0x94, 0x90, 0xB2, + 0xAE, 0x60, 0xF2, 0x6D, 0x53, 0x5A, 0x1F, 0x57, 0x05, 0xDF, 0xB5, 0xD5, + 0xBF, 0xFD, 0xFB, 0x07, 0xC0, 0xF0, 0x6F, 0x1F, 0x5E, 0x43, 0xF0, 0x43, + 0xAF, 0x28, 0x86, 0x5C, 0xD0, 0x10, 0xD2, 0x6E, 0x57, 0x53, 0xCE, 0xA6, + 0x51, 0x7B, 0x17, 0x9C, 0x0B, 0x94, 0x62, 0xC6, 0x88, 0xD5, 0xB6, 0x90, + 0x62, 0x5A, 0x0C, 0x25, 0x48, 0x6B, 0x1B, 0x12, 0x28, 0x0B, 0x91, 0x01, + 0x80, 0x20, 0x8B, 0x82, 0x33, 0x41, 0x01, 0x84, 0x39, 0x65, 0x4A, 0x30, + 0x46, 0x18, 0x20, 0x64, 0xAD, 0xCF, 0x19, 0x58, 0xEB, 0x01, 0xC6, 0xCE, + 0xF9, 0xA2, 0x90, 0x18, 0x23, 0xAD, 0x2D, 0x04, 0x00, 0x21, 0x04, 0x53, + 0x6C, 0x9B, 0x22, 0xC4, 0x34, 0xF7, 0x53, 0x37, 0xCC, 0xC6, 0xA5, 0x10, + 0x93, 0x64, 0x64, 0xD3, 0x56, 0xDA, 0xB9, 0x4B, 0x3F, 0x23, 0x8C, 0x41, + 0x4E, 0x9C, 0x51, 0x84, 0xF0, 0x7F, 0xFD, 0xCF, 0x3F, 0x77, 0x43, 0xA7, + 0xCC, 0xD2, 0x75, 0x66, 0x5C, 0xDC, 0xA2, 0x74, 0xCE, 0xB1, 0x2A, 0x4A, + 0xC2, 0x58, 0xF0, 0xB6, 0x14, 0xCC, 0x87, 0xE4, 0x63, 0x8A, 0x31, 0x84, + 0x10, 0x01, 0x84, 0x39, 0x03, 0x8C, 0x60, 0xCC, 0x19, 0x64, 0x80, 0x50, + 0x86, 0x10, 0x51, 0x82, 0xF6, 0xFB, 0x66, 0xDF, 0x4A, 0x63, 0x73, 0x5D, + 0x54, 0x2E, 0xE4, 0x65, 0xE8, 0x10, 0x46, 0xB3, 0xC3, 0xB3, 0x0E, 0xFB, + 0x4D, 0x9D, 0xA2, 0x4B, 0x21, 0x14, 0x85, 0x78, 0xFF, 0xF9, 0x49, 0x0A, + 0xB9, 0x5B, 0x37, 0xFD, 0x38, 0x0D, 0xC3, 0x88, 0x31, 0x46, 0x08, 0x3A, + 0xEF, 0x21, 0x84, 0xC6, 0x85, 0x4A, 0xCA, 0xBB, 0xC3, 0x5E, 0x0A, 0x81, + 0x10, 0x86, 0x00, 0x22, 0x0C, 0x72, 0xB2, 0xCE, 0x8E, 0x9F, 0x8E, 0xE3, + 0x3C, 0xDB, 0x7F, 0xFE, 0xF9, 0x91, 0x60, 0x8B, 0x49, 0xC4, 0xD8, 0x9B, + 0x94, 0x5F, 0x4E, 0x3E, 0x46, 0x7C, 0x7F, 0xD8, 0x56, 0x3C, 0xDF, 0xAC, + 0x6F, 0xAC, 0x4B, 0x52, 0xC8, 0xE3, 0xE5, 0x92, 0x72, 0xE4, 0xA2, 0xC8, + 0x08, 0x52, 0x4E, 0x09, 0x81, 0x98, 0x90, 0x14, 0xD3, 0xE9, 0xDC, 0xA5, + 0x9C, 0x29, 0x23, 0x20, 0x01, 0x6F, 0x16, 0xCE, 0x38, 0xCA, 0x01, 0x00, + 0xB0, 0xD9, 0xDD, 0x1E, 0x2F, 0x97, 0x79, 0x9E, 0x63, 0x86, 0x6D, 0x2B, + 0x9B, 0xA2, 0xB8, 0x5E, 0xF4, 0xDD, 0xE3, 0x21, 0x86, 0x18, 0x53, 0x4A, + 0x29, 0xD5, 0x75, 0x2D, 0x24, 0x1F, 0x2E, 0x57, 0x3D, 0x4D, 0x83, 0xC9, + 0x19, 0xD2, 0x8F, 0x9F, 0x3F, 0x1F, 0xD6, 0xB2, 0xAA, 0x8B, 0xA7, 0xD3, + 0x85, 0x90, 0xFC, 0xF4, 0x34, 0x3D, 0xDC, 0xDC, 0x10, 0x18, 0x04, 0x83, + 0x8C, 0xB3, 0xD9, 0x00, 0x86, 0x42, 0x4A, 0x61, 0x52, 0xAA, 0x28, 0xDA, + 0xA1, 0x37, 0x9C, 0xB3, 0x9B, 0xC3, 0x56, 0x6B, 0x93, 0x52, 0xD2, 0x2E, + 0xBE, 0x9E, 0xE7, 0xC3, 0xAE, 0xE1, 0x04, 0x70, 0xC1, 0x8E, 0xE7, 0x81, + 0x12, 0x52, 0x70, 0xC6, 0x38, 0x66, 0x18, 0xA7, 0x94, 0xF7, 0xFB, 0x03, + 0x41, 0x68, 0x9C, 0xB4, 0x8F, 0x09, 0x24, 0x8F, 0x29, 0xCA, 0x00, 0xFC, + 0xF2, 0xFB, 0x57, 0xCE, 0xCB, 0x71, 0x59, 0x2E, 0xD7, 0xCB, 0x6A, 0x55, + 0xBD, 0x7B, 0xF7, 0xC6, 0x6A, 0x3B, 0x4D, 0xEA, 0xCD, 0xDD, 0xAE, 0x2E, + 0x79, 0x55, 0xC9, 0x18, 0x5D, 0x88, 0x5E, 0x94, 0x55, 0xCA, 0x28, 0x38, + 0x1F, 0x53, 0xEC, 0xBB, 0xEB, 0xE5, 0x75, 0xCC, 0x20, 0xF6, 0x93, 0x5A, + 0xD5, 0x1B, 0x4C, 0xBE, 0xA1, 0x69, 0x14, 0xE4, 0xF8, 0xDD, 0xE3, 0x0D, + 0x2B, 0x85, 0x1A, 0x4C, 0x37, 0xCE, 0x4F, 0xCF, 0xD7, 0x61, 0x9C, 0x77, + 0xEB, 0x76, 0x98, 0x97, 0xBB, 0xDD, 0x1A, 0xE4, 0x1C, 0x52, 0xDE, 0x6D, + 0x56, 0xFF, 0xF2, 0xB7, 0x5F, 0x72, 0x86, 0xD6, 0x19, 0xC6, 0x78, 0x2D, + 0x45, 0x4A, 0x39, 0xA6, 0x98, 0x72, 0x8E, 0xC9, 0x71, 0x46, 0x2B, 0x21, + 0x72, 0x4E, 0xCA, 0x04, 0x00, 0x60, 0x53, 0xD5, 0x85, 0x14, 0x5A, 0xCF, + 0x19, 0x78, 0x0C, 0xB1, 0x52, 0xAE, 0x69, 0x0A, 0x65, 0x9D, 0xB6, 0x51, + 0x16, 0xC5, 0xB5, 0x5F, 0xCA, 0x42, 0x52, 0x9C, 0x09, 0x44, 0x77, 0xDB, + 0x4D, 0xCE, 0x59, 0xC8, 0x72, 0x18, 0x27, 0xCA, 0x88, 0x32, 0xCE, 0xF8, + 0x14, 0x62, 0x04, 0x20, 0x72, 0x46, 0x24, 0x17, 0x82, 0xF3, 0xCD, 0xAA, + 0x3A, 0x5D, 0x4E, 0xBF, 0x7D, 0x7A, 0x82, 0x77, 0x37, 0x07, 0xC9, 0x59, + 0x8C, 0x61, 0x56, 0xC6, 0x47, 0xE4, 0x9D, 0x5B, 0xAF, 0xAB, 0x6F, 0xBA, + 0x16, 0xA5, 0x74, 0x18, 0x27, 0x63, 0x2C, 0x17, 0xA2, 0x94, 0x05, 0xA3, + 0x40, 0x29, 0x9D, 0x21, 0x52, 0x8B, 0xF9, 0x7F, 0x59, 0x7A, 0x8F, 0x25, + 0xCB, 0xB2, 0xEC, 0x4C, 0x6F, 0xEB, 0xBD, 0x8F, 0x3E, 0xE7, 0x4A, 0x77, + 0x0F, 0xE1, 0x21, 0x32, 0xB3, 0x2A, 0x4B, 0xA0, 0x0A, 0x20, 0x80, 0x26, + 0x8D, 0x34, 0xA3, 0xF5, 0x94, 0xC3, 0x1E, 0x70, 0xC6, 0x07, 0xE0, 0x43, + 0xD2, 0x38, 0xE1, 0x80, 0x66, 0xB4, 0x46, 0xA3, 0x40, 0xA0, 0x80, 0x94, + 0x11, 0x19, 0x11, 0x2E, 0xAF, 0x3A, 0x72, 0x6B, 0xC1, 0x41, 0xF2, 0x29, + 0xD6, 0xB2, 0x5F, 0x7C, 0x3F, 0xC2, 0xD8, 0x79, 0x5F, 0xE4, 0x19, 0x82, + 0x30, 0xCB, 0x99, 0xB7, 0xAE, 0x2A, 0x73, 0xA3, 0xED, 0xA2, 0xB4, 0x10, + 0x0C, 0x40, 0x88, 0x31, 0x9E, 0xA6, 0x85, 0x51, 0x66, 0x7D, 0x34, 0xC6, + 0x8B, 0x4C, 0x54, 0x85, 0x40, 0x00, 0x03, 0x00, 0x21, 0x00, 0x8C, 0x41, + 0xC6, 0xB0, 0xF5, 0x60, 0x9C, 0x97, 0xA2, 0xE4, 0xFF, 0xE9, 0x0F, 0x5F, + 0x43, 0x48, 0x3E, 0xDE, 0x1F, 0x7E, 0xFA, 0xF0, 0xB9, 0xAA, 0x8B, 0x32, + 0xE3, 0x8B, 0xB4, 0xC3, 0x24, 0x73, 0x2E, 0x6E, 0x6E, 0xD6, 0x10, 0x86, + 0x61, 0x9A, 0xA5, 0xD2, 0x10, 0xE2, 0xAC, 0xC8, 0x30, 0x22, 0xE7, 0xC3, + 0x89, 0x10, 0x1C, 0x63, 0x04, 0x00, 0xD4, 0x75, 0x3E, 0x8C, 0xA3, 0xD2, + 0x06, 0x44, 0xF0, 0x0F, 0x7F, 0xFA, 0xD3, 0xBB, 0x3F, 0xFC, 0xC3, 0xBF, + 0xFC, 0xD7, 0xFF, 0xE3, 0xDC, 0x1F, 0xB2, 0x62, 0x93, 0x82, 0x11, 0x14, + 0x02, 0x00, 0x10, 0x82, 0x3E, 0xA6, 0x32, 0x2F, 0x1A, 0xC1, 0x2F, 0xCA, + 0x3E, 0x9E, 0x96, 0xBE, 0x9F, 0x9D, 0x1C, 0xAC, 0xB1, 0xDD, 0xF6, 0xC5, + 0xEB, 0x17, 0xDB, 0xE0, 0x35, 0xE3, 0x02, 0x82, 0x84, 0x09, 0x12, 0x82, + 0x41, 0x52, 0xC1, 0xD4, 0xFF, 0xFC, 0xE1, 0xDE, 0xF9, 0x18, 0xBC, 0xEB, + 0xFB, 0xE9, 0xD4, 0xCF, 0x31, 0xC2, 0x52, 0x90, 0xF5, 0xA6, 0xF6, 0x1E, + 0x58, 0xA5, 0x6F, 0x6F, 0xD6, 0x65, 0x55, 0x7E, 0xB8, 0x7F, 0x5A, 0x55, + 0xA2, 0x2C, 0x0B, 0x6B, 0xDC, 0x7A, 0xD5, 0xBE, 0x79, 0xB3, 0x9D, 0x67, + 0x89, 0x29, 0x8E, 0x00, 0x00, 0x88, 0x01, 0x82, 0x63, 0xBF, 0x40, 0x04, + 0x2F, 0xE3, 0xF2, 0xF9, 0xF3, 0x31, 0x45, 0xF0, 0xEB, 0x36, 0x2A, 0xC2, + 0x08, 0x01, 0x90, 0x09, 0xE1, 0xB4, 0x2C, 0x72, 0x5E, 0x94, 0xD5, 0x6E, + 0xDD, 0x22, 0x00, 0x5C, 0xF0, 0x59, 0x2E, 0xC6, 0x69, 0xC1, 0x20, 0xA5, + 0x90, 0x20, 0x4A, 0xC6, 0xD8, 0xB2, 0xCA, 0xEA, 0xAE, 0xBD, 0x5C, 0x86, + 0xA7, 0xA7, 0x8B, 0xF3, 0xDE, 0x3B, 0x0F, 0x21, 0xF6, 0xDE, 0x2A, 0x65, + 0xFA, 0x41, 0x4B, 0x65, 0x32, 0x41, 0x04, 0xE7, 0x00, 0xA0, 0xBA, 0xC9, + 0x05, 0x23, 0x31, 0xFA, 0x2C, 0xE3, 0x79, 0x91, 0x01, 0x90, 0x22, 0x00, + 0x97, 0x7E, 0x0E, 0x2E, 0x26, 0x04, 0x8D, 0x73, 0x72, 0xB1, 0x10, 0x00, + 0x4C, 0xA9, 0x75, 0x1E, 0x83, 0xE4, 0x7C, 0x74, 0xCE, 0x13, 0xC6, 0x40, + 0x4A, 0x0C, 0xC3, 0xAB, 0xAB, 0x15, 0xA1, 0x64, 0xD5, 0x35, 0x1F, 0x7E, + 0xFA, 0x72, 0xEE, 0x17, 0x08, 0x61, 0xC6, 0x28, 0x82, 0x89, 0x30, 0xB6, + 0x5A, 0x57, 0x18, 0xA3, 0xF5, 0xAA, 0x4A, 0x29, 0x20, 0x98, 0xD6, 0xEB, + 0x26, 0x86, 0x44, 0x09, 0x76, 0xCE, 0x3F, 0x1F, 0xFA, 0x51, 0xFA, 0xFB, + 0xFB, 0xD3, 0xAA, 0x6D, 0xB4, 0x92, 0xD3, 0xAC, 0x0F, 0xA7, 0x1E, 0x61, + 0x1C, 0x12, 0xB4, 0xD6, 0x01, 0x10, 0x21, 0xC2, 0x9C, 0x92, 0x6F, 0xBF, + 0xDA, 0x26, 0x04, 0x86, 0x5E, 0x7A, 0xE7, 0x7F, 0xFA, 0x74, 0x84, 0x10, + 0xB6, 0x95, 0xD8, 0xAF, 0xAB, 0x32, 0x2F, 0xE7, 0xC5, 0x04, 0x1F, 0xEB, + 0x9C, 0x46, 0x88, 0x74, 0x60, 0x77, 0x4F, 0xCF, 0xFB, 0x6D, 0x47, 0x31, + 0xD2, 0x52, 0x4A, 0xAD, 0x13, 0x44, 0x5A, 0x19, 0x21, 0x84, 0x71, 0x66, + 0x9A, 0x97, 0xFD, 0x7A, 0x85, 0x10, 0x7A, 0x3A, 0x9D, 0x76, 0xAB, 0x2E, + 0xE7, 0x3C, 0xCF, 0x72, 0x08, 0x51, 0x4C, 0x20, 0xCB, 0x72, 0x63, 0x2D, + 0x42, 0x11, 0xE2, 0x65, 0x5E, 0x46, 0xE7, 0x53, 0x57, 0xD4, 0x9B, 0x66, + 0xFD, 0x74, 0x78, 0x94, 0x7A, 0xD1, 0xC1, 0x29, 0x1F, 0x7C, 0x4C, 0x6D, + 0x93, 0x21, 0x88, 0xFF, 0xF8, 0xF6, 0x36, 0xA7, 0x75, 0x08, 0xE9, 0xEE, + 0xF1, 0x71, 0x52, 0x2A, 0x01, 0xCC, 0x29, 0xF3, 0xC1, 0xF3, 0x8C, 0x86, + 0xE8, 0xBA, 0x75, 0x6B, 0x75, 0x70, 0xD6, 0x11, 0x02, 0x39, 0x63, 0x45, + 0x2E, 0x70, 0x8A, 0x14, 0x23, 0xE3, 0xAD, 0xB5, 0xE0, 0xFE, 0xE9, 0x74, + 0xEC, 0x7B, 0x4C, 0x39, 0x22, 0x61, 0xBD, 0x2A, 0x72, 0x91, 0x3F, 0x3D, + 0xF6, 0xEF, 0x6E, 0xAF, 0xA7, 0x45, 0x36, 0xAB, 0x2E, 0x85, 0x50, 0x55, + 0x05, 0xC2, 0x54, 0x4F, 0x63, 0x9E, 0xE7, 0xF7, 0xC7, 0xE1, 0xF9, 0xE9, + 0x29, 0xA5, 0xD0, 0xE4, 0x05, 0xC2, 0xC0, 0x85, 0x40, 0x29, 0x26, 0x28, + 0x51, 0x42, 0x60, 0xC4, 0xCA, 0x78, 0x6D, 0x6D, 0x4A, 0x10, 0x11, 0x47, + 0x19, 0x77, 0x21, 0xC4, 0x10, 0xC6, 0x8B, 0xC2, 0x94, 0x77, 0x95, 0xB8, + 0x7F, 0xE8, 0x57, 0x5D, 0xFB, 0xE5, 0x79, 0x70, 0x21, 0x6D, 0x37, 0xAD, + 0xA0, 0xB8, 0xC8, 0xD9, 0xE1, 0xD4, 0x3F, 0x3C, 0xF5, 0x6D, 0x53, 0x56, + 0x79, 0x26, 0xA5, 0x2A, 0x32, 0xBE, 0xDD, 0x6D, 0x31, 0x0C, 0x55, 0x59, + 0x12, 0x82, 0xC7, 0x69, 0xC1, 0x04, 0x30, 0xCE, 0xC7, 0x51, 0x3D, 0x3E, + 0x3D, 0x5F, 0xE6, 0x65, 0xBF, 0x5F, 0x13, 0x0C, 0x09, 0x61, 0x5A, 0x1B, + 0xAD, 0xF5, 0x6E, 0x55, 0x33, 0x04, 0x43, 0xF0, 0xD3, 0xA4, 0xEA, 0xB6, + 0xA9, 0x9B, 0x26, 0x25, 0x64, 0x8C, 0x69, 0xBA, 0x96, 0x32, 0x88, 0x92, + 0x1F, 0xA6, 0xE1, 0x78, 0x9C, 0xBA, 0xB2, 0x2B, 0x38, 0x62, 0x1C, 0x41, + 0x1C, 0x63, 0x00, 0x00, 0xE0, 0xA2, 0xE3, 0x00, 0x44, 0xEB, 0x80, 0x5A, + 0xB4, 0x55, 0x2E, 0xCF, 0x98, 0x92, 0x7A, 0xB8, 0xC8, 0xFB, 0xC3, 0xD0, + 0xAD, 0x3A, 0xA3, 0xF4, 0xF7, 0xBF, 0x7C, 0xEE, 0xEA, 0x7A, 0x58, 0x24, + 0x21, 0x74, 0x55, 0x88, 0xA7, 0xF3, 0x90, 0x09, 0x16, 0x53, 0x84, 0x18, + 0xBE, 0x5A, 0x77, 0xCF, 0x97, 0x51, 0xF0, 0xCC, 0x28, 0x99, 0x00, 0x58, + 0xAF, 0x36, 0x5A, 0x2F, 0x08, 0xC3, 0x59, 0x2A, 0x00, 0x22, 0xA7, 0xDC, + 0x7A, 0x7F, 0x9A, 0x15, 0x21, 0xB4, 0x2E, 0x0B, 0x63, 0xFD, 0xBA, 0x69, + 0x18, 0xC1, 0x45, 0x26, 0x20, 0x4C, 0xC3, 0x30, 0x67, 0x42, 0xB8, 0x10, + 0x86, 0x79, 0x5E, 0xA4, 0x21, 0x3C, 0xF3, 0x31, 0x4D, 0xD3, 0xF0, 0xEE, + 0xE5, 0x15, 0x42, 0x40, 0x2A, 0x4B, 0xB9, 0x58, 0xB7, 0xC5, 0xB2, 0x0C, + 0xF0, 0xEB, 0xB7, 0xAF, 0x9E, 0x4F, 0x83, 0x77, 0xBE, 0xA9, 0x33, 0xE3, + 0x20, 0xC2, 0x58, 0xAB, 0x85, 0x62, 0x08, 0x31, 0x98, 0x17, 0xED, 0x5D, + 0x88, 0x31, 0x62, 0x42, 0x29, 0xA5, 0x8C, 0xE2, 0x4C, 0x50, 0xA9, 0xF4, + 0xB2, 0x68, 0x21, 0x78, 0x56, 0xE4, 0xC1, 0x7B, 0x67, 0x5C, 0x55, 0x66, + 0x31, 0x44, 0xC1, 0x88, 0xD2, 0x16, 0x62, 0x24, 0x38, 0x33, 0xD6, 0x86, + 0x10, 0x72, 0xC1, 0x11, 0x61, 0x97, 0x49, 0x7B, 0xE7, 0x38, 0x13, 0x29, + 0x25, 0x63, 0xCC, 0xCD, 0xA6, 0xBE, 0xD9, 0x6F, 0x95, 0x0F, 0x20, 0x39, + 0x4A, 0xD9, 0xD3, 0x61, 0xFC, 0xF6, 0xAB, 0x57, 0xB7, 0xFB, 0xEE, 0xFF, + 0xFD, 0xEE, 0xD3, 0xF7, 0x9F, 0xEE, 0x1E, 0x0E, 0xC7, 0xAF, 0x6E, 0x5F, + 0xFE, 0xA7, 0x3F, 0x7E, 0xF5, 0x7F, 0xFE, 0xDF, 0xFF, 0x32, 0x2B, 0xDF, + 0xD6, 0x55, 0x53, 0x67, 0x45, 0xC6, 0x33, 0x21, 0x3E, 0x7E, 0xB9, 0x53, + 0xC6, 0x65, 0x79, 0xC6, 0x05, 0xC3, 0x00, 0x9C, 0x8E, 0xFD, 0x2C, 0x15, + 0xA3, 0xB8, 0xAD, 0xF3, 0xC5, 0x98, 0x18, 0xFD, 0x9F, 0xDE, 0xBF, 0xDD, + 0xAF, 0x37, 0x1F, 0x4E, 0xF6, 0xCB, 0x97, 0xFF, 0xD8, 0xED, 0x6E, 0x5E, + 0xBD, 0x7A, 0x7F, 0xEE, 0x1F, 0x1F, 0x1F, 0xEE, 0xFB, 0xCB, 0x40, 0x29, + 0xE9, 0xBA, 0xAE, 0x16, 0x78, 0xDD, 0x94, 0x9F, 0x9F, 0x2E, 0x10, 0x91, + 0x6F, 0xDE, 0xBC, 0x1C, 0x86, 0xE9, 0xCB, 0xD3, 0xE5, 0xE6, 0x66, 0x6F, + 0xB5, 0xD2, 0xD6, 0x32, 0x46, 0x31, 0x86, 0x10, 0xA1, 0x10, 0x41, 0x56, + 0xAD, 0x3E, 0x7F, 0xFC, 0x81, 0x31, 0x5C, 0x35, 0x55, 0xC6, 0x98, 0xE0, + 0xE8, 0xCB, 0xC3, 0xE1, 0x78, 0x1E, 0x71, 0x0C, 0x8C, 0xF1, 0x71, 0x92, + 0xAB, 0xA6, 0x7A, 0xF7, 0xF2, 0xEA, 0x2F, 0xDF, 0xFD, 0x34, 0x29, 0xFB, + 0xED, 0xDB, 0xEB, 0xAC, 0x62, 0x5D, 0x59, 0xC3, 0xC8, 0xE7, 0x65, 0x5A, + 0xD4, 0xA2, 0x7D, 0xB0, 0xC6, 0x8A, 0x9C, 0xF2, 0x9C, 0xFD, 0x0A, 0xDE, + 0x5B, 0x16, 0x73, 0x3E, 0x4D, 0x8B, 0x34, 0x21, 0x24, 0x88, 0x00, 0x42, + 0xD8, 0x1A, 0x2B, 0xA7, 0x05, 0x02, 0xF0, 0xEA, 0xC5, 0x8E, 0x10, 0xEA, + 0xB4, 0xE7, 0x19, 0xC7, 0x08, 0xF2, 0x8C, 0x26, 0x08, 0x61, 0x8A, 0x5D, + 0x57, 0x19, 0xAD, 0xCB, 0xB2, 0x80, 0x21, 0x98, 0x10, 0x10, 0x82, 0x10, + 0x40, 0x1F, 0xFD, 0xF1, 0xF0, 0xAC, 0x54, 0x1C, 0xC7, 0xC5, 0xC7, 0x68, + 0x5C, 0x34, 0xC6, 0x6F, 0x56, 0x75, 0x08, 0x2E, 0xA5, 0x48, 0x21, 0x7A, + 0x75, 0xBD, 0x2D, 0x0B, 0x9E, 0x10, 0x80, 0x18, 0xCD, 0xC3, 0x94, 0x20, + 0xF0, 0x09, 0x10, 0xC2, 0x9C, 0x0F, 0x80, 0xA0, 0xC3, 0x73, 0x3F, 0x8E, + 0xD2, 0x85, 0x88, 0x31, 0x29, 0x04, 0x59, 0xB4, 0x0B, 0x21, 0x6C, 0xB6, + 0xDD, 0x66, 0xD5, 0x14, 0x82, 0x94, 0x45, 0x2E, 0x95, 0xE2, 0x99, 0xF0, + 0xDE, 0x3B, 0xEB, 0x52, 0x4A, 0x84, 0x40, 0x08, 0x92, 0x77, 0x09, 0x42, + 0xA4, 0x94, 0x31, 0xDA, 0x62, 0x0A, 0x63, 0x08, 0xEB, 0x75, 0x8D, 0x30, + 0x81, 0x20, 0x11, 0x8A, 0xBC, 0x0B, 0x94, 0x61, 0x08, 0x50, 0xD7, 0xD6, + 0x6A, 0x31, 0xF7, 0x8F, 0xFD, 0x24, 0x8D, 0x36, 0x7E, 0x9A, 0xAC, 0x56, + 0x73, 0x00, 0xC8, 0xB8, 0x94, 0x33, 0xFC, 0xFE, 0x55, 0xCD, 0x38, 0x0C, + 0x8E, 0x4C, 0x8A, 0x3D, 0x9C, 0x2E, 0xCF, 0xCF, 0x0F, 0x4D, 0xCE, 0xCA, + 0x9C, 0x39, 0x1F, 0x05, 0xC1, 0x08, 0x42, 0x46, 0x31, 0xE3, 0xE4, 0xF9, + 0x22, 0xCF, 0xA3, 0xDC, 0xAE, 0x3B, 0x6B, 0x2C, 0x06, 0x89, 0x10, 0x92, + 0x52, 0x1C, 0x17, 0xA5, 0x9D, 0x17, 0x9C, 0x5E, 0xC6, 0xB9, 0x29, 0x4B, + 0x6D, 0x0C, 0xC1, 0xE8, 0xFD, 0xED, 0x6B, 0x82, 0xF0, 0xBC, 0xC8, 0x71, + 0x5E, 0x20, 0x42, 0xEB, 0xD5, 0xEA, 0x97, 0x2F, 0x77, 0x79, 0xCE, 0x42, + 0x34, 0x00, 0xB9, 0x17, 0x9B, 0xED, 0xED, 0xD5, 0xCB, 0xC7, 0xE7, 0x7E, + 0x98, 0x06, 0x08, 0xD3, 0xF3, 0x65, 0x50, 0xDE, 0x72, 0x0E, 0x37, 0x2B, + 0x3A, 0x2F, 0xF1, 0xCF, 0x5F, 0xFF, 0x21, 0xBA, 0xE4, 0xAC, 0xFB, 0x72, + 0x3C, 0x2A, 0xE3, 0xB4, 0xB6, 0x59, 0x26, 0xBA, 0xBA, 0x0C, 0xC1, 0x1F, + 0xCE, 0xFD, 0xD5, 0xBE, 0x93, 0x8B, 0x16, 0x22, 0x27, 0x04, 0x78, 0xE7, + 0x09, 0x45, 0x20, 0x25, 0x82, 0xF0, 0x8B, 0x57, 0x57, 0x5A, 0xD9, 0xE3, + 0xF1, 0xFC, 0x7C, 0x19, 0xCE, 0x97, 0x79, 0xBB, 0xCB, 0xEA, 0x22, 0x8B, + 0x20, 0x35, 0x65, 0x1D, 0xB4, 0x43, 0x0C, 0x03, 0x8A, 0xAC, 0xB1, 0x08, + 0xC3, 0xB2, 0xC8, 0xA3, 0xD5, 0x5C, 0x54, 0xE3, 0x34, 0x07, 0xAF, 0xAB, + 0x4C, 0x58, 0xE9, 0x12, 0xC2, 0x4D, 0x5D, 0x6A, 0x2D, 0xB5, 0xF5, 0x65, + 0x55, 0x27, 0x6F, 0x53, 0x84, 0x19, 0xA7, 0xDA, 0x6B, 0xE3, 0x7D, 0x55, + 0xB6, 0x18, 0x05, 0x08, 0x08, 0x45, 0xD8, 0x1A, 0x13, 0x7C, 0x04, 0x09, + 0xD5, 0x4D, 0xFB, 0xE3, 0xE7, 0x07, 0xE3, 0x5C, 0x59, 0x64, 0xDA, 0x06, + 0x84, 0x20, 0x42, 0xD0, 0x68, 0x9D, 0xE5, 0x59, 0x53, 0x37, 0xC3, 0xD0, + 0x6B, 0x63, 0x8D, 0x09, 0x10, 0xC6, 0xDD, 0xBA, 0xC5, 0x10, 0x0C, 0xA3, + 0x4D, 0x04, 0x7B, 0x67, 0x38, 0x25, 0x09, 0x02, 0x65, 0x8C, 0xB1, 0x4E, + 0x1B, 0x93, 0xE7, 0xCC, 0xBB, 0x20, 0x38, 0x80, 0x11, 0xE6, 0xF9, 0x06, + 0x21, 0xE6, 0xAC, 0xBC, 0xBE, 0xB9, 0x41, 0x29, 0x0D, 0xE3, 0xA4, 0xAD, + 0xDB, 0x5D, 0x5F, 0x7B, 0x23, 0xEB, 0x2A, 0x47, 0x30, 0x09, 0xC1, 0x96, + 0x59, 0x0F, 0xA7, 0xB3, 0x52, 0x2A, 0x46, 0x9F, 0x65, 0x59, 0x82, 0x08, + 0x91, 0x84, 0x11, 0x84, 0x18, 0x88, 0x82, 0x16, 0xB9, 0x40, 0x00, 0x20, + 0x80, 0x94, 0xB4, 0x45, 0x59, 0xDE, 0x3F, 0xF4, 0xFF, 0xF6, 0xFD, 0x3D, + 0x88, 0xBE, 0x6B, 0x4A, 0x82, 0x90, 0x5A, 0xE6, 0x04, 0x31, 0x22, 0x28, + 0xE3, 0x40, 0x30, 0x02, 0x31, 0x75, 0x4A, 0x2D, 0x0E, 0x5C, 0xEF, 0x6F, + 0xFA, 0xD3, 0x13, 0xE3, 0x39, 0x21, 0x5C, 0xCA, 0x51, 0x9A, 0xA5, 0xAA, + 0x4B, 0xEF, 0x43, 0x99, 0x95, 0x1F, 0x1F, 0x0E, 0xA7, 0x71, 0xC4, 0x10, + 0x35, 0x65, 0xD1, 0xB5, 0x8D, 0x92, 0x7A, 0x9E, 0xA7, 0xDD, 0x76, 0x2F, + 0x38, 0xB3, 0x46, 0x87, 0x98, 0x8C, 0xF5, 0x10, 0x63, 0x6D, 0xEC, 0xF3, + 0xF9, 0xBC, 0x48, 0x55, 0x97, 0x85, 0xE0, 0xA2, 0x2C, 0xC4, 0xA2, 0x96, + 0x8C, 0x17, 0x55, 0x55, 0x08, 0x06, 0x30, 0xE7, 0x1C, 0x13, 0x6A, 0xAD, + 0xFD, 0x55, 0xB5, 0x55, 0x4A, 0x59, 0x17, 0xF2, 0x5C, 0x48, 0x65, 0x9C, + 0xF5, 0x08, 0x21, 0x00, 0x40, 0x55, 0x66, 0xDB, 0x6D, 0xE3, 0x9D, 0x17, + 0x19, 0x27, 0x94, 0x64, 0xB9, 0x70, 0xCE, 0x61, 0x8C, 0x56, 0xEB, 0x26, + 0xCB, 0x28, 0x86, 0x50, 0x29, 0x45, 0x28, 0x4E, 0x10, 0x78, 0xE7, 0xAD, + 0xF3, 0xE3, 0xA2, 0xD7, 0xAB, 0xB2, 0x2A, 0xEB, 0xF3, 0xB8, 0x20, 0x04, + 0x40, 0x02, 0x52, 0x29, 0x6B, 0x4D, 0x2E, 0xB2, 0xB6, 0xCA, 0xCF, 0xC3, + 0x34, 0x4C, 0xF2, 0xC5, 0xA6, 0xD5, 0xCA, 0x22, 0xCC, 0x5E, 0xED, 0xD6, + 0x9F, 0xEF, 0x9F, 0xF6, 0xDB, 0xEE, 0xBB, 0x0F, 0x9F, 0x31, 0x46, 0xDF, + 0xBC, 0xBE, 0x7E, 0x3E, 0x0F, 0x89, 0x90, 0xA2, 0x28, 0x2E, 0xFD, 0xE0, + 0xAC, 0xCF, 0x18, 0x05, 0x20, 0x4D, 0xD3, 0x72, 0x38, 0xF5, 0x10, 0x21, + 0xCE, 0x88, 0x5C, 0x14, 0x42, 0x68, 0xD5, 0xD5, 0xD3, 0x32, 0x33, 0x46, + 0x52, 0x82, 0xA5, 0x10, 0x6F, 0xAE, 0xF7, 0xBF, 0x3C, 0x3C, 0xDE, 0xDD, + 0x7F, 0x5E, 0x5D, 0xBD, 0xC5, 0x88, 0x2B, 0x39, 0x2D, 0x3A, 0xDD, 0x7D, + 0xFE, 0x64, 0x3D, 0xE8, 0xDA, 0x36, 0x13, 0xEC, 0xE9, 0xE9, 0xF4, 0xE9, + 0xE1, 0x68, 0xAD, 0x63, 0x98, 0x68, 0x6D, 0xCE, 0xC3, 0x52, 0x95, 0xF9, + 0xF3, 0xF3, 0x73, 0x84, 0xB4, 0x28, 0x5B, 0xEF, 0x02, 0x84, 0xC9, 0x18, + 0x15, 0x12, 0x0E, 0x11, 0x49, 0x65, 0x00, 0xC2, 0x53, 0xDF, 0x23, 0x90, + 0xD4, 0xA2, 0x12, 0x04, 0x75, 0x95, 0x33, 0x46, 0xCB, 0xB2, 0x88, 0x31, + 0xAE, 0xBB, 0x6E, 0x5A, 0xA6, 0xC7, 0xE3, 0x69, 0xBF, 0x6D, 0x77, 0xBB, + 0xEA, 0x6A, 0xBB, 0x4E, 0x81, 0x3F, 0x3E, 0xCF, 0xD3, 0xA2, 0x17, 0x69, + 0xAC, 0xF3, 0xF3, 0xF2, 0x6B, 0x94, 0x22, 0x69, 0x6D, 0x1F, 0xEF, 0x8F, + 0x59, 0x59, 0x94, 0x55, 0x86, 0x30, 0x98, 0xC6, 0x85, 0x09, 0x1E, 0x13, + 0x90, 0x8B, 0x72, 0x31, 0x06, 0xE3, 0x8A, 0xBC, 0xFC, 0xE1, 0xC3, 0x1D, + 0xA2, 0x28, 0x17, 0x3C, 0xF8, 0x10, 0x52, 0x7C, 0x7A, 0x3A, 0x2F, 0x4A, + 0xB9, 0x10, 0x8E, 0xC7, 0x5E, 0x4A, 0x4D, 0xB8, 0x38, 0x9F, 0x86, 0xD3, + 0xA5, 0x0F, 0x31, 0x11, 0x8C, 0x09, 0x61, 0x79, 0x91, 0x4F, 0xD3, 0xE2, + 0xAD, 0x17, 0x9C, 0xBF, 0x7F, 0xFB, 0xAA, 0xA9, 0xB8, 0x77, 0x76, 0xD3, + 0x36, 0x6D, 0x55, 0xB6, 0xED, 0x0A, 0x43, 0xEA, 0x8C, 0x39, 0x1D, 0x07, + 0x17, 0xC2, 0x30, 0x2C, 0x00, 0xA0, 0xB9, 0x97, 0xD1, 0x45, 0x18, 0xD2, + 0xBA, 0xAB, 0x36, 0xEB, 0x26, 0x78, 0xED, 0x9D, 0xE6, 0x8C, 0x46, 0x90, + 0xB6, 0xEB, 0xF2, 0xDD, 0x8B, 0x0D, 0x0C, 0x61, 0x9A, 0xE4, 0x30, 0x2C, + 0x97, 0xD3, 0xA0, 0x94, 0x3E, 0x9E, 0x86, 0xD3, 0x65, 0x58, 0x16, 0xF9, + 0x7C, 0x7F, 0xCE, 0x33, 0xEE, 0x82, 0xF7, 0x3E, 0x7E, 0xB9, 0x3B, 0x3D, + 0x3D, 0x5F, 0xAA, 0x92, 0x65, 0x45, 0x06, 0x12, 0xF0, 0xC9, 0x3B, 0x6F, + 0x13, 0x4A, 0x2C, 0x63, 0x10, 0x02, 0x4A, 0xB1, 0x73, 0x6E, 0x5E, 0x16, + 0x51, 0xF0, 0xB2, 0x2A, 0xCA, 0x82, 0xD7, 0x05, 0xCF, 0x33, 0x7A, 0x1E, + 0x34, 0x25, 0xEC, 0xEB, 0xDB, 0xEB, 0xFE, 0x3C, 0x04, 0x97, 0x0E, 0xC7, + 0x71, 0xD2, 0xBE, 0x5B, 0xEF, 0xCA, 0x9C, 0x73, 0x0A, 0xDA, 0xBA, 0x14, + 0x8C, 0x68, 0xA3, 0x52, 0xF4, 0x82, 0xA2, 0x98, 0x22, 0x40, 0x2C, 0x26, + 0x64, 0xAC, 0x7D, 0x77, 0xB3, 0xA7, 0x18, 0x48, 0xA5, 0xDE, 0x5C, 0x77, + 0xC7, 0xCB, 0x98, 0x40, 0x0C, 0x21, 0x64, 0x94, 0x58, 0xE7, 0x04, 0xA3, + 0x6F, 0x5E, 0x5C, 0x39, 0xE7, 0x39, 0x67, 0x31, 0x06, 0x10, 0x23, 0x65, + 0xEC, 0xD4, 0x0F, 0xC6, 0x6A, 0x8C, 0x30, 0x86, 0xE8, 0xCD, 0xCD, 0xB6, + 0x64, 0xF9, 0x79, 0x50, 0xD2, 0x5A, 0x1F, 0x54, 0x5B, 0xC5, 0x7E, 0x32, + 0x82, 0xC7, 0xED, 0x8A, 0xF4, 0xBD, 0x8F, 0x11, 0xEE, 0x57, 0xBB, 0xE0, + 0x81, 0x0D, 0x71, 0x5C, 0xA4, 0x32, 0xB6, 0x6E, 0xCA, 0xD5, 0xBA, 0x3B, + 0x9E, 0xFA, 0x98, 0x22, 0x26, 0x64, 0x18, 0x65, 0xDB, 0xD4, 0xAF, 0x5E, + 0x5C, 0x2F, 0xD6, 0xF5, 0xD3, 0xAC, 0x9D, 0x8F, 0x00, 0x38, 0x1F, 0x9D, + 0x0B, 0x65, 0x25, 0xBA, 0xAE, 0xA9, 0xCB, 0x5F, 0xDB, 0x1F, 0x74, 0x5E, + 0x16, 0xA5, 0x9D, 0xD6, 0x1A, 0xC0, 0xE4, 0x82, 0x9B, 0x17, 0x75, 0x19, + 0x26, 0xB9, 0xA8, 0xF1, 0xD2, 0x6B, 0xE3, 0x8E, 0xFD, 0xF9, 0x74, 0xEC, + 0x31, 0x22, 0x14, 0x93, 0xAC, 0xC8, 0xA4, 0x54, 0xE3, 0x22, 0x9F, 0x4E, + 0x52, 0xCA, 0x18, 0xDD, 0xE8, 0xAC, 0x36, 0xC6, 0x27, 0x08, 0x30, 0x23, + 0xC1, 0x06, 0x6F, 0xAC, 0x37, 0x81, 0x42, 0x31, 0x5C, 0x86, 0x18, 0x3C, + 0x21, 0x84, 0x53, 0x9A, 0x67, 0x62, 0xB3, 0xAA, 0xBA, 0x3A, 0xDB, 0xAE, + 0xEA, 0xAB, 0x7D, 0xD3, 0x94, 0x39, 0x48, 0xB1, 0x5B, 0x55, 0x59, 0x21, + 0x8A, 0x42, 0xAC, 0x56, 0xD5, 0x7A, 0x53, 0x97, 0x85, 0xD0, 0xCE, 0x2D, + 0xE3, 0x82, 0x31, 0xE5, 0x22, 0x77, 0x56, 0x11, 0x18, 0x08, 0x21, 0x10, + 0xA1, 0x69, 0x96, 0xFD, 0x20, 0x17, 0xA9, 0x83, 0xF3, 0x18, 0x25, 0x0C, + 0x61, 0x53, 0xAC, 0x45, 0xB1, 0x59, 0x94, 0xC3, 0x10, 0x74, 0x6D, 0x0B, + 0x83, 0xD3, 0x1E, 0xF0, 0xA2, 0x0A, 0xDE, 0x51, 0xCE, 0x17, 0xAD, 0xAC, + 0xB6, 0x00, 0xF2, 0x8C, 0x33, 0xAB, 0x55, 0x08, 0x71, 0x9C, 0xA5, 0xF1, + 0xE0, 0xD8, 0x2F, 0x77, 0x0F, 0x17, 0x90, 0x90, 0x35, 0xD6, 0x38, 0x7F, + 0xE9, 0xE7, 0xE7, 0x43, 0x9F, 0x70, 0x32, 0xDE, 0x5B, 0xEF, 0x44, 0x8E, + 0x9B, 0x75, 0xBD, 0xAA, 0xAB, 0x42, 0xB0, 0xB6, 0x29, 0xDB, 0xBA, 0x5A, + 0x94, 0xBD, 0x7D, 0xF5, 0x62, 0xB7, 0xD9, 0x60, 0x88, 0xAB, 0xB2, 0xF2, + 0x31, 0x95, 0xE5, 0x26, 0xE3, 0x14, 0xA5, 0xB8, 0xEA, 0x36, 0xC6, 0xFB, + 0x45, 0x4A, 0x80, 0x20, 0xE7, 0xC2, 0x58, 0x27, 0x95, 0x62, 0x4C, 0x60, + 0x8C, 0xDA, 0xBA, 0xDA, 0xAC, 0xD6, 0xE7, 0xF3, 0xF0, 0x2B, 0xD8, 0xBA, + 0xAA, 0xBA, 0x61, 0xE8, 0x8D, 0x5E, 0x42, 0x8C, 0x21, 0x24, 0x69, 0x6C, + 0xDB, 0x56, 0x10, 0xE2, 0xDD, 0xBA, 0x6D, 0xF3, 0xAC, 0xAB, 0x6B, 0x88, + 0xF9, 0xDD, 0xC3, 0x53, 0x93, 0x67, 0x4A, 0x1B, 0x6D, 0x2C, 0x86, 0x08, + 0x03, 0x00, 0xAD, 0x35, 0x21, 0xC6, 0xB2, 0xCC, 0x30, 0x84, 0x00, 0xC0, + 0x32, 0x13, 0xC1, 0x07, 0x88, 0x60, 0x55, 0x66, 0x05, 0xA3, 0xDA, 0xB8, + 0x2A, 0xCF, 0x83, 0xF3, 0xFD, 0x65, 0x42, 0x08, 0x82, 0x98, 0xA4, 0x54, + 0xB9, 0xE0, 0x14, 0x21, 0xE7, 0x9C, 0x71, 0x96, 0x21, 0xB4, 0xDB, 0x76, + 0x52, 0xDA, 0xA6, 0xAA, 0x4E, 0xFD, 0x80, 0x11, 0xDC, 0x75, 0x75, 0xC6, + 0xC4, 0xA7, 0xFB, 0x47, 0x04, 0x62, 0x8A, 0x91, 0x53, 0x5C, 0xE6, 0xB9, + 0x31, 0xBA, 0x9F, 0x26, 0xEB, 0x3C, 0x42, 0xF0, 0x3C, 0x2E, 0x9F, 0x1E, + 0xCF, 0xA5, 0x60, 0x04, 0x06, 0x44, 0xD1, 0x5F, 0x7E, 0xFC, 0xC5, 0x79, + 0x7F, 0xB5, 0x6D, 0x3F, 0xDE, 0x1D, 0x8D, 0xF5, 0x6F, 0xDF, 0xBC, 0xFC, + 0xF4, 0xE5, 0xBE, 0x1F, 0x47, 0x4C, 0x59, 0x88, 0x51, 0x70, 0x1C, 0xBC, + 0x9F, 0x16, 0xD5, 0xB6, 0xF5, 0xE5, 0x7C, 0x69, 0xCA, 0xAC, 0x6B, 0xEA, + 0xBE, 0x1F, 0x5F, 0xDF, 0x6C, 0x21, 0x44, 0xE3, 0x30, 0xBE, 0xB9, 0xD9, + 0x1B, 0xE7, 0x3E, 0xDE, 0x3D, 0x0A, 0x4E, 0xAE, 0xF6, 0xD7, 0x97, 0xD9, + 0x25, 0x2C, 0xE4, 0x74, 0x7A, 0x3E, 0x1C, 0x08, 0xE1, 0x55, 0x2E, 0xA6, + 0x71, 0xF2, 0x3E, 0xFC, 0xFD, 0xDF, 0x7C, 0xB5, 0xD9, 0xD4, 0x98, 0xE2, + 0xFB, 0xFB, 0xE3, 0xF3, 0xE9, 0xE4, 0x8C, 0xB6, 0xDE, 0xAD, 0xAF, 0xDF, + 0x14, 0x8C, 0x5C, 0xDD, 0xDC, 0xFC, 0xFC, 0xE1, 0xCB, 0xA2, 0x42, 0x55, + 0x6F, 0x8F, 0xE7, 0x1E, 0x40, 0x60, 0xED, 0xE2, 0x5C, 0x08, 0xD6, 0xC5, + 0x94, 0xE6, 0x59, 0x32, 0x42, 0xEA, 0x32, 0x5F, 0x35, 0xD5, 0x7E, 0xB7, + 0xC9, 0x33, 0x36, 0x4C, 0xF3, 0xD5, 0x8B, 0xF7, 0xAF, 0x6E, 0xBF, 0xE2, + 0x2C, 0x37, 0x0A, 0x0E, 0x93, 0x53, 0x11, 0x9D, 0x2F, 0x97, 0x10, 0x62, + 0x8C, 0x81, 0x32, 0x3C, 0x4E, 0x4B, 0x5E, 0x08, 0x6B, 0x2D, 0x17, 0xCC, + 0x1A, 0x13, 0xBC, 0x2B, 0x8B, 0xDC, 0x5A, 0x2B, 0x17, 0xE3, 0x9D, 0xF7, + 0x21, 0xC8, 0x59, 0x6E, 0xDA, 0xFA, 0xE9, 0xD4, 0x4B, 0x6D, 0xDA, 0x3A, + 0x2B, 0x32, 0xEE, 0x43, 0x3C, 0x3C, 0x9F, 0x8F, 0xC7, 0x73, 0x5B, 0x17, + 0x29, 0x46, 0x00, 0x61, 0x8A, 0x70, 0xEA, 0x25, 0xA6, 0x84, 0x72, 0x86, + 0x30, 0x19, 0x86, 0x39, 0x17, 0x39, 0x42, 0x08, 0x41, 0x58, 0x64, 0xA2, + 0x5B, 0xD5, 0xCE, 0xAB, 0xE0, 0x42, 0x53, 0x94, 0x82, 0x32, 0xA5, 0x7C, + 0x48, 0xA1, 0x1F, 0x86, 0xE0, 0xC2, 0x22, 0x35, 0xE1, 0x64, 0x77, 0xDD, + 0x3C, 0x3E, 0x8E, 0xF3, 0x6C, 0xAA, 0x2A, 0xB7, 0xCA, 0x4F, 0x93, 0x16, + 0x8C, 0xE7, 0x9C, 0xD4, 0x15, 0x07, 0x10, 0x5F, 0xEF, 0xB7, 0xCE, 0x79, + 0x0A, 0xD2, 0x6A, 0xDB, 0xB8, 0x18, 0x29, 0x41, 0x55, 0x5B, 0x61, 0x04, + 0xBD, 0x8B, 0x3E, 0xF8, 0x79, 0x94, 0x20, 0x61, 0x46, 0x08, 0x26, 0x58, + 0x69, 0x0B, 0x21, 0xA8, 0xDB, 0x1C, 0xC3, 0xB8, 0x59, 0x97, 0x94, 0x10, + 0x42, 0xA0, 0x9C, 0xA5, 0x5C, 0x64, 0x7F, 0x19, 0xBC, 0x71, 0xC1, 0x04, + 0xB5, 0xE8, 0xB2, 0xCE, 0x09, 0x65, 0x28, 0x41, 0x46, 0x70, 0x59, 0xF1, + 0xD5, 0xAA, 0x5E, 0x35, 0x45, 0x55, 0xF0, 0x10, 0xDC, 0xB9, 0x9F, 0x9D, + 0x73, 0xD2, 0xD8, 0x0F, 0x5F, 0xEE, 0x53, 0x30, 0x82, 0x23, 0x8A, 0x61, + 0x46, 0x19, 0x04, 0xF0, 0x74, 0x19, 0x18, 0x61, 0xEB, 0xBA, 0x4C, 0x00, + 0x73, 0xC6, 0x8E, 0xA7, 0xE3, 0xBA, 0xA9, 0xCB, 0x3C, 0xFB, 0xEE, 0xC3, + 0x2F, 0xFB, 0x55, 0xF5, 0x70, 0xEC, 0x63, 0x8C, 0x14, 0xE3, 0x10, 0x13, + 0xC5, 0x68, 0x94, 0xFA, 0xD5, 0xBE, 0x03, 0x20, 0x49, 0xA9, 0x31, 0x8C, + 0xD3, 0x3C, 0xA7, 0x14, 0x4F, 0xFD, 0x00, 0x40, 0x2C, 0xF2, 0xCC, 0x3A, + 0x53, 0x64, 0x05, 0xA5, 0xF9, 0xF1, 0x32, 0xDC, 0x1F, 0x07, 0xEB, 0x96, + 0xEB, 0x1D, 0xF8, 0xF2, 0xBC, 0x48, 0xE3, 0x43, 0x4C, 0xC6, 0x23, 0x00, + 0xC8, 0xDB, 0x57, 0xBB, 0xA6, 0xDA, 0x32, 0x51, 0x60, 0x42, 0x43, 0x04, + 0x6D, 0x5D, 0x67, 0x82, 0x1D, 0x4E, 0x97, 0xD3, 0xE5, 0xF2, 0xCD, 0x57, + 0x2F, 0x08, 0x86, 0xDA, 0xBA, 0xA2, 0xC8, 0xEF, 0x1E, 0x9F, 0xA4, 0xB5, + 0xF3, 0xAC, 0x28, 0xE3, 0xDE, 0x07, 0x04, 0xC0, 0x7E, 0xB7, 0x22, 0x14, + 0x73, 0xCE, 0x31, 0x82, 0x65, 0x99, 0xAF, 0xD7, 0x5D, 0x3F, 0xCC, 0x77, + 0x0F, 0xBD, 0x35, 0x21, 0xC6, 0x70, 0x19, 0x97, 0x69, 0xD1, 0xCE, 0x25, + 0x6D, 0x3C, 0xC1, 0x44, 0x9B, 0x78, 0xEA, 0x55, 0x5D, 0x55, 0x20, 0xA1, + 0x61, 0x99, 0x17, 0xE3, 0x94, 0xF5, 0xE7, 0xB3, 0xC4, 0x08, 0x4B, 0xA5, + 0x09, 0x4C, 0xD6, 0x3B, 0xE5, 0x92, 0x31, 0xFE, 0x74, 0x1E, 0x95, 0xF1, + 0xA7, 0xF3, 0x0C, 0x21, 0x38, 0x0E, 0xA3, 0xD4, 0xFA, 0xD0, 0xAB, 0xF3, + 0x6C, 0xCF, 0xA3, 0x1C, 0x67, 0xDD, 0x8F, 0xF3, 0x2C, 0xF5, 0xB2, 0x2C, + 0x30, 0x05, 0x4E, 0xA9, 0xC8, 0x04, 0xC4, 0xC8, 0x79, 0xEF, 0xBD, 0xD7, + 0xCA, 0xCC, 0xB3, 0x62, 0x04, 0xBD, 0xBC, 0xD9, 0x96, 0x75, 0x89, 0x30, + 0xBA, 0x0C, 0x83, 0xF3, 0x8A, 0xB1, 0xBC, 0x9F, 0xF5, 0x38, 0x2E, 0xD6, + 0xBA, 0x71, 0x9E, 0xAF, 0x37, 0xCD, 0x7E, 0xBD, 0xA1, 0xAC, 0xB4, 0x1E, + 0x39, 0x0F, 0x8D, 0x0B, 0x5C, 0x64, 0x4D, 0xC9, 0x73, 0x41, 0x82, 0x51, + 0x2A, 0xC8, 0x61, 0xBE, 0x18, 0x37, 0xF7, 0x63, 0x2F, 0xE5, 0x32, 0x4D, + 0xE3, 0xBC, 0xC8, 0x79, 0x94, 0x65, 0x59, 0x70, 0x4E, 0x09, 0x11, 0x8B, + 0x76, 0xE7, 0x61, 0xF6, 0x31, 0x65, 0x99, 0x90, 0xCA, 0x30, 0xC1, 0xA5, + 0xB2, 0x77, 0x5F, 0xCE, 0xC1, 0xFB, 0x65, 0xD1, 0xCA, 0x9A, 0xF3, 0xB9, + 0xE7, 0x0C, 0x36, 0x95, 0x30, 0x6A, 0x41, 0x30, 0x54, 0x55, 0x99, 0x09, + 0x41, 0x29, 0x9B, 0x67, 0x13, 0x13, 0x9A, 0x17, 0x9D, 0xE7, 0x45, 0x5D, + 0xD7, 0xC9, 0xFB, 0x10, 0xC2, 0xE1, 0x70, 0x20, 0x9C, 0xBC, 0xB8, 0x59, + 0x6D, 0xDA, 0x7A, 0xB3, 0xEE, 0xAC, 0xB3, 0x59, 0x5E, 0xB6, 0x4D, 0x99, + 0x33, 0x0C, 0x13, 0xD0, 0xC6, 0x58, 0x17, 0xAD, 0x73, 0x82, 0x67, 0x72, + 0x99, 0xFB, 0xF1, 0x82, 0x31, 0x32, 0xD6, 0x8D, 0x52, 0x85, 0x18, 0xEB, + 0xA6, 0x56, 0x4A, 0x56, 0x82, 0x96, 0x65, 0x96, 0x40, 0x7A, 0xEC, 0xA7, + 0x75, 0xD7, 0xF8, 0x90, 0x06, 0xA9, 0x53, 0xF0, 0xB8, 0xA9, 0x2B, 0x6B, + 0x2D, 0x84, 0xA9, 0xCA, 0x85, 0x54, 0x9A, 0x63, 0xC4, 0x09, 0xA2, 0x8C, + 0x60, 0x4A, 0xDA, 0xB2, 0xDC, 0xAE, 0x6A, 0xA9, 0x95, 0x94, 0x06, 0x45, + 0xC0, 0x19, 0x99, 0x95, 0xC9, 0x05, 0x8F, 0x00, 0x44, 0x1F, 0x57, 0x6D, + 0x8B, 0x09, 0xD2, 0xDA, 0xD6, 0x19, 0x6B, 0xCA, 0xDC, 0xF9, 0xA8, 0x8D, + 0xAF, 0x9A, 0x1A, 0xA4, 0xF0, 0xE2, 0x7A, 0x95, 0x10, 0x7F, 0x7C, 0x3A, + 0x7A, 0xE7, 0x32, 0x2E, 0xFE, 0xF8, 0xBB, 0x6F, 0xFE, 0xEE, 0xF7, 0x5F, + 0x57, 0x65, 0x09, 0x80, 0x17, 0x1C, 0x73, 0xC6, 0x9B, 0xA6, 0x32, 0xDE, + 0x78, 0x6B, 0xBE, 0x7D, 0xF3, 0x62, 0xBD, 0xAE, 0x46, 0xA7, 0xC7, 0x45, + 0x27, 0x1F, 0x42, 0x88, 0x8B, 0xD2, 0x6F, 0x5F, 0xBF, 0x08, 0xDE, 0x9D, + 0xCE, 0x17, 0x21, 0x78, 0x8C, 0x89, 0x11, 0x2A, 0x18, 0xC9, 0x84, 0x58, + 0xB5, 0x8D, 0x96, 0x2A, 0xA7, 0xE8, 0xEB, 0x77, 0xAF, 0x9F, 0x8F, 0x67, + 0x82, 0xD0, 0xE1, 0x32, 0xF6, 0xFD, 0x70, 0xB3, 0x59, 0x17, 0x65, 0xF5, + 0x4F, 0xFF, 0xFE, 0x43, 0x55, 0x96, 0xEB, 0xBA, 0x00, 0x44, 0x88, 0x62, + 0x6D, 0xCC, 0x32, 0x5C, 0x9E, 0x9A, 0xBA, 0xF8, 0xED, 0xBB, 0x57, 0x52, + 0x49, 0x00, 0xD2, 0xB7, 0xEF, 0x5F, 0x59, 0x97, 0x86, 0x59, 0xA3, 0xE8, + 0xCA, 0xA2, 0xF8, 0xE3, 0x6F, 0xDE, 0x7F, 0xFB, 0xD5, 0xED, 0xEE, 0xF6, + 0x8F, 0xCA, 0xA6, 0xAA, 0xDB, 0x43, 0x56, 0x3C, 0x9F, 0xFA, 0xDD, 0xEE, + 0xAA, 0x60, 0x28, 0xAA, 0xD1, 0xC8, 0x21, 0x06, 0xFF, 0xD5, 0xCB, 0x6D, + 0x8A, 0x7E, 0xB5, 0xAE, 0x5F, 0xED, 0xB6, 0xD7, 0x9B, 0x75, 0x91, 0xE5, + 0x79, 0x96, 0xC5, 0x10, 0x31, 0x21, 0x65, 0xDD, 0xA5, 0x94, 0x8F, 0x8D, + 0x68, 0x52, 0x00, 0x00, 0x20, 0x00, 0x49, 0x44, 0x41, 0x54, 0x1D, 0x8E, + 0x63, 0x02, 0xE2, 0xD3, 0xE7, 0xFB, 0x61, 0x9A, 0xA6, 0x79, 0x3A, 0x9E, + 0x8F, 0x59, 0x5E, 0x70, 0x8A, 0x29, 0x23, 0x52, 0x19, 0x67, 0x1D, 0x25, + 0x18, 0x42, 0x34, 0xF4, 0xD3, 0xCD, 0x66, 0xE5, 0x9C, 0x03, 0x08, 0x69, + 0x6D, 0xC7, 0x71, 0xA1, 0x9C, 0xB4, 0x05, 0x1F, 0xC6, 0x79, 0x56, 0xEA, + 0xC5, 0xAE, 0x6B, 0xDB, 0xF2, 0x32, 0xC8, 0x61, 0x5E, 0xF6, 0xDB, 0xE6, + 0x66, 0xBF, 0xFA, 0xB5, 0xF6, 0x0C, 0x12, 0x08, 0x3E, 0x12, 0xC6, 0x7C, + 0x88, 0x45, 0xDD, 0x68, 0xE3, 0x87, 0x61, 0x0A, 0x21, 0x06, 0x17, 0x28, + 0xA1, 0x18, 0xE3, 0x61, 0x1C, 0x01, 0x88, 0x08, 0x41, 0xEF, 0x7D, 0x04, + 0xE1, 0x70, 0xEC, 0xC7, 0x59, 0x61, 0x82, 0xFA, 0x71, 0xC1, 0x18, 0x63, + 0x44, 0x17, 0x69, 0x2F, 0xFD, 0x8C, 0x30, 0xC6, 0x18, 0x49, 0xE3, 0x22, + 0x00, 0x21, 0x00, 0x67, 0xFC, 0x38, 0x29, 0x00, 0x90, 0xB3, 0x41, 0x64, + 0xE4, 0xEA, 0xBA, 0x0B, 0x20, 0x38, 0xE7, 0x29, 0x46, 0x84, 0x62, 0x9E, + 0x33, 0x84, 0x20, 0x80, 0x69, 0xB7, 0x5F, 0x97, 0x15, 0xCF, 0x2B, 0x61, + 0x4C, 0x2C, 0x4A, 0x4E, 0x70, 0x2A, 0x0A, 0xEA, 0xAC, 0x8B, 0x3E, 0x8E, + 0xBD, 0xEA, 0xCF, 0x8B, 0x54, 0xF6, 0xEE, 0xE1, 0xAC, 0xA5, 0xA5, 0x58, + 0x18, 0x99, 0x82, 0x4F, 0x97, 0x93, 0x54, 0x4B, 0x98, 0x67, 0xAD, 0x94, + 0x92, 0x4A, 0x5F, 0xFA, 0x19, 0xC0, 0x24, 0x32, 0x9C, 0x17, 0xE2, 0xC5, + 0xCB, 0xAD, 0xB1, 0x5E, 0x69, 0x33, 0x4E, 0x92, 0x51, 0x18, 0x9D, 0xE3, + 0x84, 0xF9, 0x10, 0x87, 0x45, 0x43, 0x80, 0xAA, 0xA2, 0x60, 0x14, 0x4D, + 0x4A, 0xF3, 0x0C, 0x12, 0x94, 0xD6, 0x6D, 0x3B, 0x2C, 0x8A, 0x53, 0x92, + 0x62, 0x98, 0x94, 0xAB, 0xAB, 0x82, 0x60, 0x44, 0x31, 0x1E, 0xA5, 0x6A, + 0xAB, 0x32, 0xCF, 0x18, 0x04, 0x89, 0x51, 0xC4, 0x48, 0xD2, 0xD6, 0x0B, + 0x86, 0x09, 0x01, 0x14, 0x13, 0xA3, 0xB5, 0x76, 0x6E, 0xDB, 0xE4, 0x85, + 0xA0, 0x9F, 0x9F, 0xCF, 0x04, 0x27, 0x0C, 0xC1, 0x2F, 0x9F, 0x07, 0x63, + 0x82, 0xD4, 0x49, 0xE9, 0xB8, 0x5D, 0x55, 0xFF, 0xF8, 0xFB, 0x37, 0x20, + 0x66, 0x54, 0x74, 0xF3, 0xA2, 0x86, 0xF1, 0x12, 0xBD, 0xB7, 0xCE, 0x9E, + 0xFB, 0xE1, 0xF1, 0x70, 0xEC, 0x9A, 0x4A, 0x50, 0xAE, 0x94, 0x4E, 0x09, + 0x4C, 0x8B, 0x9A, 0x66, 0xE9, 0x7D, 0x30, 0xC6, 0x11, 0x84, 0xEB, 0x22, + 0xCF, 0xB2, 0x5C, 0x29, 0x2B, 0xA5, 0x81, 0x00, 0xA6, 0x04, 0xA4, 0x34, + 0x18, 0xE2, 0xA6, 0x6C, 0x04, 0xA3, 0xF3, 0xA2, 0x94, 0xB2, 0x8B, 0xF2, + 0x31, 0x25, 0xEB, 0x42, 0x0C, 0x09, 0x43, 0xA8, 0xB4, 0x87, 0x88, 0x22, + 0xCC, 0xC6, 0x71, 0xBE, 0xF4, 0xF3, 0xB9, 0x9F, 0xC7, 0xC9, 0x40, 0x44, + 0xA4, 0xB6, 0xC3, 0xAC, 0x22, 0x04, 0x36, 0xF8, 0xC5, 0x78, 0x80, 0xD0, + 0xAC, 0xCD, 0x71, 0xD0, 0x93, 0xB4, 0x36, 0xB8, 0xC5, 0xE8, 0xCB, 0xAC, + 0x67, 0xE5, 0xA4, 0x76, 0xD6, 0x27, 0xE3, 0x62, 0x02, 0x29, 0x06, 0xAF, + 0x8C, 0xD6, 0xC6, 0x1A, 0x6D, 0x83, 0x75, 0xE7, 0x61, 0x9A, 0x95, 0x81, + 0x10, 0x27, 0x00, 0xAD, 0x8E, 0x87, 0xA7, 0xE7, 0x59, 0xCE, 0x88, 0x31, + 0x14, 0x5D, 0x95, 0xA1, 0xCB, 0xA0, 0x3F, 0x7C, 0x3E, 0x86, 0x18, 0x77, + 0x9B, 0x2E, 0x58, 0xD3, 0x16, 0x30, 0xE7, 0xAC, 0x6D, 0x37, 0x87, 0xCB, + 0xF2, 0x74, 0x3C, 0x1B, 0xA3, 0xF3, 0x9C, 0x01, 0x60, 0x19, 0x4D, 0x52, + 0x4E, 0xC1, 0xF5, 0xC6, 0x5E, 0xFA, 0x59, 0x6A, 0x6D, 0x29, 0xC6, 0x4A, + 0xEA, 0x0F, 0x1F, 0xEF, 0xBC, 0x4F, 0x8C, 0x88, 0x18, 0xD1, 0xE9, 0x3C, + 0x4C, 0xD2, 0x0C, 0x8B, 0xFE, 0x55, 0x29, 0x5A, 0xB4, 0x75, 0xC1, 0xE7, + 0x05, 0x9D, 0x46, 0xC9, 0x72, 0x0E, 0x10, 0x02, 0x10, 0x1A, 0x1B, 0x08, + 0x63, 0xDE, 0x04, 0xEB, 0x5C, 0x04, 0x51, 0x69, 0x5D, 0x70, 0x2E, 0x38, + 0xF2, 0xDE, 0x69, 0x63, 0x9A, 0xBA, 0x00, 0x29, 0x72, 0x26, 0xBC, 0xB5, + 0x31, 0x46, 0x9E, 0x17, 0xA2, 0xC8, 0x43, 0xF4, 0x52, 0x5B, 0xE7, 0x2C, + 0x21, 0x38, 0xCF, 0x39, 0x80, 0x11, 0x91, 0x90, 0x7C, 0x30, 0xCA, 0x68, + 0x2B, 0xB5, 0xD6, 0xD6, 0x79, 0xE7, 0x7C, 0x0C, 0xAE, 0xA9, 0x2B, 0x1F, + 0xE2, 0xAC, 0x54, 0x5D, 0x66, 0x37, 0xBB, 0xDD, 0x34, 0xCE, 0x7D, 0xDF, + 0xA7, 0x18, 0x8B, 0x2C, 0x5B, 0x16, 0x89, 0x09, 0x73, 0xDE, 0x8F, 0x52, + 0xD7, 0x65, 0x19, 0x9C, 0xC6, 0x45, 0x96, 0x69, 0x63, 0x19, 0x06, 0x94, + 0xE0, 0x59, 0xEA, 0x9B, 0x4D, 0xC3, 0x19, 0x7D, 0xEE, 0xC7, 0xDD, 0x7E, + 0xA7, 0x95, 0x5A, 0x96, 0x05, 0x00, 0xB0, 0x6B, 0x4B, 0x63, 0x3D, 0x48, + 0x80, 0x50, 0xC2, 0x19, 0xBD, 0x0C, 0x73, 0x55, 0x14, 0xAF, 0xAE, 0xD6, + 0xD6, 0x3B, 0x63, 0xDC, 0xD5, 0xAA, 0xAE, 0xAB, 0xC2, 0x07, 0x40, 0x09, + 0x2E, 0x73, 0x01, 0x93, 0xF7, 0xC1, 0x5B, 0x1F, 0xBC, 0xD6, 0x19, 0x67, + 0x65, 0x55, 0xBE, 0xBB, 0x7D, 0x6D, 0xAC, 0x4D, 0x29, 0x32, 0x8C, 0x6E, + 0xF6, 0x5B, 0x90, 0x60, 0x56, 0x30, 0x1C, 0xCD, 0xEF, 0xDE, 0xBF, 0xBE, + 0xD9, 0x77, 0xB3, 0xB1, 0x29, 0xF9, 0x08, 0xC0, 0x66, 0xB7, 0x72, 0x31, + 0xBD, 0x7D, 0xFF, 0x1A, 0xA6, 0xA4, 0x8C, 0x62, 0x14, 0x5B, 0xE3, 0x05, + 0x25, 0x8C, 0xA2, 0x97, 0xD7, 0xBB, 0x2C, 0x13, 0xA7, 0xCB, 0x25, 0x67, + 0xF8, 0xF5, 0x8B, 0xAB, 0x1F, 0x7E, 0x79, 0x38, 0x0F, 0xD3, 0xAF, 0xAF, + 0xDF, 0xAA, 0x2A, 0xFE, 0xF8, 0xED, 0x37, 0x77, 0x8F, 0x87, 0x18, 0xC1, + 0x1F, 0x7E, 0xFB, 0x9E, 0xE5, 0x4D, 0xD6, 0xBE, 0x8C, 0x31, 0x0C, 0xA7, + 0x2F, 0x02, 0x83, 0xD7, 0x37, 0x7B, 0x46, 0x49, 0x2E, 0xF8, 0xCB, 0x5D, + 0xF7, 0x78, 0x38, 0x3B, 0x54, 0x07, 0xE7, 0xDB, 0x8C, 0xFE, 0xE9, 0x77, + 0xDF, 0x76, 0x4D, 0xDB, 0xFB, 0xE2, 0xC3, 0xC3, 0x69, 0xE9, 0x8F, 0x34, + 0xE9, 0xF9, 0xF8, 0x85, 0x04, 0x79, 0xBB, 0x29, 0xB6, 0x5D, 0x96, 0x0B, + 0xF1, 0xE2, 0x6A, 0xFF, 0xF6, 0xC5, 0x55, 0x29, 0x48, 0xB7, 0xEA, 0x36, + 0x5D, 0x23, 0x08, 0xBC, 0x7F, 0xEE, 0x9F, 0xCF, 0xE3, 0xE3, 0xF1, 0xFC, + 0x70, 0x18, 0x7F, 0xF9, 0x7C, 0x30, 0xC6, 0x4D, 0xE3, 0x64, 0xB4, 0x3C, + 0x1E, 0x9F, 0x2F, 0x97, 0x13, 0x04, 0x61, 0xB7, 0xCA, 0x94, 0x01, 0x5C, + 0xE4, 0x55, 0xC1, 0x42, 0xF2, 0x52, 0x1A, 0x6B, 0xC3, 0x34, 0x49, 0x6F, + 0xC3, 0x76, 0xD5, 0xEC, 0x76, 0xDD, 0x0F, 0x1F, 0xEF, 0xCB, 0xBA, 0x02, + 0x08, 0x3E, 0x3F, 0x1C, 0xAB, 0x82, 0x16, 0x05, 0x5D, 0x96, 0xB9, 0xCC, + 0xB3, 0xBA, 0xCA, 0xA5, 0xB6, 0xFD, 0xA4, 0x08, 0x82, 0x28, 0x25, 0x65, + 0xFC, 0x65, 0x94, 0x2E, 0x04, 0x0C, 0xD1, 0x30, 0xCA, 0x79, 0x51, 0x08, + 0x13, 0x17, 0xD2, 0xE7, 0xCF, 0xF7, 0x8C, 0x12, 0x04, 0x91, 0xB3, 0x2E, + 0xCF, 0x85, 0x54, 0xF2, 0xBB, 0xEF, 0x3F, 0xCF, 0x8B, 0x36, 0xC6, 0x0E, + 0x93, 0x24, 0x8C, 0xF4, 0x93, 0xEE, 0x07, 0x69, 0x63, 0x78, 0x3C, 0xF6, + 0x82, 0x67, 0x52, 0x59, 0xE7, 0x02, 0x23, 0x98, 0x12, 0x9A, 0x71, 0xF1, + 0x7C, 0xEA, 0x8D, 0xF7, 0x2E, 0xF8, 0x69, 0x91, 0xCA, 0x58, 0x65, 0x34, + 0xE1, 0xE0, 0x7A, 0xD7, 0xCE, 0xFD, 0x62, 0x94, 0x9F, 0x46, 0xF5, 0xE5, + 0xD3, 0x51, 0x4B, 0x6B, 0x7D, 0x04, 0x18, 0x08, 0xC1, 0x18, 0x23, 0x5A, + 0x2B, 0x88, 0x40, 0x04, 0xE9, 0xF4, 0x7C, 0x64, 0x0C, 0xC5, 0x18, 0x09, + 0x25, 0xD3, 0xB8, 0xCC, 0x4B, 0x50, 0xD6, 0xF5, 0xFD, 0x7C, 0xE9, 0xD5, + 0x38, 0x5B, 0x86, 0xD8, 0x22, 0xFD, 0x38, 0x4B, 0x84, 0xD0, 0xE3, 0xE3, + 0x39, 0x26, 0xD8, 0xF7, 0xFD, 0x24, 0xED, 0x22, 0xED, 0x79, 0x98, 0xAD, + 0xF5, 0xC3, 0xB8, 0x38, 0x6B, 0xDB, 0x75, 0xB3, 0xDD, 0xB5, 0x55, 0x29, + 0x72, 0x8E, 0xBD, 0x4D, 0x94, 0xB2, 0x04, 0xD2, 0xB4, 0x68, 0x84, 0x49, + 0xB0, 0x3A, 0x17, 0x62, 0xB2, 0xEE, 0x3C, 0x4D, 0x4D, 0x9E, 0x95, 0x45, + 0x09, 0x11, 0x98, 0xA5, 0x2B, 0x04, 0x45, 0x18, 0x6E, 0xB7, 0xDD, 0xED, + 0xD5, 0x4A, 0x7B, 0xD0, 0xB5, 0x45, 0x55, 0x08, 0x4C, 0x61, 0x9E, 0x27, + 0x8C, 0x93, 0xB7, 0x1E, 0x82, 0x18, 0x93, 0x4B, 0x29, 0x9D, 0x27, 0xD9, + 0x95, 0xD9, 0x4D, 0x57, 0x41, 0x00, 0x16, 0xAD, 0x8C, 0xB3, 0x5D, 0x53, + 0xBE, 0x7F, 0xBD, 0xCF, 0x04, 0xDD, 0xAE, 0xAA, 0x17, 0xFB, 0xCA, 0x38, + 0xB7, 0xEB, 0xDA, 0x8C, 0x94, 0xC7, 0x8B, 0xEE, 0xC7, 0xF9, 0xE3, 0x97, + 0xCF, 0xF3, 0xB2, 0x68, 0xAD, 0xFB, 0x71, 0xB4, 0xD6, 0xDB, 0x10, 0xCA, + 0x3C, 0xEF, 0x87, 0x59, 0x1B, 0x15, 0x13, 0xD0, 0xD6, 0xDB, 0x5F, 0x8F, + 0x10, 0x42, 0x30, 0x81, 0xAA, 0xA8, 0xCA, 0x22, 0x7F, 0x78, 0x3A, 0x40, + 0xCC, 0xBC, 0x0F, 0x97, 0x7E, 0xC6, 0x18, 0x07, 0xEB, 0x62, 0x08, 0x79, + 0x59, 0x14, 0x65, 0x1E, 0x43, 0x98, 0x66, 0x29, 0x04, 0x9B, 0x16, 0x07, + 0x01, 0x30, 0xD6, 0x73, 0x91, 0x43, 0x88, 0x97, 0x45, 0x2A, 0x6D, 0x21, + 0x80, 0x2E, 0x00, 0x1F, 0x13, 0xC2, 0xD8, 0x86, 0xA8, 0xAD, 0x23, 0x18, + 0x86, 0x00, 0x7C, 0x00, 0xB3, 0xB2, 0xF3, 0x6C, 0x43, 0x04, 0x79, 0x96, + 0x85, 0x98, 0x8C, 0x09, 0x3E, 0x04, 0xCE, 0x31, 0x44, 0x58, 0x6A, 0xF7, + 0xAB, 0x99, 0x26, 0xB5, 0x8A, 0x20, 0x58, 0x1B, 0xAD, 0x72, 0x52, 0x1B, + 0xEB, 0x63, 0x3F, 0x48, 0x17, 0xD2, 0x3C, 0x6B, 0x1F, 0x22, 0x65, 0x54, + 0x2A, 0xAB, 0x17, 0x59, 0x09, 0x9E, 0x65, 0xE4, 0xD4, 0x0F, 0xD6, 0xB9, + 0x97, 0xDB, 0x1A, 0x01, 0xCF, 0x19, 0xE0, 0x18, 0x52, 0x96, 0x7F, 0x79, + 0x7A, 0x32, 0x6E, 0xC1, 0x30, 0x6C, 0x57, 0x19, 0x22, 0x7E, 0x5C, 0x06, + 0xEF, 0x4D, 0x3F, 0x5F, 0x9A, 0x92, 0x1C, 0xCF, 0xF3, 0x69, 0xB4, 0x21, + 0x44, 0x2D, 0xCD, 0xE1, 0x78, 0x01, 0x90, 0xBC, 0x7F, 0xFF, 0xBB, 0xBC, + 0xA8, 0x94, 0x52, 0xD3, 0x34, 0x69, 0xE3, 0x66, 0x65, 0xC6, 0x79, 0xAC, + 0xAA, 0xC2, 0x3B, 0xBD, 0x5A, 0x15, 0x6D, 0xC3, 0x39, 0xC3, 0xCA, 0xD8, + 0x14, 0xD3, 0x30, 0x2E, 0x45, 0x21, 0x78, 0x9E, 0xA9, 0x45, 0x2B, 0x65, + 0x28, 0xC7, 0x9C, 0x65, 0x21, 0x60, 0x6D, 0x62, 0x3F, 0x4D, 0x21, 0x86, + 0x10, 0xE2, 0x30, 0xCF, 0xCA, 0x8C, 0x18, 0xA9, 0x8C, 0xC7, 0xD3, 0x68, + 0x20, 0x82, 0xE3, 0x38, 0x58, 0x6B, 0x86, 0x79, 0xFE, 0xF9, 0xD3, 0x43, + 0x4A, 0xE9, 0xF1, 0x70, 0x7A, 0x78, 0x38, 0x14, 0x79, 0xB1, 0xDE, 0x6E, + 0x42, 0x70, 0x5D, 0xDB, 0x32, 0x4A, 0x67, 0xA5, 0x2F, 0xC3, 0x98, 0x42, + 0xB4, 0xCE, 0x01, 0x08, 0xEB, 0xAA, 0x14, 0x94, 0x65, 0x02, 0x21, 0xE0, + 0x04, 0x25, 0x4D, 0x51, 0x2A, 0x6D, 0xAC, 0xB1, 0xFD, 0x30, 0x66, 0x42, + 0x14, 0x99, 0x98, 0xE7, 0x09, 0xC7, 0x98, 0x10, 0x4C, 0x7F, 0xF8, 0xFA, + 0xED, 0x22, 0xCD, 0xAB, 0xEB, 0xDD, 0x8B, 0xFD, 0x2A, 0x84, 0xB8, 0x6A, + 0x2B, 0xA9, 0x35, 0x67, 0xAC, 0x10, 0xEC, 0xD5, 0x6E, 0xF5, 0x78, 0xEC, + 0x21, 0x84, 0x18, 0x23, 0x0C, 0x20, 0xA7, 0x44, 0x19, 0xFB, 0x9B, 0xB7, + 0x2F, 0x85, 0x60, 0xE3, 0xA8, 0xDA, 0x22, 0x23, 0x30, 0x09, 0xC6, 0xE6, + 0x59, 0x5F, 0x5F, 0x5F, 0x33, 0x46, 0x43, 0x0C, 0x52, 0x4B, 0x02, 0x11, + 0x67, 0xE4, 0xF1, 0x3C, 0xDD, 0xBE, 0x7C, 0xD5, 0xB5, 0x45, 0x70, 0xCA, + 0xAB, 0x69, 0xB7, 0x2E, 0x0B, 0xC1, 0x5E, 0x5E, 0xD5, 0x9B, 0x36, 0xFB, + 0xF3, 0xEF, 0x5F, 0x7F, 0xF3, 0xD5, 0xCE, 0xF8, 0x90, 0x67, 0x7C, 0x53, + 0x67, 0xB7, 0x2F, 0xBA, 0x22, 0x67, 0x57, 0xFB, 0x8E, 0x12, 0xDA, 0x8F, + 0x93, 0xB3, 0x36, 0xB9, 0x14, 0x13, 0xA2, 0x18, 0xDF, 0xBE, 0xD8, 0x63, + 0x04, 0x7F, 0xF9, 0xFC, 0x90, 0x0B, 0xBE, 0x5F, 0xD5, 0xA3, 0x4D, 0x01, + 0x17, 0xA7, 0xD3, 0xE9, 0x7A, 0xD7, 0xFD, 0xE6, 0xDD, 0xAB, 0xDB, 0xDB, + 0xD7, 0x37, 0x37, 0x57, 0xB9, 0x60, 0xEB, 0xF5, 0x26, 0x22, 0x72, 0x75, + 0xFB, 0xBB, 0xEF, 0xBF, 0xFF, 0x1E, 0x27, 0xFD, 0xFA, 0xAA, 0x60, 0x98, + 0x9C, 0x4E, 0x17, 0x82, 0x51, 0x5B, 0x95, 0xFB, 0x6D, 0x33, 0xF4, 0xD3, + 0xD5, 0xFE, 0x6A, 0xD3, 0x35, 0xB7, 0x37, 0xDB, 0x2F, 0x0F, 0x87, 0xE7, + 0x09, 0xFC, 0xD3, 0xBF, 0xFE, 0x6B, 0x16, 0xC7, 0x4D, 0x9B, 0x3B, 0x35, + 0x55, 0x19, 0xD3, 0xDA, 0xF8, 0x18, 0x3E, 0x7E, 0xFE, 0xAC, 0xF4, 0xA4, + 0xE4, 0x72, 0x3C, 0x1E, 0x87, 0xC5, 0xE1, 0x72, 0x6F, 0x03, 0xB4, 0xC6, + 0x00, 0xE0, 0x18, 0xC3, 0x3E, 0x38, 0xCE, 0x59, 0x4C, 0x69, 0x91, 0xF6, + 0x3C, 0xF4, 0x4A, 0x9B, 0x4B, 0x7F, 0x99, 0xE5, 0x52, 0x66, 0x74, 0xD5, + 0x75, 0xDA, 0x03, 0x08, 0x92, 0x33, 0x6A, 0xE8, 0x67, 0xC2, 0x48, 0x80, + 0xE9, 0xCD, 0xCD, 0xCE, 0xB9, 0xF0, 0xFB, 0x6F, 0xDE, 0x7C, 0xBA, 0x3F, + 0x5C, 0xFA, 0x11, 0x81, 0x88, 0x10, 0x14, 0x19, 0xA5, 0x30, 0x39, 0x1F, + 0x01, 0x22, 0x9C, 0x32, 0xA5, 0x7D, 0x4C, 0x70, 0xD5, 0x16, 0x20, 0xC5, + 0x0F, 0x5F, 0x8E, 0x21, 0x22, 0x42, 0xC9, 0xE1, 0xD8, 0x8B, 0x2C, 0x4F, + 0x29, 0x26, 0x00, 0x11, 0x45, 0xA7, 0xF3, 0xB1, 0xCE, 0x05, 0xE7, 0x84, + 0x70, 0x56, 0xE5, 0x85, 0x36, 0xE6, 0x32, 0xF5, 0x5D, 0xD7, 0x12, 0x82, + 0x2F, 0xC3, 0x32, 0xCE, 0x66, 0x9A, 0xCD, 0xB8, 0xE8, 0xB2, 0xC8, 0x29, + 0x85, 0xE7, 0x49, 0x62, 0x84, 0x28, 0xC5, 0x5A, 0x69, 0xE7, 0xA2, 0xF1, + 0x61, 0xD1, 0xD6, 0x58, 0x27, 0x38, 0x9E, 0x17, 0x79, 0xBA, 0x4C, 0x94, + 0xD3, 0xCD, 0xB6, 0xBA, 0xDA, 0x75, 0x6A, 0x76, 0x9F, 0x3E, 0x5F, 0x04, + 0xE7, 0xB3, 0x54, 0xC7, 0xCB, 0xC2, 0x18, 0xBD, 0x9C, 0x67, 0x6B, 0xB4, + 0x71, 0xE1, 0x74, 0x9C, 0xBE, 0xFC, 0xFC, 0xAC, 0x95, 0x95, 0x8B, 0x3A, + 0x9E, 0xE6, 0x94, 0xC0, 0x78, 0x91, 0x6A, 0x36, 0xCE, 0x79, 0x65, 0x82, + 0x76, 0xE1, 0xD2, 0xCF, 0x5C, 0xF0, 0x3C, 0x2F, 0xAF, 0x36, 0x1B, 0x63, + 0x4D, 0x82, 0x78, 0x96, 0x2A, 0x21, 0x46, 0x08, 0x24, 0x04, 0x01, 0x44, + 0x7C, 0x4A, 0x5A, 0x6A, 0xCA, 0x68, 0x82, 0x40, 0x2E, 0xCA, 0x1A, 0xE7, + 0x7D, 0x2C, 0xCB, 0x3C, 0x17, 0x99, 0x73, 0x41, 0x69, 0x29, 0x04, 0xCB, + 0x05, 0x79, 0xB1, 0xEB, 0x62, 0x8A, 0x9C, 0x65, 0xC7, 0xCB, 0x50, 0x67, + 0xE2, 0x66, 0xB3, 0x6A, 0x9A, 0x72, 0x9E, 0x66, 0x02, 0xE0, 0x76, 0xD5, + 0x0C, 0xB3, 0xBA, 0xD9, 0xAC, 0x10, 0xC4, 0x3E, 0x31, 0x2E, 0xA8, 0x94, + 0xB2, 0x2A, 0xF3, 0x42, 0xA0, 0xF3, 0xA5, 0xE7, 0x59, 0x9E, 0xF1, 0x44, + 0x38, 0x26, 0x8C, 0x73, 0xC6, 0xDF, 0xBC, 0xD8, 0x5C, 0x5D, 0xAD, 0x6E, + 0x6E, 0x6E, 0xAE, 0xAF, 0xF6, 0xD7, 0xBB, 0xD5, 0xBB, 0xD7, 0xAF, 0xDA, + 0xA6, 0xBA, 0xDA, 0xAD, 0x5E, 0xBC, 0xBA, 0xAE, 0xDB, 0xFA, 0xAB, 0xF7, + 0x2F, 0xBB, 0xB6, 0x9B, 0xA4, 0xF5, 0xC1, 0x6B, 0xAB, 0x94, 0xD2, 0x6F, + 0x5F, 0xBD, 0x20, 0x18, 0x10, 0x14, 0x67, 0x29, 0x6D, 0x08, 0xDA, 0x58, + 0x65, 0x0C, 0xC5, 0xA0, 0xC8, 0x32, 0x6D, 0x9C, 0xF5, 0x5E, 0x88, 0x7C, + 0x59, 0x24, 0xC6, 0x68, 0x5A, 0xE4, 0xE3, 0xE1, 0x59, 0x1A, 0x57, 0x35, + 0x6B, 0xC1, 0x88, 0xB7, 0xF6, 0x7A, 0xB7, 0x2E, 0x84, 0x68, 0xDB, 0xBC, + 0x29, 0xF3, 0x5D, 0xDB, 0x6C, 0xBB, 0x6A, 0xDD, 0xE6, 0x2F, 0xAF, 0xB6, + 0x75, 0xCE, 0x95, 0xB2, 0x79, 0x9E, 0x25, 0x88, 0xCE, 0xE7, 0x01, 0x42, + 0x40, 0x08, 0x46, 0x00, 0x24, 0x08, 0x7D, 0x88, 0x18, 0x21, 0x82, 0x51, + 0x59, 0x70, 0x4A, 0x90, 0x92, 0x8E, 0x53, 0x6C, 0x5C, 0x24, 0x94, 0x95, + 0x79, 0xB6, 0x2C, 0xCA, 0x5A, 0x0F, 0x21, 0xF2, 0x21, 0x42, 0x84, 0x9D, + 0x07, 0x09, 0x80, 0x77, 0x37, 0xDD, 0xC3, 0x61, 0x40, 0x98, 0x94, 0x9C, + 0x30, 0x0C, 0x46, 0x69, 0x74, 0x0C, 0x88, 0x20, 0x98, 0x20, 0x15, 0x6C, + 0x5A, 0x94, 0x75, 0x8E, 0x72, 0xE6, 0xA4, 0x2E, 0x38, 0x45, 0x10, 0x1D, + 0xCF, 0x3D, 0x13, 0x6C, 0x5D, 0x12, 0xEF, 0xAC, 0x73, 0x9E, 0x13, 0x2C, + 0x18, 0xA5, 0x82, 0x5A, 0xAF, 0x9C, 0x0D, 0x6D, 0x27, 0x8C, 0xF3, 0xDA, + 0xB8, 0x3A, 0x17, 0x1C, 0xA6, 0x4D, 0x93, 0x1F, 0x2F, 0xF3, 0xE3, 0xC5, + 0xF8, 0x08, 0xCE, 0x97, 0x45, 0x4A, 0xD3, 0x36, 0xF5, 0xBB, 0x77, 0xBF, + 0xDB, 0xAC, 0xB6, 0xE3, 0x70, 0x19, 0xA7, 0x29, 0x46, 0xB3, 0xDA, 0xD6, + 0x84, 0x20, 0xC1, 0x38, 0xC1, 0x00, 0xA4, 0x50, 0x70, 0x1A, 0x8C, 0xC7, + 0x0C, 0x47, 0x90, 0xBC, 0x8F, 0xAB, 0x55, 0x4B, 0x10, 0x31, 0x52, 0x59, + 0xE3, 0xD5, 0xAC, 0x53, 0x48, 0x08, 0x11, 0x6B, 0x62, 0x3F, 0x19, 0xE7, + 0xC3, 0x38, 0x8C, 0x08, 0x13, 0x65, 0x9D, 0x75, 0xE3, 0x65, 0x98, 0x13, + 0x00, 0x8B, 0xD4, 0x87, 0xD3, 0xD9, 0x58, 0x67, 0x7D, 0x78, 0x78, 0x3E, + 0x46, 0x88, 0x28, 0xA5, 0xF3, 0xBC, 0x18, 0xEB, 0x09, 0xA5, 0x88, 0x33, + 0x9E, 0x67, 0x6D, 0xC3, 0x23, 0x4A, 0x59, 0x8E, 0x76, 0x9B, 0x7C, 0xD5, + 0x55, 0x94, 0x91, 0x90, 0x20, 0x48, 0x80, 0x42, 0x2F, 0x08, 0x0A, 0xCE, + 0xFA, 0x10, 0xCA, 0x8C, 0x3F, 0x9F, 0x7B, 0x84, 0x50, 0x5B, 0x96, 0x10, + 0x41, 0xA5, 0xAD, 0x75, 0x0E, 0x0B, 0x8E, 0x5E, 0xED, 0xD6, 0xBB, 0x55, + 0x8B, 0x41, 0xFA, 0xFB, 0x3F, 0xFE, 0xD6, 0x58, 0xB7, 0x5A, 0xD5, 0x8B, + 0x31, 0x30, 0x86, 0xAE, 0x2A, 0xAA, 0x8C, 0x2C, 0x8B, 0xF2, 0x21, 0x31, + 0xC6, 0x0F, 0xE7, 0x61, 0xB7, 0x5B, 0xED, 0xB6, 0xEB, 0x75, 0x53, 0x57, + 0x79, 0x16, 0x62, 0xF4, 0x3E, 0x54, 0x05, 0x83, 0x88, 0xBC, 0x7F, 0xF7, + 0x55, 0xDD, 0x75, 0x55, 0x55, 0xA5, 0x94, 0xA6, 0x69, 0xA4, 0x84, 0xD6, + 0x55, 0x4E, 0x08, 0xDE, 0x74, 0xC5, 0xDF, 0xFC, 0xF6, 0x65, 0x5B, 0xD2, + 0x8C, 0x82, 0xBA, 0xE4, 0xAF, 0xAE, 0x1B, 0x90, 0x82, 0xD4, 0x6E, 0xE8, + 0x07, 0x63, 0xE2, 0xB0, 0xB8, 0xA3, 0x2C, 0x71, 0xB0, 0x94, 0x44, 0x82, + 0xD1, 0xA6, 0xCD, 0xBA, 0x4A, 0x34, 0x39, 0xAB, 0x0B, 0xDE, 0x14, 0xE2, + 0x7A, 0xDB, 0x6C, 0x56, 0xC5, 0xDB, 0x57, 0x9B, 0x6D, 0x57, 0x9F, 0x8F, + 0x97, 0x52, 0xF0, 0x57, 0xD7, 0xFB, 0x08, 0xB1, 0xB1, 0xAE, 0xDB, 0xBC, + 0xA8, 0x32, 0x7A, 0xBD, 0xBB, 0xE2, 0x3C, 0xFF, 0xFD, 0x6F, 0xDE, 0x20, + 0x94, 0xAA, 0xB2, 0xBC, 0x4C, 0x52, 0xB4, 0xAF, 0xFE, 0xF2, 0xCF, 0xFF, + 0x0D, 0xBA, 0xD3, 0xEF, 0xBE, 0xDA, 0x62, 0x0E, 0x30, 0xC1, 0x5D, 0x5B, + 0x8A, 0x8C, 0x6C, 0xDA, 0xB2, 0xA9, 0x8B, 0xAB, 0xDD, 0x2A, 0x81, 0x98, + 0x97, 0x1D, 0x01, 0x7E, 0xD6, 0xFE, 0xBC, 0xB8, 0x1C, 0xBB, 0x55, 0x5D, + 0xCC, 0x72, 0xD1, 0xC6, 0x0E, 0xD3, 0x0C, 0x31, 0x94, 0x52, 0xBA, 0xE0, + 0x2E, 0xE3, 0xBC, 0x68, 0xA5, 0x3C, 0x2A, 0xF7, 0xBF, 0xB9, 0x4C, 0xCB, + 0x77, 0xFF, 0xFE, 0xAF, 0xF3, 0x3C, 0xC4, 0x14, 0xB5, 0x31, 0x94, 0x53, + 0x91, 0xB1, 0xCD, 0xBA, 0xC2, 0x31, 0x0A, 0x46, 0xCF, 0xE3, 0x62, 0xAD, + 0xDE, 0x6D, 0x6B, 0xED, 0x3C, 0xC2, 0xE4, 0x70, 0x38, 0xED, 0xBA, 0x0C, + 0x42, 0x8C, 0x20, 0xA8, 0x72, 0x4E, 0x00, 0x68, 0x0B, 0xE1, 0x7C, 0xF8, + 0xED, 0xFB, 0xDB, 0xBF, 0xFC, 0xC7, 0x4F, 0x4D, 0x5B, 0x31, 0x42, 0xA4, + 0x52, 0x75, 0xDB, 0x9C, 0x8E, 0x03, 0x4C, 0x89, 0x60, 0x8A, 0x11, 0xB4, + 0x21, 0x3A, 0x6B, 0x9D, 0xF7, 0x52, 0x59, 0x6B, 0x7D, 0x04, 0x30, 0x46, + 0x68, 0x8C, 0xB6, 0x2E, 0x71, 0x46, 0xB3, 0x2C, 0xB3, 0xCE, 0x18, 0xA5, + 0x8A, 0x8C, 0xF2, 0x8C, 0x81, 0x08, 0x33, 0x41, 0x4E, 0x97, 0xCB, 0xB4, + 0xA8, 0xDD, 0xA6, 0x95, 0x4A, 0x2F, 0xDA, 0x66, 0x19, 0x5F, 0x16, 0xFD, + 0x87, 0x6F, 0x6E, 0x8B, 0x9C, 0xB7, 0x25, 0x52, 0xC6, 0x39, 0x17, 0x38, + 0xA3, 0xA7, 0xCB, 0x88, 0x30, 0x4A, 0x10, 0x9D, 0x87, 0xB1, 0xA9, 0xC4, + 0x9B, 0xD7, 0x7B, 0x42, 0x71, 0x59, 0xB0, 0x97, 0x37, 0x1D, 0xC3, 0xA8, + 0x2A, 0xF2, 0xC7, 0xC7, 0x49, 0x08, 0xE1, 0xBC, 0xFF, 0xE5, 0xCB, 0x61, + 0xBF, 0x6F, 0x7E, 0xFB, 0xCD, 0x2B, 0x6D, 0x9D, 0x5C, 0x8C, 0x0F, 0x41, + 0x4B, 0x87, 0x08, 0x39, 0x9D, 0x67, 0x6B, 0x7D, 0x08, 0x41, 0x2D, 0xCE, + 0xBA, 0xE8, 0x7C, 0x02, 0x10, 0x4D, 0xB3, 0x51, 0xDA, 0x2A, 0xE3, 0x09, + 0xE5, 0xB9, 0xC8, 0x96, 0x65, 0x11, 0x9C, 0x34, 0x55, 0x75, 0xF7, 0xF8, + 0xE4, 0xBC, 0xA7, 0x08, 0x3B, 0x0F, 0xA4, 0xD4, 0x31, 0x06, 0xA3, 0x5D, + 0x0C, 0x11, 0x81, 0x84, 0x10, 0x9C, 0x66, 0x5D, 0xE4, 0x42, 0x2D, 0x32, + 0x85, 0x54, 0xE5, 0xE2, 0x66, 0xBF, 0xDE, 0x6F, 0xDA, 0xA6, 0xE0, 0x39, + 0xA3, 0x45, 0x91, 0x21, 0x80, 0x36, 0x75, 0xBE, 0x6E, 0x72, 0x91, 0x57, + 0x3E, 0x84, 0xFE, 0x72, 0x21, 0x18, 0x52, 0x4E, 0xCB, 0x9C, 0x0C, 0x93, + 0xB2, 0x2E, 0x06, 0xBB, 0x2C, 0x8B, 0xD9, 0x74, 0x75, 0xF4, 0xCE, 0x28, + 0x05, 0x10, 0x8F, 0x21, 0x25, 0x98, 0x6C, 0x48, 0xEF, 0x5F, 0xBF, 0xB8, + 0xD9, 0x75, 0xEB, 0xAE, 0x6B, 0x9B, 0x2E, 0x02, 0xA6, 0x74, 0x48, 0x09, + 0x2A, 0x65, 0x3F, 0x7D, 0x79, 0x7E, 0x7C, 0xEE, 0xCF, 0x97, 0xC9, 0x85, + 0xD0, 0x0F, 0x1A, 0x51, 0x26, 0x72, 0xD1, 0xB5, 0xC5, 0xBA, 0x2D, 0x5E, + 0xBD, 0x58, 0xEF, 0xB7, 0xCD, 0x7E, 0xDB, 0x5E, 0x6D, 0x5B, 0x84, 0x31, + 0x48, 0xA9, 0xA9, 0x8A, 0x4C, 0x08, 0x0C, 0x20, 0x4C, 0xE9, 0x38, 0x4C, + 0x00, 0x00, 0xCE, 0xD8, 0x76, 0xDD, 0xF4, 0xFD, 0xB0, 0xDB, 0x6E, 0x12, + 0x44, 0x00, 0x80, 0x14, 0xE3, 0xEB, 0xAB, 0x6D, 0x5B, 0x15, 0x18, 0xC0, + 0x10, 0xA2, 0xD6, 0x4E, 0xA9, 0xE5, 0x3C, 0x0C, 0xC6, 0x5A, 0x04, 0x71, + 0x59, 0xE7, 0x37, 0x9B, 0xD5, 0xCD, 0xBE, 0xDB, 0x6D, 0xCA, 0xBB, 0x87, + 0x93, 0xB6, 0xBE, 0x2C, 0xB3, 0x14, 0x03, 0x84, 0xBF, 0xCE, 0x7C, 0xE0, + 0xB2, 0xE4, 0x52, 0xDB, 0xAE, 0xC9, 0x82, 0x8F, 0x29, 0xA6, 0x97, 0xFB, + 0xCD, 0x8B, 0xDD, 0xAA, 0x6B, 0x8A, 0x65, 0x96, 0xC6, 0xD8, 0x32, 0x17, + 0xDA, 0xF8, 0x08, 0x00, 0x44, 0x54, 0x4A, 0x95, 0x09, 0x66, 0xB4, 0x9D, + 0xA4, 0xA2, 0x18, 0x76, 0x35, 0xBB, 0xF4, 0x32, 0x02, 0x50, 0xD5, 0x42, + 0x64, 0x59, 0x5E, 0x30, 0x8C, 0x52, 0xB3, 0xAA, 0xAA, 0xB6, 0x32, 0xCE, + 0x95, 0x8C, 0x7A, 0x6B, 0x16, 0xA5, 0x13, 0x44, 0x29, 0xF9, 0xCB, 0x30, + 0x65, 0x9C, 0xB5, 0x55, 0x4E, 0x18, 0x66, 0xA2, 0x8A, 0xC9, 0x39, 0xE7, + 0x52, 0x02, 0xCF, 0xBD, 0x26, 0x18, 0x39, 0xA7, 0xF3, 0x9C, 0x57, 0x25, + 0x3F, 0xF7, 0x6A, 0x98, 0x97, 0x75, 0x57, 0x94, 0x9C, 0xB6, 0x55, 0x76, + 0xBD, 0xA9, 0x36, 0xAB, 0x1B, 0x42, 0x8B, 0xC3, 0xD3, 0xC3, 0xE9, 0x74, + 0x80, 0x28, 0xEE, 0xF7, 0x5D, 0x96, 0x21, 0xC1, 0x08, 0x63, 0x2C, 0xC6, + 0xB8, 0x48, 0x15, 0x7D, 0x2C, 0xB3, 0xFC, 0x3C, 0x4C, 0x4A, 0xDB, 0xFD, + 0x6E, 0x93, 0x53, 0xF6, 0xE5, 0xEE, 0xC0, 0x19, 0x95, 0x8B, 0xCE, 0x72, + 0x16, 0x22, 0x42, 0x00, 0xA6, 0x14, 0xAC, 0x8B, 0x8C, 0xB3, 0x32, 0xE7, + 0x65, 0x91, 0x7B, 0x6F, 0xBC, 0x4B, 0xFD, 0x1C, 0xAC, 0x4F, 0x82, 0xE1, + 0xE3, 0x65, 0x9C, 0x16, 0x67, 0x8C, 0xAD, 0xCA, 0xF2, 0xFD, 0xED, 0x6B, + 0x65, 0xA4, 0x35, 0x36, 0xF8, 0x24, 0x44, 0xF6, 0xF0, 0x74, 0xB0, 0x56, + 0x69, 0xAD, 0x7E, 0xFE, 0xFC, 0x04, 0x49, 0xA4, 0x8C, 0x23, 0xC6, 0x78, + 0x86, 0x6F, 0x6E, 0x36, 0x55, 0x41, 0x2B, 0x81, 0x42, 0xD4, 0x75, 0x9E, + 0xDD, 0x5C, 0xBD, 0x8E, 0xC1, 0x4F, 0x8B, 0x7C, 0xFF, 0xF6, 0x4D, 0x4A, + 0x69, 0x59, 0x96, 0xEB, 0xEB, 0xEB, 0xF5, 0x7A, 0x8D, 0xFF, 0xF3, 0xFF, + 0xF4, 0xDF, 0xD5, 0x4D, 0x6B, 0xE5, 0xF2, 0xE7, 0xDF, 0x7F, 0x2D, 0xB5, + 0xB7, 0x4A, 0x41, 0x8C, 0x42, 0x4C, 0xEF, 0xDE, 0xBC, 0xCC, 0x8B, 0xC2, + 0x58, 0x67, 0x6C, 0xA8, 0x9A, 0x35, 0xC6, 0x69, 0xBB, 0x6D, 0xAF, 0xAE, + 0x77, 0xEB, 0x75, 0x55, 0x08, 0x86, 0x30, 0x70, 0x3E, 0x36, 0x55, 0xD1, + 0xD4, 0xCD, 0xD5, 0xFE, 0x7A, 0xB7, 0xDF, 0x5B, 0xEB, 0x11, 0x4C, 0xCE, + 0x48, 0x6B, 0x34, 0xA6, 0xF8, 0x9B, 0xDB, 0x9B, 0xD7, 0x57, 0xDD, 0xCB, + 0x6D, 0x63, 0x94, 0x1A, 0xC6, 0x45, 0x29, 0x7B, 0x38, 0x8D, 0x77, 0x8F, + 0xE7, 0x2F, 0xCF, 0xFA, 0xC3, 0xA7, 0xC3, 0xC3, 0xD3, 0x30, 0x8C, 0x6A, + 0xD6, 0x54, 0x86, 0xEC, 0x72, 0xB8, 0xAF, 0x72, 0x34, 0xCC, 0xEA, 0xF9, + 0x38, 0xDC, 0xDD, 0x1F, 0x62, 0xF2, 0x59, 0x4E, 0x0A, 0xC1, 0xD6, 0x6D, + 0xB1, 0xDD, 0xE4, 0x8C, 0x41, 0xC1, 0xF0, 0x66, 0xDD, 0xEC, 0x37, 0x55, + 0x80, 0xE4, 0xD3, 0xF3, 0x12, 0xCC, 0x42, 0x79, 0x86, 0x28, 0x73, 0xEA, + 0x12, 0x23, 0x5A, 0xB5, 0x19, 0xF4, 0xCA, 0x3A, 0xF0, 0x34, 0xC2, 0xC7, + 0xC3, 0x29, 0x03, 0xCB, 0xFF, 0xFC, 0x3F, 0xFE, 0xED, 0xB1, 0x3F, 0x9F, + 0x2F, 0x17, 0x88, 0x00, 0x00, 0xC1, 0x04, 0x47, 0x19, 0x76, 0xC6, 0xCE, + 0x52, 0x51, 0x82, 0x54, 0x10, 0xFF, 0xFE, 0xE3, 0xA7, 0x41, 0xBA, 0x4F, + 0x5F, 0x3E, 0x6F, 0xEA, 0xE2, 0x78, 0x3E, 0x73, 0x46, 0xBD, 0x8F, 0xA7, + 0x7E, 0x18, 0xE7, 0x65, 0x96, 0xEA, 0xE3, 0xDD, 0xA9, 0x6B, 0xBB, 0x5C, + 0xD0, 0xC8, 0x57, 0x93, 0x5C, 0x86, 0xD3, 0x5D, 0x5E, 0x55, 0x56, 0x1B, + 0x6B, 0xF5, 0xDD, 0xF3, 0x39, 0x21, 0x78, 0x3E, 0x0F, 0x46, 0x9B, 0x4D, + 0x57, 0x63, 0x08, 0x8D, 0x31, 0xE3, 0xB2, 0x6C, 0x56, 0x15, 0x84, 0xF0, + 0x7C, 0x3A, 0x0F, 0xD3, 0x54, 0x64, 0xD9, 0xC7, 0xBB, 0xA7, 0x17, 0xBB, + 0x4E, 0x6B, 0xFB, 0xA7, 0x6F, 0x5E, 0xFF, 0xDB, 0x0F, 0x9F, 0x6E, 0xF6, + 0x3B, 0x4C, 0xF9, 0x7F, 0xFC, 0xF0, 0xB1, 0xCC, 0x45, 0x8C, 0x81, 0x63, + 0x02, 0x40, 0xB2, 0xCE, 0xBD, 0xB9, 0xDA, 0x4D, 0xB3, 0xDC, 0x74, 0x35, + 0x04, 0x50, 0x70, 0x11, 0x00, 0x98, 0x66, 0x45, 0x08, 0x09, 0x31, 0x40, + 0x08, 0x08, 0xC5, 0x8B, 0x94, 0x9B, 0xF5, 0x6A, 0x51, 0xCA, 0x39, 0xDB, + 0x36, 0x65, 0x59, 0x08, 0x6D, 0x1C, 0x86, 0x48, 0x1A, 0x93, 0x40, 0xCA, + 0x58, 0xE6, 0xAC, 0x1B, 0x97, 0x45, 0x1B, 0x17, 0x42, 0xEC, 0xAA, 0xEC, + 0x72, 0x99, 0x87, 0x69, 0x68, 0x6B, 0xDE, 0x95, 0x02, 0x03, 0xF4, 0xE5, + 0xF1, 0xE4, 0x7C, 0xF0, 0xDE, 0x43, 0x0C, 0x32, 0xCE, 0xEB, 0x92, 0x15, + 0x39, 0x16, 0x9C, 0x32, 0xCC, 0x82, 0x73, 0x4D, 0x99, 0x39, 0x93, 0x0E, + 0xA7, 0xE9, 0xD7, 0xA7, 0xE0, 0x74, 0x19, 0xAF, 0x36, 0x9B, 0xA1, 0x9F, + 0xE7, 0x45, 0xD6, 0x55, 0x5E, 0x66, 0x59, 0x88, 0x7E, 0xD6, 0x56, 0x6B, + 0x23, 0x17, 0x9D, 0x12, 0x88, 0x09, 0x68, 0x1B, 0x44, 0xC6, 0x21, 0x46, + 0x4A, 0x79, 0xE7, 0x7C, 0x5D, 0xE7, 0xB9, 0xE0, 0x4D, 0xDD, 0xD4, 0xF5, + 0xEA, 0xF5, 0xCB, 0xFD, 0x8B, 0x5D, 0xFD, 0xFE, 0xF6, 0x6A, 0xB7, 0xED, + 0x9A, 0xBA, 0x9C, 0xA6, 0x99, 0x52, 0xE2, 0xBC, 0x9F, 0x66, 0xE5, 0x7C, + 0xC8, 0x19, 0x9E, 0x26, 0xED, 0x43, 0xAA, 0x33, 0xEE, 0xAC, 0xD5, 0x46, + 0x37, 0x55, 0x05, 0x01, 0x18, 0x86, 0x19, 0x04, 0x10, 0x7D, 0x74, 0x2E, + 0xED, 0x76, 0x9B, 0xED, 0xAA, 0x59, 0xAF, 0x3A, 0xCE, 0x05, 0x04, 0x28, + 0xC5, 0x50, 0xD7, 0xA5, 0x4F, 0xD6, 0xFA, 0x88, 0xA9, 0x68, 0x9A, 0x3C, + 0x45, 0xDD, 0xAD, 0x3A, 0x9E, 0x97, 0x72, 0x91, 0x28, 0x21, 0x84, 0x58, + 0x5E, 0xE4, 0xDE, 0xA7, 0xD7, 0xD7, 0x37, 0x6D, 0xDE, 0xF5, 0x93, 0x12, + 0x22, 0x3F, 0xF5, 0xE6, 0xEE, 0xE9, 0xF2, 0xE5, 0xE1, 0xF1, 0xD4, 0x0F, + 0x00, 0x26, 0x17, 0xA2, 0xF3, 0xB1, 0xC8, 0x2B, 0x80, 0xD0, 0xE3, 0xF3, + 0xC5, 0x79, 0x1F, 0x82, 0x1F, 0x2E, 0xE3, 0x3C, 0x69, 0x8C, 0xC9, 0xE3, + 0xF3, 0xE5, 0xC3, 0xE7, 0x67, 0x88, 0x28, 0x63, 0xEC, 0xF5, 0xD5, 0xE6, + 0xD5, 0xF5, 0xFA, 0xE5, 0xF5, 0x6A, 0xD3, 0x55, 0xCB, 0x2C, 0x27, 0xA9, + 0x01, 0x42, 0xEF, 0x5F, 0x5F, 0xBF, 0x7F, 0xF3, 0x1A, 0x42, 0xD8, 0xB4, + 0x75, 0x53, 0x17, 0x82, 0xE1, 0xEB, 0x55, 0xE9, 0xAC, 0x3F, 0x9E, 0x47, + 0xEB, 0xC2, 0xA2, 0xD4, 0xC3, 0xA1, 0xFF, 0xFC, 0x74, 0x3C, 0x9D, 0xA7, + 0x59, 0x1A, 0x65, 0xDC, 0xBC, 0xE8, 0xE3, 0x65, 0xD4, 0xCE, 0x85, 0x98, + 0x36, 0x9B, 0xCA, 0x5A, 0x2F, 0x95, 0xB1, 0xD6, 0x01, 0x04, 0x04, 0xC7, + 0xB9, 0xC0, 0x9C, 0x73, 0x63, 0x9C, 0x36, 0x0E, 0x00, 0xF0, 0xCD, 0x9B, + 0x17, 0xDF, 0xBC, 0x7B, 0xBB, 0x6E, 0x4A, 0xC1, 0x88, 0x52, 0x5A, 0x30, + 0x9A, 0x0B, 0xAA, 0x8C, 0xF3, 0x21, 0xC5, 0x10, 0x43, 0x8C, 0x8C, 0xE0, + 0x49, 0x3A, 0x82, 0x11, 0x4C, 0xC1, 0x79, 0x1F, 0x01, 0x12, 0x1C, 0x5F, + 0x2E, 0x33, 0x42, 0xD1, 0x5A, 0x6B, 0x8D, 0xB5, 0x46, 0x39, 0xA7, 0xCB, + 0x9C, 0x0B, 0x04, 0xA2, 0x77, 0x01, 0x42, 0x2E, 0x58, 0x5E, 0x8A, 0xAC, + 0x40, 0xC9, 0x25, 0x1F, 0xC3, 0x79, 0x92, 0x31, 0x61, 0x08, 0xA2, 0xD4, + 0xDA, 0x27, 0x42, 0x10, 0xB8, 0x5A, 0x67, 0x84, 0x60, 0x4C, 0xE0, 0xA2, + 0xCC, 0x30, 0x2D, 0x8C, 0x72, 0x92, 0x10, 0x80, 0x69, 0xDD, 0xE5, 0xEB, + 0xD5, 0x55, 0x4C, 0xFC, 0x7C, 0x3E, 0x68, 0x3D, 0x09, 0xC1, 0x5E, 0xBF, + 0xEA, 0x60, 0x8C, 0x7A, 0x36, 0x4D, 0x99, 0x7F, 0xBE, 0xBB, 0x77, 0xC1, + 0x0E, 0xE3, 0x52, 0xE5, 0x45, 0x3F, 0x4B, 0x96, 0x61, 0x81, 0x49, 0x95, + 0x97, 0x3F, 0xFD, 0x7C, 0xBF, 0xDE, 0xB4, 0x04, 0x21, 0xA3, 0x35, 0x44, + 0x90, 0xD1, 0x0C, 0xA4, 0xB8, 0x28, 0x59, 0x56, 0x85, 0x5C, 0x34, 0x81, + 0x88, 0x10, 0x22, 0x97, 0x79, 0x9C, 0x4D, 0xD7, 0xB6, 0x11, 0x3A, 0xEB, + 0x4D, 0x57, 0xE7, 0x29, 0x81, 0x97, 0x37, 0xAF, 0xF7, 0xDB, 0xCD, 0x34, + 0x8C, 0x9C, 0xB2, 0xB2, 0x6C, 0x18, 0x81, 0x10, 0xC2, 0x65, 0x91, 0x95, + 0xE0, 0x87, 0x93, 0xC2, 0x98, 0x5A, 0xE3, 0xAC, 0x31, 0x6D, 0x55, 0x25, + 0xEB, 0xE7, 0x69, 0x06, 0x29, 0x22, 0x00, 0x20, 0x26, 0x9C, 0x65, 0x14, + 0x13, 0x8C, 0xE1, 0xFE, 0xC5, 0x55, 0xF4, 0x5A, 0x08, 0xBA, 0x5A, 0x35, + 0xED, 0xBA, 0xCE, 0x0A, 0x86, 0xFF, 0x87, 0x7F, 0xF8, 0xFB, 0xAA, 0x5A, + 0xE5, 0x0C, 0x79, 0x9F, 0x8C, 0xB5, 0x29, 0x85, 0x94, 0x52, 0xD3, 0x14, + 0x65, 0x95, 0xCD, 0x8B, 0x0C, 0x11, 0x54, 0x55, 0xB5, 0xBB, 0xDA, 0x76, + 0x8D, 0xD8, 0xED, 0xD6, 0xD1, 0xDA, 0xCB, 0xE9, 0xB9, 0xAC, 0x45, 0x4C, + 0x89, 0x11, 0x9A, 0xA2, 0xDB, 0xAD, 0x5B, 0x46, 0x71, 0x88, 0x21, 0x7A, + 0xCB, 0x08, 0x22, 0x04, 0x2B, 0x39, 0x96, 0x79, 0x5E, 0x66, 0xF9, 0xF1, + 0x70, 0xB9, 0x8C, 0x6E, 0x98, 0x34, 0x44, 0x6C, 0x91, 0x7A, 0x94, 0x6A, + 0x94, 0x91, 0x94, 0xD7, 0x90, 0xD7, 0xD3, 0xD8, 0x9F, 0xFB, 0x91, 0x16, + 0x5D, 0xD0, 0x73, 0xF0, 0x8A, 0xE2, 0x70, 0xB8, 0x4C, 0xD3, 0xA2, 0x52, + 0x0A, 0x21, 0x84, 0x4F, 0x9F, 0x9F, 0x87, 0x7E, 0x32, 0xC6, 0xFD, 0xF8, + 0xE1, 0xF1, 0xE9, 0x38, 0x59, 0x17, 0x2F, 0xF3, 0x32, 0x2A, 0xCD, 0xB3, + 0x7C, 0x51, 0x21, 0xCB, 0x00, 0x4A, 0x61, 0x31, 0xA1, 0x62, 0xA1, 0x6E, + 0xD6, 0xE3, 0x2C, 0x31, 0xC2, 0xFF, 0xF4, 0xEF, 0x77, 0x09, 0x91, 0x5F, + 0x3E, 0x7C, 0xF7, 0xED, 0xB7, 0x5F, 0x49, 0x29, 0xA7, 0xE1, 0x6C, 0x9C, + 0x8B, 0x09, 0x49, 0x65, 0x97, 0x79, 0x3E, 0x9E, 0x2E, 0x8F, 0xC7, 0xD3, + 0x65, 0x1C, 0xBD, 0xF7, 0xF3, 0xAC, 0x1F, 0x2F, 0xF2, 0xC3, 0x2F, 0x1F, + 0xBF, 0xFE, 0xED, 0x1F, 0xA7, 0xCB, 0x73, 0x55, 0x8A, 0xE3, 0xA5, 0x27, + 0x14, 0x33, 0x91, 0xEB, 0x40, 0x59, 0xD1, 0xAD, 0xAF, 0x5E, 0xBF, 0xBD, + 0x69, 0x73, 0x81, 0xBE, 0xFF, 0xF1, 0x67, 0xCA, 0xF3, 0xFD, 0xCD, 0xED, + 0xD4, 0x9F, 0xC6, 0xFE, 0x84, 0x30, 0xFE, 0x75, 0xED, 0x91, 0x33, 0x3A, + 0x8E, 0xF2, 0x70, 0x1E, 0xBB, 0xA6, 0x2C, 0x33, 0x3A, 0x4C, 0x32, 0x01, + 0xB0, 0xCC, 0x6A, 0x91, 0xE6, 0xDD, 0x9B, 0x57, 0x4A, 0x5B, 0x41, 0xF1, + 0x9F, 0x7F, 0x73, 0xFB, 0xD5, 0xED, 0xCD, 0x7F, 0xFB, 0xEB, 0x8F, 0x52, + 0xB9, 0xAB, 0xCD, 0xEA, 0xD3, 0xDD, 0x23, 0xC1, 0xE0, 0xF7, 0x5F, 0xBD, + 0xB4, 0xD6, 0xE5, 0x42, 0x7C, 0xFF, 0xE3, 0x87, 0x3F, 0xFF, 0xEE, 0xED, + 0x2F, 0x5F, 0x8E, 0xDE, 0x9A, 0x8C, 0x52, 0x6D, 0xFD, 0xF1, 0xD2, 0x1B, + 0x65, 0xB3, 0x3C, 0x07, 0x10, 0x7A, 0xEB, 0x28, 0xC1, 0x18, 0xA5, 0xCD, + 0xBA, 0xCB, 0xB3, 0xEC, 0xE1, 0xE9, 0x39, 0xE3, 0x0C, 0x01, 0xA8, 0x74, + 0xE8, 0xEA, 0x4A, 0x1B, 0x35, 0xCF, 0x0B, 0x80, 0xB4, 0x29, 0x72, 0xA5, + 0x6D, 0x08, 0xBE, 0x2C, 0x78, 0x95, 0x65, 0x20, 0x06, 0x00, 0x52, 0x5D, + 0x12, 0x04, 0xD3, 0xBA, 0x2C, 0x8A, 0xBC, 0xBC, 0xDA, 0x76, 0xAF, 0xF7, + 0xEB, 0x9B, 0x5D, 0xFB, 0xF6, 0xE5, 0xAE, 0xCC, 0xC8, 0x8B, 0x6D, 0xB3, + 0x6E, 0xCA, 0x75, 0x27, 0x60, 0x02, 0x04, 0xE1, 0x77, 0xB7, 0xFB, 0x26, + 0xCF, 0xB6, 0xEB, 0xB2, 0x2E, 0x05, 0x21, 0x90, 0x31, 0xB0, 0x5D, 0xD5, + 0xC6, 0x69, 0x29, 0x7D, 0xF4, 0x08, 0x44, 0x80, 0x50, 0x32, 0xD6, 0xBC, + 0xB8, 0x5A, 0x63, 0x08, 0x63, 0x82, 0xC6, 0x05, 0x17, 0x02, 0xE3, 0x14, + 0x21, 0x0C, 0x31, 0x4C, 0x10, 0xE6, 0x82, 0xFF, 0xF9, 0xF7, 0xBF, 0xBF, + 0xD9, 0xDF, 0xD4, 0x55, 0x0D, 0x01, 0x48, 0x09, 0x46, 0x00, 0xF3, 0x2C, + 0xCB, 0x33, 0xBE, 0x5A, 0x17, 0x45, 0xC1, 0x29, 0x45, 0x4D, 0x9B, 0x21, + 0x04, 0xAA, 0x4A, 0x50, 0xCE, 0x21, 0xC4, 0x9C, 0x80, 0xE0, 0xBD, 0x73, + 0x21, 0x7A, 0x47, 0x11, 0x68, 0xEB, 0xA6, 0xEB, 0x9A, 0xBA, 0x2A, 0x31, + 0xCD, 0x01, 0x44, 0xC6, 0x25, 0xA9, 0xBD, 0x31, 0x26, 0x13, 0xD9, 0xCB, + 0x9B, 0x1B, 0x00, 0xE3, 0xE9, 0xD2, 0x1F, 0x4E, 0xC3, 0xA6, 0xED, 0x60, + 0x0A, 0x4F, 0x87, 0xA1, 0x9F, 0xF4, 0xCF, 0x9F, 0x8F, 0xDA, 0x06, 0x4A, + 0x60, 0x3F, 0x8D, 0x65, 0x29, 0xAE, 0x77, 0x9B, 0xE4, 0x93, 0x71, 0x30, + 0x44, 0xE8, 0x3C, 0x98, 0x75, 0x78, 0x3C, 0x1E, 0x1F, 0x9E, 0x0F, 0x59, + 0x46, 0xD7, 0xAB, 0x6A, 0x9A, 0x15, 0x67, 0x3C, 0x41, 0xA8, 0xAC, 0x45, + 0x18, 0x00, 0x00, 0x8F, 0x87, 0x13, 0x21, 0x30, 0x01, 0xBC, 0x48, 0x63, + 0x8C, 0x33, 0xDE, 0xF7, 0xB3, 0x7C, 0x78, 0xBA, 0x28, 0x65, 0x8D, 0x75, + 0xC3, 0xBC, 0xC4, 0x08, 0xAB, 0x2A, 0x7F, 0x79, 0xB3, 0xDB, 0xAC, 0x9A, + 0xAA, 0xCC, 0x02, 0x88, 0x28, 0xC5, 0x14, 0x4C, 0x08, 0x96, 0xA4, 0x58, + 0x72, 0xFA, 0xE5, 0xF1, 0x38, 0x2E, 0x0B, 0xC1, 0x58, 0x6A, 0x3B, 0x2C, + 0xD2, 0x05, 0x90, 0x67, 0x5C, 0x19, 0x67, 0x7D, 0xF8, 0xB5, 0x3E, 0x0C, + 0x11, 0xD2, 0xDA, 0x80, 0x14, 0xDA, 0xAE, 0x5C, 0x37, 0x55, 0xD7, 0xE4, + 0x42, 0xB0, 0x73, 0xBF, 0xAC, 0xDA, 0x92, 0x12, 0x4A, 0x31, 0x8C, 0x31, + 0x55, 0x45, 0x51, 0xE7, 0x99, 0xB7, 0x8A, 0x71, 0xFC, 0x78, 0xB8, 0x18, + 0xEB, 0x6D, 0x08, 0x54, 0xE4, 0x39, 0xA7, 0x5A, 0x6B, 0xEB, 0x43, 0x5B, + 0x30, 0x8C, 0xB0, 0x32, 0xAE, 0x2A, 0xC8, 0xBA, 0xE3, 0xDE, 0x5A, 0x2A, + 0xCA, 0xE3, 0x65, 0xC2, 0x14, 0x7A, 0x1F, 0x52, 0x4A, 0xB9, 0x60, 0x8C, + 0x20, 0x41, 0x45, 0x74, 0x20, 0x7A, 0xD7, 0x54, 0x4D, 0x48, 0x91, 0x50, + 0x6C, 0x9D, 0xEB, 0x07, 0x85, 0x08, 0xA7, 0x82, 0x11, 0xC2, 0x73, 0x21, + 0x62, 0xB2, 0x31, 0x21, 0x84, 0x00, 0x45, 0xDE, 0xDA, 0x90, 0x02, 0x14, + 0x8C, 0x8C, 0x93, 0x6E, 0xDB, 0x15, 0x26, 0x2C, 0x2F, 0x44, 0xD3, 0x14, + 0xC1, 0x47, 0x84, 0x68, 0x96, 0x45, 0x21, 0xC2, 0x66, 0x9B, 0xEF, 0xF7, + 0x75, 0x55, 0x31, 0xC1, 0x49, 0x59, 0x65, 0x31, 0x79, 0x23, 0x75, 0x0A, + 0x31, 0x25, 0xD0, 0x4F, 0xF2, 0x57, 0xCA, 0xF1, 0xB7, 0x5F, 0xBF, 0xEA, + 0x07, 0x05, 0x62, 0xAC, 0x8A, 0x4C, 0x2F, 0x0A, 0xA4, 0x84, 0x31, 0x6D, + 0xDB, 0xFA, 0xF9, 0xD4, 0x4B, 0xA9, 0x09, 0x84, 0x10, 0x42, 0x80, 0x51, + 0x51, 0x17, 0x65, 0x55, 0x7D, 0xFF, 0xD3, 0x17, 0x84, 0x21, 0x4C, 0x49, + 0x49, 0xBD, 0xAA, 0x3B, 0xC6, 0x32, 0x8C, 0xF0, 0x65, 0x98, 0x61, 0x0A, + 0x4F, 0xC7, 0x3E, 0x41, 0x52, 0x66, 0x8C, 0x12, 0x58, 0x08, 0xDA, 0x54, + 0xA5, 0xB1, 0xBE, 0xA9, 0x4A, 0x0C, 0x60, 0x5D, 0x88, 0x3A, 0xCF, 0x63, + 0xC0, 0x19, 0x2F, 0x38, 0xC2, 0xD6, 0x84, 0xED, 0xF6, 0x4A, 0x1B, 0x9F, + 0xE5, 0x14, 0x13, 0xC8, 0x05, 0xBB, 0xF4, 0x87, 0xA6, 0x2D, 0x42, 0xB0, + 0x7A, 0x99, 0x38, 0x8B, 0xF0, 0x7F, 0xFF, 0xDF, 0xFE, 0x0B, 0x04, 0x78, + 0x1C, 0x2E, 0xD3, 0x70, 0x4C, 0x30, 0x44, 0x90, 0x28, 0xCD, 0x18, 0x25, + 0xC3, 0xD4, 0xBB, 0xE0, 0x37, 0xAB, 0x2B, 0xE7, 0xA0, 0x8F, 0x81, 0x73, + 0xCC, 0x05, 0x43, 0x08, 0x4B, 0xB9, 0x60, 0x82, 0x9C, 0xF6, 0xD1, 0xFB, + 0x61, 0xEA, 0xDB, 0x3A, 0x63, 0x3C, 0x8B, 0x11, 0xC6, 0x18, 0x31, 0xA2, + 0x2E, 0x84, 0x14, 0x42, 0x9D, 0x57, 0x18, 0x93, 0xFB, 0xC7, 0x7B, 0x6B, + 0x03, 0x40, 0xF8, 0xFE, 0xF1, 0x58, 0xE4, 0x3C, 0xB1, 0xFA, 0xE9, 0xD8, + 0x27, 0xB7, 0x50, 0x96, 0x5D, 0xA6, 0x19, 0x42, 0xF4, 0xF5, 0xD7, 0xBF, + 0xF3, 0x6A, 0x9C, 0xE7, 0x0B, 0x49, 0x8E, 0x50, 0xEC, 0xA3, 0xDB, 0x6D, + 0x4B, 0x18, 0x60, 0x88, 0xA1, 0xCC, 0x39, 0xE1, 0xF8, 0x87, 0x1F, 0x0F, + 0x4D, 0x57, 0x71, 0xC1, 0xFB, 0xF3, 0xB8, 0xDA, 0xAC, 0x77, 0x57, 0xEF, + 0x3F, 0xFC, 0xFC, 0x5D, 0x59, 0xA0, 0x4D, 0xD9, 0x8C, 0x2E, 0xCF, 0x33, + 0x9A, 0xE7, 0xC5, 0x77, 0x3F, 0x7D, 0xB2, 0xEA, 0x72, 0xB3, 0xCE, 0x81, + 0xD8, 0xFE, 0xCB, 0x5F, 0xBF, 0x7B, 0xF7, 0xE6, 0xAA, 0xA0, 0x17, 0x4C, + 0xB3, 0xD3, 0x71, 0xB1, 0x11, 0xC7, 0xE4, 0xBE, 0xDA, 0x96, 0x65, 0x8E, + 0xBE, 0x3F, 0x9A, 0x9C, 0xB1, 0x55, 0x91, 0x9F, 0xCE, 0xEA, 0x2F, 0xDF, + 0x7F, 0xBE, 0x7D, 0xF3, 0xE6, 0xF5, 0xBB, 0xDF, 0xFD, 0xF0, 0x97, 0xFF, + 0xCB, 0x3A, 0xE7, 0xA3, 0x8D, 0xDE, 0x5D, 0xBD, 0x78, 0x93, 0x48, 0x83, + 0x09, 0xA5, 0x94, 0x7D, 0xFE, 0xE1, 0x9F, 0x08, 0x06, 0x57, 0x2F, 0x6E, + 0xA5, 0xC5, 0x21, 0xC5, 0x2F, 0x3F, 0xFD, 0xB3, 0xE0, 0x22, 0x84, 0x88, + 0x00, 0x20, 0x18, 0x33, 0x4E, 0x62, 0x08, 0x00, 0x13, 0x02, 0xD1, 0xBA, + 0x2B, 0xB5, 0x73, 0x87, 0xE3, 0x50, 0x54, 0x19, 0xC5, 0xF4, 0xFD, 0xED, + 0xCB, 0xFF, 0xE7, 0x2F, 0x7F, 0xFD, 0xC7, 0x6F, 0xDF, 0x5D, 0x6D, 0xDA, + 0xBF, 0xFE, 0x74, 0x37, 0x4B, 0x1D, 0x13, 0x78, 0x73, 0xFB, 0xF2, 0xDF, + 0xBE, 0xFF, 0xF1, 0xEF, 0xBE, 0x7D, 0xEF, 0x93, 0x7B, 0x7C, 0xBE, 0x7C, + 0xFC, 0xF4, 0x28, 0x32, 0xDA, 0xB6, 0xF9, 0x2F, 0x77, 0xC7, 0x57, 0xBB, + 0x6E, 0x5A, 0x5C, 0x44, 0xD8, 0x5A, 0x07, 0x21, 0xB6, 0x21, 0x9C, 0x4E, + 0x97, 0xDB, 0x9B, 0xF5, 0xDB, 0xDB, 0x3D, 0x17, 0xAC, 0x2C, 0x8A, 0xBB, + 0xA7, 0xC3, 0xE3, 0x73, 0x0F, 0x23, 0x48, 0x09, 0x54, 0x55, 0x51, 0xE7, + 0x1C, 0xC2, 0x24, 0xA5, 0x05, 0x90, 0xBC, 0x7E, 0xB5, 0xD1, 0xCA, 0x46, + 0xA0, 0xBB, 0x2E, 0x3F, 0x9F, 0x66, 0x63, 0x1C, 0xA3, 0xF0, 0xFE, 0xF1, + 0xB0, 0x68, 0xFB, 0xB7, 0xBF, 0xFD, 0x36, 0x17, 0x19, 0xE7, 0x84, 0x52, + 0xC2, 0x28, 0x00, 0x08, 0x46, 0x1F, 0x83, 0x8F, 0x01, 0xF8, 0x3C, 0xC7, + 0x3E, 0x44, 0xA3, 0x81, 0xF3, 0x01, 0x24, 0x50, 0x35, 0xB9, 0xB3, 0xD6, + 0x3A, 0x47, 0x29, 0xCE, 0x32, 0x92, 0xE5, 0xEC, 0xFE, 0x7E, 0xBA, 0xBF, + 0x9F, 0x31, 0x45, 0xC6, 0xD9, 0xE4, 0x42, 0xDB, 0x55, 0xFD, 0x22, 0xC7, + 0xC9, 0x3C, 0x1D, 0xA6, 0x69, 0xD1, 0x10, 0x86, 0x14, 0x22, 0xC2, 0x90, + 0x52, 0xF6, 0xB7, 0x7F, 0xFE, 0x7D, 0x25, 0x8A, 0x71, 0x90, 0xCE, 0x5B, + 0x04, 0xC1, 0x65, 0x32, 0xE3, 0xA2, 0x10, 0xF4, 0x9C, 0xD3, 0xAE, 0xCD, + 0x9B, 0x32, 0xA3, 0x04, 0xF8, 0x68, 0xAC, 0x8B, 0x04, 0x63, 0xCE, 0x98, + 0x5C, 0x6C, 0xF2, 0x36, 0x13, 0x22, 0x04, 0x9F, 0xBC, 0x5B, 0x75, 0x9D, + 0x71, 0x38, 0x01, 0x3C, 0x8E, 0x8B, 0xB2, 0x4E, 0x70, 0xAE, 0x8D, 0x4E, + 0x20, 0x41, 0xE8, 0x9B, 0x66, 0x45, 0x29, 0xC9, 0x33, 0x06, 0x53, 0x3C, + 0x1C, 0x7B, 0xBD, 0xCC, 0xC3, 0xD0, 0x3F, 0x1C, 0x87, 0xA2, 0x5D, 0x61, + 0xD1, 0x8E, 0xFD, 0xA1, 0xE0, 0x2E, 0x45, 0xFF, 0xCD, 0xED, 0xEB, 0xB2, + 0x2C, 0x8F, 0x87, 0x3E, 0xCB, 0x2B, 0x63, 0xFD, 0xB4, 0xC8, 0xAA, 0x6D, + 0x7F, 0xFA, 0xF8, 0x39, 0xCF, 0x79, 0x53, 0x65, 0x31, 0x85, 0x61, 0x36, + 0xD3, 0xA4, 0xBD, 0x57, 0x6D, 0x5B, 0x7B, 0x17, 0x9C, 0xF7, 0x5A, 0xA9, + 0xAE, 0x2D, 0x62, 0x80, 0xD6, 0x7A, 0xC6, 0xE9, 0xC3, 0xE1, 0x64, 0xBD, + 0xDF, 0x6F, 0xD6, 0x20, 0x44, 0x4A, 0x45, 0x08, 0xAE, 0x29, 0x33, 0x00, + 0x52, 0xC6, 0xA8, 0x10, 0x54, 0x4A, 0xC9, 0x33, 0x66, 0x5C, 0x3C, 0x3C, + 0x3D, 0xED, 0xB6, 0xAB, 0x92, 0x8B, 0xF3, 0x65, 0xBC, 0x3F, 0x8D, 0xFB, + 0xDD, 0x75, 0x9E, 0x15, 0x4F, 0x87, 0x67, 0xE3, 0x9C, 0x10, 0xC2, 0x7B, + 0xBB, 0x28, 0xC5, 0x38, 0xD5, 0x4A, 0x97, 0x45, 0x06, 0x40, 0xE2, 0x0C, + 0x63, 0x0C, 0x44, 0xCE, 0x01, 0x00, 0x04, 0xA2, 0xD5, 0xAA, 0x3D, 0x9D, + 0x67, 0x4A, 0xC8, 0xBA, 0x2B, 0x04, 0xC7, 0x2E, 0xC4, 0x60, 0x3C, 0x23, + 0x78, 0x9A, 0xE4, 0x71, 0x94, 0xA7, 0x5E, 0x7A, 0xE7, 0x98, 0x60, 0x98, + 0x72, 0x02, 0xEC, 0x65, 0x98, 0x8C, 0x0D, 0xAB, 0x92, 0x1F, 0x07, 0x0D, + 0x10, 0x6E, 0x0A, 0x22, 0x04, 0x4A, 0xC1, 0x69, 0x87, 0x18, 0xCF, 0x30, + 0xD0, 0x9B, 0xA6, 0x28, 0xCB, 0x9C, 0x72, 0x56, 0x14, 0xB9, 0x52, 0xA0, + 0xEF, 0x15, 0x26, 0xA8, 0xEF, 0x67, 0xA9, 0xA5, 0x0B, 0x21, 0x84, 0x08, + 0x12, 0x4A, 0x20, 0xB6, 0x6D, 0x4E, 0x29, 0x76, 0x36, 0x48, 0x69, 0xAA, + 0x5C, 0x40, 0xE0, 0x66, 0xA9, 0x11, 0x00, 0x82, 0x21, 0x80, 0x29, 0xC6, + 0x04, 0x02, 0x62, 0xA3, 0xDD, 0xEF, 0xBB, 0xA9, 0x5F, 0xA6, 0x51, 0x7B, + 0x9F, 0xB4, 0x73, 0x98, 0xA0, 0xB2, 0xE4, 0x94, 0xE0, 0xAA, 0xCA, 0x8A, + 0x42, 0x20, 0x84, 0x18, 0xA5, 0xCE, 0x5A, 0x90, 0x12, 0x41, 0xE8, 0xA7, + 0x8F, 0xCF, 0x2E, 0xC0, 0x5A, 0xF0, 0x77, 0xB7, 0x7B, 0x88, 0x61, 0xB0, + 0x0E, 0x01, 0x1C, 0x22, 0x00, 0x09, 0x52, 0x4A, 0x03, 0x80, 0xC7, 0x73, + 0xAF, 0x94, 0xE4, 0x94, 0x02, 0x84, 0xCA, 0xAA, 0xB2, 0xCE, 0x21, 0x84, + 0x97, 0x65, 0xA6, 0x14, 0x3D, 0x3E, 0x9D, 0x36, 0xAB, 0x6D, 0x5D, 0x14, + 0xF3, 0x3C, 0x5C, 0x26, 0xD9, 0x56, 0x35, 0x63, 0xE0, 0xF9, 0x3C, 0xA4, + 0x44, 0x28, 0x01, 0x65, 0x4E, 0x95, 0xF6, 0x79, 0x9E, 0x2B, 0xE7, 0xC6, + 0x69, 0x21, 0x28, 0x65, 0x82, 0xA7, 0x04, 0x29, 0x67, 0x04, 0xE1, 0xAB, + 0x6D, 0xC3, 0x29, 0x8E, 0xD1, 0x1B, 0x9F, 0x9A, 0xA6, 0x34, 0x46, 0x79, + 0x0F, 0x43, 0x32, 0xDE, 0x2D, 0x52, 0xDA, 0x18, 0x53, 0x48, 0x00, 0xFE, + 0xAF, 0xFF, 0xCB, 0x7F, 0x4E, 0xC9, 0x6B, 0xB5, 0xFC, 0xF0, 0xF1, 0x93, + 0x0D, 0x5E, 0x70, 0x06, 0x02, 0xAE, 0xCA, 0xC2, 0x26, 0xBF, 0xDB, 0xAE, + 0x51, 0xC2, 0x87, 0xE7, 0x11, 0x20, 0x74, 0xEC, 0xC7, 0xDD, 0xA6, 0x76, + 0x21, 0x94, 0x25, 0x6B, 0x4A, 0x56, 0x70, 0xAE, 0xAC, 0xFE, 0xE9, 0xE3, + 0x01, 0x02, 0x6C, 0xAC, 0xBA, 0xDA, 0x34, 0xD3, 0x2C, 0x77, 0xEB, 0x15, + 0x23, 0xB4, 0x69, 0xAA, 0x18, 0x82, 0x31, 0x7E, 0x5A, 0x96, 0xF3, 0xE4, + 0xDA, 0xDD, 0x9B, 0xFE, 0xF4, 0x98, 0x97, 0xDD, 0xFD, 0xD3, 0xE3, 0x4F, + 0x3F, 0xFE, 0xF5, 0xE5, 0xA6, 0xBD, 0xCC, 0xA6, 0xDB, 0xBF, 0x6E, 0xDB, + 0x6E, 0x38, 0x3D, 0xE7, 0x9C, 0x4D, 0xF3, 0xF9, 0x7A, 0x57, 0x83, 0x94, + 0x10, 0x8A, 0x10, 0x44, 0x39, 0x9B, 0xE0, 0xD3, 0x76, 0x53, 0x24, 0x08, + 0x16, 0xED, 0x41, 0x42, 0x52, 0xD9, 0xA1, 0x9F, 0xBF, 0xFD, 0x9B, 0xBF, + 0xFB, 0xF2, 0xF1, 0x63, 0x5D, 0x62, 0x80, 0xD0, 0xCF, 0x9F, 0x1E, 0xB3, + 0x72, 0x75, 0xFB, 0xFA, 0xF6, 0x97, 0xBB, 0xE7, 0x92, 0x9A, 0x3F, 0xBE, + 0xEF, 0x4E, 0xC3, 0x3C, 0xBA, 0x4E, 0x1A, 0xD0, 0xA0, 0xC7, 0x2A, 0x57, + 0x8C, 0xE1, 0xC0, 0xBE, 0xF2, 0x3E, 0xE0, 0xF9, 0xC7, 0x2A, 0xAF, 0xB2, + 0xA6, 0xFA, 0xF9, 0xA4, 0x70, 0x48, 0xDB, 0x92, 0xE5, 0x8C, 0xFF, 0xD7, + 0xFF, 0x78, 0x7E, 0xF3, 0xFE, 0x3D, 0x12, 0xED, 0x97, 0x8F, 0x3F, 0x3E, + 0x3D, 0x3F, 0xDE, 0x5C, 0xB7, 0x2E, 0x10, 0x1B, 0xC5, 0x97, 0x5F, 0x7E, + 0x8A, 0x5E, 0x96, 0x55, 0x39, 0x2F, 0xE6, 0xF6, 0xFA, 0xBA, 0xAA, 0xCA, + 0x7E, 0x56, 0xE7, 0x69, 0xC9, 0x88, 0xA5, 0x8C, 0x06, 0xE7, 0x11, 0x48, + 0xD6, 0x78, 0x00, 0x40, 0x5E, 0xF2, 0x3C, 0x67, 0xC9, 0x01, 0x90, 0x20, + 0xCF, 0x58, 0x51, 0x96, 0x00, 0xA6, 0xB1, 0xBF, 0xC4, 0x14, 0x6F, 0xB6, + 0xDD, 0x38, 0xEA, 0xE0, 0xD3, 0xC3, 0x79, 0x2C, 0x84, 0xF8, 0xE3, 0x6F, + 0xDE, 0x3C, 0x1E, 0xCF, 0xDE, 0xDB, 0x3F, 0x7D, 0xFB, 0xFE, 0xEE, 0x72, + 0x51, 0xCA, 0x9C, 0x8E, 0x67, 0xCE, 0x31, 0x44, 0x10, 0x63, 0x72, 0x3A, + 0x0E, 0xE3, 0xE2, 0x08, 0x63, 0x45, 0xC6, 0x5F, 0xBF, 0xDA, 0xFE, 0xF4, + 0xF3, 0xE7, 0xDB, 0xEB, 0xCD, 0xCD, 0xD5, 0x6A, 0x9C, 0x75, 0x84, 0x00, + 0xC1, 0x44, 0x10, 0x28, 0x8A, 0x0C, 0x41, 0x84, 0x21, 0x82, 0x10, 0x79, + 0x1B, 0x6D, 0xF0, 0x10, 0x22, 0x1F, 0xC3, 0x22, 0x25, 0x04, 0x80, 0x09, + 0x34, 0x5D, 0x16, 0x8C, 0x98, 0x49, 0xD1, 0x06, 0xAB, 0xB4, 0x26, 0x88, + 0x80, 0x08, 0xB4, 0xB4, 0x19, 0x81, 0x75, 0xC3, 0xCA, 0x5A, 0x80, 0x84, + 0x38, 0x13, 0x84, 0x20, 0xE3, 0xBC, 0x33, 0xA6, 0xE9, 0x72, 0x6D, 0xDC, + 0x34, 0x6B, 0x82, 0x18, 0xA6, 0x48, 0x2D, 0x32, 0x2F, 0x8B, 0xBA, 0xAC, + 0xCE, 0xA7, 0x79, 0x96, 0xAE, 0x6B, 0xF3, 0xB6, 0xCE, 0xB2, 0x8C, 0x04, + 0x0F, 0x94, 0x74, 0x90, 0xC4, 0x7F, 0xFE, 0xEB, 0x47, 0x88, 0x49, 0x04, + 0xF4, 0xE7, 0x8F, 0x4F, 0x4A, 0x2E, 0x99, 0xA0, 0x6D, 0xD7, 0x7C, 0xF5, + 0xF6, 0x4D, 0x9E, 0x61, 0xBD, 0x04, 0xAD, 0xF5, 0xE1, 0x7C, 0xC1, 0xB4, + 0x78, 0x3A, 0x9E, 0x10, 0x26, 0xC6, 0x5A, 0x63, 0x54, 0x57, 0x57, 0xBF, + 0xFB, 0xEA, 0x05, 0x02, 0x29, 0xC1, 0x00, 0x60, 0xC2, 0x10, 0x2B, 0xE5, + 0x31, 0x04, 0x6D, 0x9D, 0x87, 0x90, 0xAC, 0x56, 0x9C, 0xE1, 0x10, 0x71, + 0x3F, 0x5B, 0xEB, 0x22, 0x65, 0xDC, 0x5A, 0x57, 0x64, 0xDC, 0x79, 0x43, + 0x39, 0x45, 0x18, 0x0D, 0xA3, 0xC4, 0x8C, 0x16, 0x22, 0x0B, 0xDE, 0x64, + 0x9C, 0x71, 0x9A, 0xC5, 0x14, 0xE5, 0x32, 0x98, 0x00, 0x4D, 0xA0, 0xD3, + 0xE5, 0x7E, 0xBB, 0xA2, 0x55, 0x55, 0x10, 0x9A, 0x05, 0x17, 0x19, 0x65, + 0xC3, 0x38, 0xF7, 0xBD, 0x1C, 0xA6, 0x25, 0x2F, 0x4B, 0xF8, 0xAB, 0x2E, + 0x1D, 0x7C, 0x82, 0x50, 0xE9, 0x30, 0x4D, 0x4B, 0x5D, 0x52, 0x08, 0xA0, + 0xD4, 0x9E, 0x12, 0x0C, 0x60, 0x4C, 0x31, 0x70, 0xC6, 0x20, 0x44, 0x8F, + 0x87, 0x8B, 0x0F, 0x6E, 0xBB, 0x69, 0x28, 0x46, 0x29, 0xA6, 0xCB, 0xA8, + 0x85, 0x60, 0xBB, 0x55, 0xB3, 0xCC, 0xB2, 0xAD, 0x72, 0x4A, 0xD9, 0xBC, + 0x4C, 0x30, 0x79, 0x88, 0xC8, 0xB9, 0x9F, 0x32, 0x8E, 0x33, 0x2E, 0x8E, + 0x97, 0x25, 0x21, 0xBC, 0x5E, 0x6D, 0x2F, 0x97, 0xF3, 0xA2, 0x35, 0x21, + 0x74, 0x98, 0xC6, 0xB2, 0x28, 0x7C, 0x08, 0x42, 0x70, 0x46, 0xB1, 0x0F, + 0x3E, 0x06, 0x5F, 0x55, 0x99, 0x36, 0x36, 0xC6, 0xC0, 0x33, 0xE6, 0xAC, + 0x63, 0x54, 0x50, 0xCC, 0xDB, 0xA6, 0x22, 0x28, 0x41, 0x08, 0x05, 0x27, + 0x65, 0xC6, 0x30, 0xA6, 0x9C, 0x67, 0x0F, 0x87, 0xE7, 0xFB, 0x87, 0xA7, + 0xF3, 0x65, 0x5A, 0xB4, 0x45, 0x28, 0xD5, 0x25, 0xBB, 0x4C, 0x36, 0xE3, + 0x6C, 0x55, 0xE7, 0x2E, 0x61, 0x0C, 0xC1, 0xF3, 0xB9, 0x8F, 0x09, 0xBE, + 0x7B, 0xB1, 0x3E, 0x9E, 0xFA, 0xAB, 0xFD, 0x7E, 0xD3, 0xE2, 0xAA, 0xCC, + 0x09, 0x11, 0x98, 0x11, 0x25, 0xB5, 0x31, 0x86, 0x72, 0x86, 0x08, 0x39, + 0x9F, 0xC7, 0x45, 0x69, 0x08, 0xF1, 0xF9, 0xB8, 0x04, 0x1F, 0xCB, 0x2A, + 0x93, 0x72, 0x11, 0x1C, 0x9F, 0x2F, 0x12, 0x93, 0xAC, 0xA9, 0x45, 0xD7, + 0x94, 0xA7, 0x73, 0xFF, 0x7C, 0xBC, 0xAC, 0x57, 0x35, 0x63, 0xB4, 0x2E, + 0xC4, 0x34, 0xCB, 0x10, 0xBC, 0x28, 0x33, 0x25, 0x8D, 0xB5, 0x00, 0x41, + 0x7C, 0x19, 0x86, 0x97, 0xFB, 0x6E, 0x96, 0x7A, 0x98, 0x15, 0x04, 0x10, + 0x23, 0xC8, 0x28, 0x69, 0x6A, 0x51, 0xE4, 0x14, 0x62, 0x44, 0x09, 0x58, + 0xB5, 0x0D, 0x8C, 0x18, 0x46, 0x68, 0x9D, 0x85, 0x28, 0x39, 0x1B, 0x7E, + 0x9D, 0x19, 0x8C, 0x11, 0x02, 0x80, 0xCA, 0x22, 0x67, 0x14, 0x13, 0x42, + 0x08, 0xA1, 0x94, 0xD0, 0x18, 0x62, 0x4C, 0xD1, 0x58, 0x8D, 0x71, 0x62, + 0x94, 0xF5, 0xD3, 0x9C, 0x17, 0x0D, 0x01, 0xD0, 0xA8, 0xC9, 0x86, 0x54, + 0x95, 0xF5, 0xBC, 0xCC, 0xDA, 0xDA, 0x7E, 0x9C, 0x9A, 0x8A, 0x53, 0xC2, + 0x96, 0x59, 0x13, 0xCE, 0x86, 0x45, 0x5B, 0xE7, 0xEA, 0xBA, 0xD6, 0xCB, + 0xA2, 0x94, 0xA3, 0x8C, 0x58, 0xE7, 0x57, 0x5D, 0x53, 0x14, 0x58, 0x14, + 0x79, 0x08, 0xE4, 0xFE, 0xCB, 0x53, 0x08, 0xBE, 0xAC, 0xB2, 0x9B, 0x57, + 0xE5, 0xE1, 0xF9, 0xA8, 0xA4, 0x17, 0x8C, 0x6A, 0xE7, 0x71, 0x5B, 0xF2, + 0x4C, 0xF0, 0x8F, 0x77, 0xA7, 0xC3, 0x45, 0x5A, 0x0F, 0xFA, 0xD1, 0x68, + 0x07, 0xB6, 0xDB, 0x75, 0x00, 0x58, 0x4A, 0xB3, 0xCC, 0xCE, 0xBA, 0xB4, + 0x28, 0x85, 0x11, 0x2C, 0xF3, 0xFC, 0x7C, 0x1A, 0x31, 0x40, 0x05, 0xE7, + 0x31, 0xC4, 0xAE, 0x5E, 0x39, 0x17, 0x73, 0x91, 0xED, 0xD7, 0xAB, 0x3C, + 0xCB, 0xBA, 0xB6, 0xDC, 0x6E, 0xD7, 0x8C, 0x52, 0x8C, 0x51, 0x0C, 0x3E, + 0x44, 0x8B, 0x52, 0x74, 0x30, 0x9F, 0x43, 0xB6, 0xBF, 0xDA, 0x0E, 0xC3, + 0x00, 0xCC, 0xF3, 0x3F, 0xFC, 0xCD, 0x0D, 0x44, 0x09, 0x01, 0xD7, 0xD4, + 0x6D, 0x00, 0x64, 0x39, 0x7F, 0x6E, 0x9B, 0x9A, 0x67, 0x59, 0x0A, 0x6A, + 0x51, 0x4A, 0x29, 0x13, 0x43, 0xD4, 0xDA, 0x49, 0xE5, 0x9A, 0x26, 0x7B, + 0x7A, 0x1E, 0x95, 0xF1, 0x7D, 0x2F, 0x6D, 0x08, 0x75, 0xB7, 0xD1, 0x36, + 0x9D, 0x0F, 0x5F, 0x52, 0x82, 0x21, 0xA4, 0x10, 0x41, 0x46, 0xB1, 0xD6, + 0xF6, 0xA6, 0xC5, 0xDF, 0xBE, 0x5D, 0xF5, 0xF3, 0xA4, 0xAC, 0xB3, 0xA0, + 0xE6, 0x79, 0x87, 0xF5, 0x2F, 0x57, 0x2B, 0xBA, 0x6F, 0x57, 0xC5, 0xEA, + 0x76, 0x3E, 0xFE, 0xB0, 0xAB, 0x21, 0x67, 0xF1, 0xA7, 0x4F, 0xD3, 0x9A, + 0x81, 0x4D, 0x09, 0xBD, 0xB3, 0xD1, 0xA7, 0xE0, 0x5D, 0x89, 0x25, 0xC0, + 0xA5, 0x9C, 0xFB, 0xEB, 0x6D, 0x65, 0x41, 0xFE, 0xE3, 0x87, 0x87, 0x65, + 0x1E, 0x9C, 0x33, 0x42, 0x50, 0x82, 0x71, 0x53, 0xB7, 0xCA, 0xE8, 0xCF, + 0x9F, 0x3F, 0xFE, 0xFE, 0xCF, 0xFF, 0xFD, 0xC3, 0xFD, 0x67, 0x42, 0x40, + 0x7F, 0x99, 0x29, 0x45, 0x31, 0x25, 0x8C, 0x60, 0x02, 0x10, 0x63, 0x64, + 0x95, 0xB7, 0xD6, 0x73, 0xCE, 0x21, 0x22, 0x18, 0xA1, 0xE8, 0x83, 0x73, + 0xD1, 0x59, 0x6D, 0x4C, 0x30, 0x0E, 0x14, 0x65, 0x66, 0x43, 0xD8, 0xB4, + 0xE5, 0xAB, 0xEB, 0x55, 0x4A, 0x71, 0xBB, 0x5A, 0xFF, 0xCB, 0xBF, 0xFF, + 0x90, 0x97, 0x45, 0xF0, 0x6E, 0xB7, 0x69, 0xDF, 0xBC, 0xBC, 0xBE, 0xD9, + 0xAD, 0xCE, 0x97, 0x25, 0xA6, 0xFF, 0xDF, 0xCF, 0xBA, 0x7D, 0x7D, 0x0D, + 0xA3, 0x2F, 0x44, 0xB6, 0xED, 0xBA, 0xBE, 0x57, 0xFD, 0x20, 0xA7, 0x71, + 0x01, 0x20, 0x85, 0x08, 0xA6, 0xC9, 0x7C, 0xFC, 0xF4, 0x3C, 0x4C, 0xFA, + 0xE9, 0x30, 0xDD, 0x3F, 0xF5, 0x8B, 0xF1, 0xE7, 0xCB, 0xDC, 0x0F, 0xF3, + 0xF1, 0x38, 0x5F, 0x2E, 0xCA, 0xC8, 0xF8, 0xF8, 0x3C, 0x06, 0x40, 0x4E, + 0x97, 0xC9, 0xD9, 0x50, 0x55, 0x85, 0xB5, 0x71, 0x9C, 0x55, 0xB3, 0x29, + 0x19, 0x47, 0x59, 0x26, 0xEE, 0x1F, 0xFA, 0x2F, 0xF7, 0xE7, 0x7E, 0xD2, + 0x97, 0x51, 0x8D, 0xD2, 0xCD, 0x4A, 0x3F, 0xF7, 0x0B, 0x24, 0x99, 0x73, + 0x4E, 0x6A, 0xE3, 0x5C, 0xD0, 0xC6, 0x42, 0x8C, 0x7C, 0x02, 0xD6, 0xC1, + 0x4F, 0x77, 0xA7, 0x63, 0xAF, 0x3E, 0xDD, 0x5D, 0xA4, 0xB6, 0x87, 0xF3, + 0x32, 0x4B, 0xC3, 0x05, 0x2D, 0x73, 0x11, 0xA2, 0xFF, 0xF1, 0xA7, 0x3B, + 0xC1, 0x79, 0xC6, 0xE8, 0x7A, 0xD3, 0xBD, 0xB8, 0xB9, 0xBA, 0x5C, 0x8E, + 0xC1, 0x2E, 0x8B, 0x4E, 0xF7, 0x4F, 0xCF, 0x11, 0x10, 0x69, 0x3C, 0x44, + 0xD8, 0x87, 0x80, 0xE0, 0xAF, 0x34, 0x44, 0xB9, 0x5D, 0x6F, 0x31, 0x4A, + 0xC3, 0x30, 0xC9, 0x45, 0x5F, 0xCE, 0x53, 0xF4, 0xA0, 0xA9, 0x9B, 0x3C, + 0x63, 0x00, 0x82, 0x10, 0x23, 0x82, 0x84, 0x73, 0x96, 0x67, 0x4C, 0x70, + 0x5A, 0x57, 0x19, 0xE7, 0xF0, 0x78, 0x3E, 0x01, 0x08, 0x31, 0x06, 0x0F, + 0x0F, 0xA7, 0x53, 0x3F, 0xFB, 0x18, 0xEF, 0x1F, 0x4F, 0xE3, 0xB8, 0x00, + 0x10, 0x11, 0xC6, 0x21, 0x44, 0xC1, 0x99, 0x35, 0x13, 0xC3, 0xFE, 0x6A, + 0xDB, 0xAC, 0xBA, 0x9A, 0x50, 0x0A, 0x09, 0x9A, 0x17, 0x23, 0x95, 0x85, + 0x28, 0x69, 0x6B, 0x89, 0xA0, 0xE3, 0x22, 0x33, 0xC1, 0x39, 0xA7, 0xCE, + 0xFB, 0xBB, 0xFB, 0x03, 0x00, 0x28, 0xCB, 0x84, 0xD6, 0x66, 0x98, 0x35, + 0x26, 0x8C, 0xE0, 0x14, 0xBC, 0x23, 0x14, 0x11, 0x8C, 0xDA, 0xBA, 0xE2, + 0x9C, 0x10, 0x04, 0x63, 0x0C, 0x84, 0x30, 0x82, 0xE9, 0x38, 0xCB, 0x2C, + 0xA3, 0xD6, 0x3A, 0x82, 0x31, 0x63, 0x58, 0x19, 0xB5, 0x48, 0x13, 0x43, + 0x22, 0x04, 0xB7, 0x4D, 0xC9, 0x79, 0x09, 0x71, 0x9E, 0x30, 0x3D, 0x9E, + 0x4E, 0xF3, 0x32, 0x0B, 0x2E, 0xF6, 0xDB, 0x9D, 0x36, 0x46, 0x5B, 0x9B, + 0x52, 0x04, 0x00, 0x84, 0x10, 0x17, 0xA5, 0xB4, 0x75, 0x00, 0x44, 0x42, + 0x10, 0xA5, 0xC4, 0xFB, 0x18, 0x42, 0x0C, 0x21, 0x32, 0x4E, 0x42, 0x88, + 0xD3, 0x2C, 0x4F, 0xE7, 0x51, 0x1A, 0x37, 0x4C, 0xFA, 0xFE, 0x79, 0x1C, + 0x27, 0x79, 0x3A, 0x0F, 0x08, 0xA6, 0xCD, 0x3A, 0xCB, 0x73, 0x7A, 0xEE, + 0x17, 0x04, 0xE1, 0x76, 0xDD, 0x22, 0x8C, 0x8A, 0x9C, 0xEF, 0xD7, 0x0D, + 0xA7, 0x2C, 0x78, 0x13, 0xA2, 0x2B, 0x73, 0x41, 0x10, 0x5C, 0x75, 0xC5, + 0x8B, 0xAB, 0xCE, 0x49, 0x2F, 0x97, 0x70, 0x7F, 0x3F, 0xF7, 0x97, 0xF9, + 0xCB, 0xE7, 0x27, 0x63, 0xDC, 0x34, 0x2E, 0x29, 0x85, 0x98, 0xA2, 0xC8, + 0x38, 0x17, 0x34, 0xCF, 0xE8, 0xAB, 0x57, 0x9B, 0xCD, 0xA6, 0x02, 0x28, + 0x69, 0xAD, 0x79, 0xCE, 0xAB, 0xAA, 0xA4, 0x18, 0x4D, 0x72, 0x36, 0xD6, + 0xEE, 0xB7, 0xAD, 0xD3, 0xCE, 0x85, 0x74, 0x38, 0x0E, 0x08, 0x41, 0x88, + 0xF0, 0xAF, 0xA0, 0xDD, 0x94, 0x92, 0xD4, 0xE6, 0xDD, 0xDB, 0xFD, 0xB6, + 0xAD, 0x9E, 0x2F, 0x03, 0xE1, 0xD4, 0x7B, 0x57, 0xE4, 0x54, 0x70, 0xBA, + 0xEA, 0x0A, 0x46, 0x10, 0xE7, 0x84, 0xE7, 0xC2, 0xB9, 0x20, 0xB5, 0x9D, + 0x16, 0x15, 0x22, 0x30, 0xDA, 0x51, 0x8C, 0xA6, 0x59, 0x3D, 0x1C, 0x2F, + 0xCA, 0x99, 0x2F, 0xCF, 0xE7, 0x49, 0x2A, 0x0C, 0x63, 0x3F, 0xCD, 0xCE, + 0x87, 0xE7, 0x73, 0xFF, 0xD3, 0xA7, 0xFB, 0x90, 0xBC, 0x75, 0xEE, 0xEE, + 0xE9, 0x64, 0x5D, 0x4C, 0x00, 0x70, 0xCE, 0x8C, 0xD2, 0x00, 0x42, 0x00, + 0x09, 0xA7, 0x4C, 0x70, 0x51, 0x97, 0xD5, 0xCB, 0xAB, 0x6D, 0x59, 0x64, + 0x8C, 0x70, 0xCE, 0x08, 0x23, 0xB4, 0x6B, 0x1A, 0xA3, 0x0C, 0x88, 0xA9, + 0xED, 0x1A, 0x84, 0x20, 0xA7, 0xB8, 0x69, 0x0A, 0x8C, 0x40, 0x84, 0xE8, + 0xD2, 0xCB, 0x71, 0x98, 0xBC, 0x5D, 0xBA, 0xB6, 0xB8, 0xBE, 0xAA, 0x21, + 0x00, 0x4C, 0xF0, 0x4D, 0xB7, 0x2E, 0xB2, 0xB2, 0x69, 0x4B, 0x7C, 0xB5, + 0xEE, 0x08, 0x11, 0x2A, 0x60, 0x2A, 0x4A, 0x6B, 0x6D, 0xDD, 0xB4, 0xDB, + 0xF5, 0x2A, 0xE7, 0xF4, 0x87, 0x9F, 0x3F, 0xF6, 0xC3, 0x48, 0x09, 0x6B, + 0xEB, 0x2C, 0xCB, 0xC4, 0x6E, 0xB5, 0xD9, 0x75, 0xAB, 0x97, 0x57, 0xFB, + 0x4D, 0xDB, 0x70, 0x8C, 0xAB, 0xB2, 0x43, 0x11, 0xAC, 0xEB, 0x72, 0xD5, + 0x66, 0xEB, 0xAE, 0x04, 0xC0, 0xD4, 0x65, 0x16, 0x63, 0x08, 0xD1, 0xCF, + 0xF3, 0xEC, 0xBD, 0x29, 0x0A, 0xD6, 0xD4, 0x8C, 0x67, 0xC5, 0xDD, 0xD3, + 0x18, 0xA7, 0x2F, 0x94, 0x98, 0xF7, 0xB7, 0xF5, 0xAA, 0x2B, 0x84, 0x48, + 0x57, 0xBB, 0x6A, 0x73, 0xF3, 0xED, 0xC3, 0xC3, 0x49, 0x08, 0x88, 0x68, + 0xB6, 0x4C, 0x53, 0x4C, 0x98, 0x67, 0x7C, 0x18, 0xA7, 0x7E, 0x50, 0x11, + 0x02, 0x80, 0x80, 0xB1, 0x78, 0xD6, 0xE1, 0xDC, 0x4F, 0x98, 0x52, 0x08, + 0xE2, 0x6A, 0x7B, 0x83, 0x60, 0xF2, 0xD6, 0x5C, 0x86, 0x05, 0x53, 0x4C, + 0x39, 0xFF, 0xC7, 0xB7, 0x2B, 0x39, 0xCD, 0xDF, 0xEC, 0x79, 0x89, 0x46, + 0x88, 0xC8, 0x6F, 0x76, 0x2D, 0x48, 0xA0, 0x00, 0x0F, 0x7F, 0x7A, 0x49, + 0xAE, 0x36, 0xDB, 0x7E, 0xB2, 0xCB, 0xF1, 0x61, 0x9C, 0x1F, 0x5D, 0x0A, + 0xFB, 0x96, 0x77, 0x25, 0xBD, 0xCA, 0xBC, 0xB2, 0x6E, 0x71, 0x08, 0xC4, + 0xA0, 0x83, 0x74, 0xCE, 0x3F, 0xF7, 0xFA, 0xDD, 0x4B, 0xBE, 0x2A, 0x80, + 0x91, 0x0B, 0x8B, 0xF2, 0x6F, 0x5F, 0xE7, 0xBF, 0xB9, 0xDD, 0xBD, 0x7F, + 0xB9, 0xDB, 0x74, 0xAB, 0xB2, 0x2C, 0x1F, 0xCF, 0x32, 0x2F, 0x1B, 0x22, + 0xCA, 0xCF, 0x1F, 0xBE, 0x23, 0x10, 0x20, 0x84, 0x94, 0x76, 0x84, 0x20, + 0xCA, 0xB0, 0x52, 0x16, 0xC4, 0x84, 0x09, 0x65, 0x04, 0x03, 0x00, 0x9C, + 0xF7, 0xE7, 0xD3, 0x79, 0xD5, 0xD4, 0x79, 0xC6, 0x86, 0x71, 0x5A, 0x94, + 0xEB, 0xEA, 0xE2, 0xE1, 0x78, 0xDE, 0xAE, 0xEA, 0xAE, 0xC8, 0x94, 0xB1, + 0x99, 0xC8, 0x67, 0x65, 0x36, 0xDB, 0xCD, 0x32, 0x2B, 0x82, 0x08, 0x08, + 0x48, 0x29, 0xF7, 0x78, 0x1C, 0xAC, 0x0F, 0xBF, 0x46, 0x0A, 0xEB, 0xBA, + 0x6A, 0x4A, 0x71, 0x3A, 0x8C, 0xCE, 0xC5, 0x90, 0xE0, 0x87, 0x4F, 0x4F, + 0x2E, 0x00, 0x4A, 0x71, 0xD7, 0x94, 0xFD, 0x28, 0x9F, 0x4F, 0x63, 0x4C, + 0x60, 0x56, 0xEE, 0xD3, 0xDD, 0xC1, 0x27, 0xC8, 0x28, 0x5F, 0x66, 0xCD, + 0x18, 0x0B, 0x29, 0x41, 0x88, 0xCA, 0xB2, 0xB8, 0x7B, 0x3A, 0x1F, 0xCF, + 0x63, 0x4A, 0x20, 0x04, 0x38, 0x8E, 0x0B, 0x45, 0x28, 0x2F, 0x73, 0x08, + 0x01, 0xC7, 0xB4, 0x5B, 0xB5, 0x9F, 0x1F, 0x0E, 0x90, 0x88, 0x08, 0x00, + 0x65, 0x14, 0x22, 0xD4, 0x8F, 0x72, 0x92, 0xE6, 0xE1, 0xF1, 0xAC, 0x94, + 0xE9, 0x7B, 0xE5, 0xBC, 0xEF, 0x47, 0x3D, 0x4E, 0xDA, 0x5A, 0xBF, 0xCC, + 0x26, 0x2B, 0xF2, 0xBB, 0xFB, 0x53, 0x55, 0x66, 0xDA, 0xB8, 0x8F, 0x9F, + 0x8F, 0xCE, 0x47, 0x1F, 0x93, 0xB5, 0xA9, 0x2A, 0x8A, 0xB6, 0xC9, 0xD6, + 0x6D, 0x0D, 0x63, 0x58, 0xB5, 0xB5, 0x71, 0x71, 0x9E, 0x5D, 0xD7, 0x6E, + 0xA6, 0x69, 0x44, 0x08, 0x20, 0x84, 0x0F, 0x97, 0xC9, 0x18, 0x6D, 0x8C, + 0xF1, 0xCE, 0x59, 0xAB, 0x41, 0x02, 0x31, 0x24, 0x6B, 0xD5, 0x22, 0x15, + 0x23, 0x74, 0xB7, 0xED, 0x36, 0xAB, 0x0E, 0x40, 0x7C, 0x3A, 0xFF, 0x7F, + 0x55, 0xBD, 0xC7, 0xAE, 0x6D, 0xD9, 0x95, 0x5D, 0x3B, 0xBD, 0x59, 0x76, + 0xFB, 0x63, 0xAF, 0x8B, 0x08, 0x06, 0xF5, 0x10, 0xFF, 0x35, 0x00, 0x00, + 0x20, 0x00, 0x49, 0x44, 0x41, 0x54, 0x4D, 0x32, 0xA5, 0x44, 0x02, 0x0F, + 0xD0, 0xDF, 0xAB, 0x2A, 0x15, 0x5E, 0x3E, 0x20, 0xA1, 0x64, 0xF2, 0x31, + 0x48, 0x86, 0xB9, 0x71, 0x8F, 0xDB, 0x6E, 0xB9, 0xE9, 0x9D, 0x0A, 0x97, + 0x2A, 0x68, 0x7E, 0xC4, 0x18, 0x7D, 0x00, 0xB3, 0xB7, 0x36, 0xE5, 0x0C, + 0x2E, 0xD7, 0xB9, 0x6D, 0xDB, 0x4A, 0x88, 0xB6, 0x91, 0xEB, 0x5E, 0x0A, + 0x01, 0x7C, 0x72, 0x5D, 0x5F, 0xED, 0x76, 0x3D, 0xE7, 0x98, 0x4B, 0x11, + 0x7C, 0xD6, 0xC6, 0x0A, 0x41, 0xD6, 0xAB, 0x86, 0x60, 0x9C, 0x62, 0x0C, + 0xC1, 0x71, 0x46, 0xD7, 0xAB, 0x66, 0xB7, 0x6E, 0xA5, 0xE4, 0xDA, 0x38, + 0xA7, 0x43, 0x0A, 0x69, 0x1C, 0x97, 0xAF, 0x9E, 0x47, 0x5E, 0xD1, 0x94, + 0x8B, 0xA8, 0xAA, 0x9C, 0x63, 0x29, 0x08, 0x23, 0x24, 0x38, 0x3D, 0x5F, + 0x46, 0x88, 0xA0, 0x75, 0x4E, 0x1B, 0x9B, 0x52, 0xC4, 0x20, 0xD5, 0x95, + 0xE0, 0x5C, 0x3A, 0xEB, 0xAC, 0xD5, 0x31, 0x04, 0x63, 0x1C, 0x84, 0x58, + 0xC8, 0xEA, 0x7C, 0x9D, 0x9C, 0xF3, 0x04, 0xC1, 0x65, 0xD1, 0xC6, 0xB9, + 0xD7, 0xF3, 0xE0, 0x7C, 0x6C, 0x1B, 0x49, 0x30, 0xD2, 0x26, 0x40, 0x88, + 0x9D, 0xCF, 0xE7, 0x71, 0x5E, 0xD4, 0x8C, 0x08, 0xEF, 0xEA, 0xF6, 0xB0, + 0xDB, 0x4D, 0xF3, 0xAC, 0x8D, 0xA9, 0x9B, 0x16, 0x22, 0x34, 0xCD, 0x13, + 0xC6, 0x58, 0x56, 0x8D, 0xB5, 0xC6, 0x07, 0x0F, 0x0B, 0x34, 0xC6, 0xC5, + 0x9C, 0x8D, 0x0D, 0x21, 0xE6, 0x61, 0x52, 0xDA, 0x58, 0xE7, 0x03, 0x21, + 0x38, 0xC4, 0x38, 0x2E, 0xDA, 0x5A, 0x0F, 0x21, 0x1C, 0xC6, 0x69, 0xD1, + 0x2E, 0x67, 0x9C, 0x52, 0xF9, 0xF0, 0xB0, 0x6D, 0x6A, 0xB6, 0x5A, 0xF5, + 0xFB, 0x75, 0x57, 0x73, 0x0A, 0x4B, 0xC1, 0x10, 0x4A, 0x4E, 0xFB, 0x8A, + 0xC6, 0x18, 0xDF, 0xCE, 0x53, 0x23, 0x64, 0xF2, 0x65, 0x56, 0xD1, 0x45, + 0x62, 0x9C, 0x3F, 0x9E, 0x47, 0x00, 0x91, 0x10, 0xE2, 0x3A, 0xE8, 0x18, + 0xCB, 0x38, 0x9A, 0xE0, 0x1D, 0x2C, 0x40, 0x4A, 0xC1, 0x19, 0x39, 0x9F, + 0xAF, 0xA0, 0x94, 0xF5, 0xAA, 0xFB, 0xF8, 0xE1, 0xB6, 0x6B, 0x44, 0x2D, + 0xF9, 0xBA, 0xAD, 0xFE, 0xF5, 0x5F, 0xBE, 0x6F, 0x6B, 0x21, 0x28, 0x85, + 0x10, 0x5E, 0x86, 0x59, 0x6B, 0x77, 0x38, 0x6C, 0x29, 0xA5, 0xA7, 0xD3, + 0x35, 0xA6, 0x88, 0x30, 0x7E, 0x77, 0xB3, 0xFD, 0x7F, 0xFF, 0xFD, 0x07, + 0x04, 0x51, 0x0C, 0x71, 0xDD, 0x37, 0xB5, 0x64, 0x31, 0x96, 0x69, 0x72, + 0xE3, 0x6C, 0xE6, 0xD9, 0x86, 0x58, 0xCE, 0x97, 0x19, 0x22, 0x84, 0x39, + 0xD1, 0xC6, 0xE7, 0x92, 0x4B, 0x06, 0x21, 0xE6, 0x90, 0x73, 0x29, 0x65, + 0x52, 0xF6, 0xED, 0x32, 0x13, 0x8C, 0x2A, 0xC1, 0x11, 0x46, 0x05, 0x96, + 0xAF, 0x2C, 0x10, 0x1B, 0x83, 0x76, 0x61, 0xD1, 0xAE, 0x92, 0xD5, 0xE5, + 0x3A, 0x9F, 0xC7, 0xD9, 0xC5, 0x68, 0x8C, 0x19, 0xE7, 0xA5, 0x40, 0x68, + 0xBD, 0x75, 0x3E, 0x22, 0xC4, 0x10, 0xC2, 0x5D, 0x53, 0x4B, 0x29, 0x31, + 0x42, 0x7D, 0xDB, 0x3C, 0xDC, 0xED, 0x56, 0x9D, 0xDC, 0xF4, 0x92, 0x10, + 0xB4, 0xE9, 0x6B, 0x4C, 0x49, 0x2C, 0x25, 0xB9, 0xD0, 0xD6, 0xF4, 0xE1, + 0x71, 0xDF, 0xB7, 0xAD, 0x10, 0x22, 0xA6, 0xEC, 0x4C, 0x9C, 0x16, 0x3D, + 0x6B, 0x13, 0x62, 0xC6, 0xDF, 0x7C, 0x78, 0x6F, 0x5C, 0x9C, 0x8D, 0xF1, + 0x21, 0x5B, 0xEB, 0x9C, 0x35, 0xB5, 0xC0, 0xAF, 0x97, 0x61, 0xD1, 0x1E, + 0x42, 0xF4, 0xEE, 0x61, 0xDB, 0x55, 0x72, 0xBF, 0xBF, 0xEF, 0x37, 0xB7, + 0x6E, 0x3E, 0x6B, 0x63, 0x8D, 0xF3, 0x99, 0x77, 0xA7, 0x71, 0x1E, 0x86, + 0x61, 0x98, 0xCD, 0xB4, 0xCC, 0xBF, 0x3E, 0xBF, 0xBE, 0x1D, 0x87, 0xE3, + 0x79, 0x18, 0xA7, 0x51, 0x2B, 0x3D, 0x2F, 0x66, 0x9A, 0x97, 0xE7, 0xB7, + 0x6B, 0xE2, 0x37, 0xC3, 0xE2, 0xBB, 0x7E, 0x5F, 0x00, 0x36, 0xCB, 0x17, + 0x29, 0xD9, 0xA2, 0xDC, 0x38, 0x6A, 0x9F, 0x59, 0x80, 0x3B, 0x08, 0x91, + 0xB1, 0x51, 0x2D, 0x3A, 0x38, 0x75, 0xFB, 0xEE, 0xBB, 0xE1, 0xFC, 0x64, + 0x8D, 0x5D, 0x6F, 0x6A, 0xC6, 0xC9, 0xE5, 0x32, 0x43, 0xCC, 0x01, 0xA2, + 0x29, 0xA5, 0x52, 0xA0, 0x94, 0xB2, 0x6A, 0x36, 0x76, 0xB9, 0xFC, 0xCB, + 0x07, 0x36, 0xCF, 0xDA, 0x26, 0xB8, 0xDB, 0x6E, 0x7E, 0xB7, 0xC7, 0x29, + 0xAA, 0x0C, 0x90, 0x10, 0xB0, 0xE2, 0x25, 0x5A, 0xF3, 0xF2, 0xF6, 0xE5, + 0xAA, 0xAE, 0x10, 0xD1, 0x3F, 0xFD, 0xF0, 0xFA, 0x7A, 0xD1, 0x14, 0x7B, + 0x6D, 0xA3, 0x76, 0xD0, 0x99, 0xC8, 0x50, 0x38, 0xEB, 0xF8, 0x34, 0xC4, + 0x5C, 0xF2, 0xCB, 0x65, 0x38, 0xAA, 0xF8, 0xFF, 0x7F, 0x99, 0x6B, 0xAA, + 0x1F, 0x0E, 0x78, 0xD1, 0x0E, 0xA3, 0xD3, 0x6F, 0x3F, 0xCA, 0x4A, 0x50, + 0xEF, 0x34, 0x82, 0xE8, 0xE1, 0xFE, 0xC1, 0x67, 0xE7, 0x12, 0x6A, 0xD6, + 0x8F, 0xE3, 0xE9, 0xA9, 0x22, 0x69, 0xBB, 0x96, 0x10, 0x22, 0xC6, 0x08, + 0x63, 0xC4, 0xEA, 0x00, 0x21, 0x28, 0x00, 0x72, 0x8E, 0x85, 0x20, 0x36, + 0x26, 0xA5, 0x74, 0x2D, 0x05, 0x41, 0x04, 0x82, 0xB8, 0x18, 0x7F, 0xB3, + 0xDB, 0x68, 0xAF, 0x9B, 0xAA, 0xFA, 0xE3, 0xEF, 0xBF, 0x75, 0x5A, 0xB7, + 0x6D, 0xEF, 0x42, 0xDE, 0x6E, 0x57, 0x10, 0xA4, 0xA6, 0xAA, 0xB4, 0xB6, + 0xCE, 0xC7, 0xE3, 0x75, 0xB8, 0xCE, 0x36, 0xE5, 0x8C, 0x71, 0x59, 0x6F, + 0xBB, 0x5A, 0xA2, 0x79, 0x34, 0xC3, 0x64, 0x4E, 0xD7, 0x85, 0x71, 0xD9, + 0x77, 0x4C, 0x08, 0x4A, 0x28, 0x7C, 0x7E, 0xBE, 0x2A, 0x15, 0x31, 0xA6, + 0xEB, 0xD5, 0x8A, 0x60, 0x8C, 0x09, 0xAE, 0x05, 0x0B, 0xDE, 0xE6, 0x94, + 0x53, 0x0A, 0x7D, 0x27, 0x6F, 0x76, 0xFD, 0x7F, 0xFC, 0xF0, 0x19, 0x53, + 0x22, 0x2A, 0xD1, 0x36, 0xCD, 0x30, 0x2D, 0x4A, 0x5B, 0x46, 0x98, 0xB7, + 0xFE, 0xF8, 0x36, 0xDE, 0x1C, 0x0E, 0x6F, 0xD7, 0x01, 0x00, 0x2C, 0xAB, + 0x2A, 0x17, 0x60, 0x94, 0x63, 0x8C, 0x7A, 0xEF, 0x43, 0x4C, 0x29, 0xE5, + 0x9C, 0x00, 0x40, 0xA8, 0x40, 0x04, 0x31, 0xA4, 0x8C, 0x0E, 0x83, 0xB6, + 0x3E, 0xC6, 0x18, 0xD7, 0xEB, 0x7A, 0x18, 0x55, 0x06, 0xB9, 0x92, 0x0C, + 0x63, 0x8C, 0x31, 0x3E, 0x1E, 0xE7, 0x79, 0xB6, 0x7D, 0x5F, 0xCB, 0x8A, + 0xD5, 0x55, 0x25, 0x44, 0x7D, 0x3C, 0xCD, 0x08, 0x89, 0x71, 0x9A, 0xB5, + 0x31, 0x10, 0xC3, 0xEB, 0xB8, 0xCC, 0x6A, 0x49, 0x29, 0x41, 0x00, 0xAD, + 0xB3, 0x29, 0x85, 0xBE, 0x6F, 0x9B, 0x5A, 0x78, 0xE7, 0xC6, 0x59, 0x0B, + 0xCA, 0x41, 0x41, 0x25, 0x17, 0xC1, 0x19, 0x42, 0x50, 0x34, 0x14, 0x80, + 0xD4, 0xB5, 0x6D, 0x01, 0x44, 0x3B, 0x7F, 0x1E, 0xC6, 0xC9, 0x18, 0xEB, + 0xCB, 0x70, 0x5D, 0xDA, 0xAE, 0x8E, 0x29, 0x33, 0x4E, 0xBB, 0x4E, 0x0C, + 0xC3, 0x94, 0x53, 0xE1, 0x94, 0x56, 0x92, 0x3B, 0xE7, 0x4B, 0x49, 0x6D, + 0x53, 0x77, 0x6D, 0x6D, 0x8D, 0x2F, 0x00, 0x48, 0xCE, 0x2E, 0x97, 0x29, + 0x95, 0x4C, 0x18, 0x2E, 0x20, 0xBD, 0xBC, 0x5E, 0xAD, 0x8D, 0x10, 0x23, + 0x6B, 0xDD, 0x34, 0x29, 0xEF, 0x33, 0xC6, 0xD0, 0xF9, 0xB8, 0x28, 0x57, + 0x37, 0x55, 0xF0, 0x4E, 0x70, 0xDA, 0x54, 0xB2, 0x12, 0x2C, 0xFA, 0xA8, + 0x8D, 0xCB, 0x39, 0x19, 0x63, 0x40, 0x29, 0x39, 0x17, 0x84, 0xD0, 0xA2, + 0x94, 0x76, 0x1E, 0x82, 0x6C, 0xAD, 0xF3, 0x31, 0xC5, 0x18, 0x20, 0x80, + 0xDE, 0x47, 0x46, 0x60, 0x29, 0x60, 0x5C, 0xAC, 0xF2, 0xFE, 0x7C, 0x1D, + 0x08, 0xA3, 0x82, 0x11, 0x88, 0xA8, 0x94, 0xD2, 0x7B, 0xEF, 0xBC, 0xAD, + 0xAA, 0xFA, 0xE9, 0xE5, 0xB9, 0x80, 0xC2, 0x85, 0x2C, 0x00, 0x12, 0x82, + 0x21, 0xCC, 0xDE, 0x05, 0x8C, 0x71, 0x86, 0xC0, 0x18, 0x4B, 0x09, 0xD9, + 0x6D, 0xD6, 0x7D, 0x23, 0x2B, 0x41, 0x3F, 0xDE, 0xEF, 0xFF, 0xCB, 0xF7, + 0xDF, 0x76, 0x75, 0x45, 0x09, 0x62, 0x84, 0xBC, 0x9D, 0xAE, 0xDA, 0x7A, + 0xCA, 0x58, 0x4C, 0x05, 0x16, 0x20, 0x04, 0x2B, 0x39, 0xAF, 0x9A, 0x0A, + 0x41, 0x88, 0x0A, 0xBC, 0xDB, 0xEF, 0x4E, 0xE7, 0x63, 0x29, 0x00, 0x41, + 0x88, 0x51, 0x21, 0x10, 0x61, 0xC4, 0x43, 0x42, 0xCA, 0x25, 0x17, 0xB3, + 0xB1, 0x6E, 0x58, 0xA6, 0x98, 0x32, 0x63, 0x82, 0x51, 0x4E, 0x29, 0x5C, + 0x77, 0x92, 0x62, 0x7A, 0xD8, 0x1D, 0x52, 0x28, 0x2F, 0x2F, 0x67, 0x8C, + 0xE8, 0xAA, 0xED, 0x57, 0x4D, 0x5B, 0x62, 0xAC, 0x04, 0x0B, 0xCE, 0x11, + 0x4C, 0xAC, 0xD5, 0x21, 0xE6, 0xF7, 0x1F, 0xEE, 0x0B, 0x8C, 0xB7, 0x87, + 0xFE, 0x7E, 0xBF, 0x9D, 0x67, 0x73, 0x3E, 0x8F, 0x10, 0x00, 0xA5, 0xDD, + 0x66, 0xB5, 0x1E, 0x07, 0x05, 0x11, 0x46, 0x00, 0xBD, 0x1C, 0x47, 0x17, + 0xE0, 0xF1, 0xA2, 0x20, 0x20, 0x05, 0xC2, 0xB7, 0xF3, 0x8C, 0x30, 0xD5, + 0xDA, 0x39, 0x1B, 0xAC, 0xF5, 0xCB, 0x62, 0x0B, 0x28, 0x10, 0xA1, 0xF3, + 0x75, 0x51, 0x2E, 0x6A, 0xE3, 0x86, 0x59, 0x2F, 0xDA, 0xF9, 0x18, 0x05, + 0x63, 0x8C, 0xE0, 0x59, 0xD9, 0x59, 0xEB, 0xE3, 0x75, 0x32, 0xDE, 0x29, + 0x6D, 0x84, 0xA0, 0x9C, 0xF2, 0x71, 0xD6, 0xDA, 0xD8, 0x61, 0x5E, 0x20, + 0xCA, 0x82, 0x13, 0x29, 0xEB, 0x98, 0xD3, 0x30, 0xCF, 0xE3, 0xA2, 0x5E, + 0x4F, 0x97, 0xC5, 0xDA, 0xF3, 0xB0, 0x8C, 0xB3, 0xF6, 0x21, 0x62, 0x4C, + 0x16, 0xA5, 0xB5, 0xB1, 0x82, 0x55, 0xAB, 0xAE, 0x82, 0x10, 0x2C, 0xC6, + 0x22, 0x02, 0x0F, 0xFB, 0x75, 0xD7, 0x8B, 0x94, 0x93, 0xB5, 0x41, 0x6B, + 0x37, 0x4D, 0xF3, 0x30, 0x2A, 0x6D, 0x5D, 0x4C, 0xF9, 0x72, 0x9D, 0xF1, + 0xBB, 0xDB, 0xC3, 0xBF, 0xFD, 0xFB, 0x7F, 0xD8, 0x10, 0x38, 0xE7, 0xE3, + 0x38, 0x50, 0x98, 0x18, 0x81, 0xCA, 0x78, 0x8A, 0xD9, 0x37, 0x1F, 0x6E, + 0x0F, 0xDB, 0x86, 0x00, 0x96, 0x7C, 0xF0, 0x80, 0xAA, 0x65, 0x9E, 0xB5, + 0x4D, 0xAC, 0xBD, 0x1C, 0x9F, 0x9D, 0x1E, 0xB5, 0x75, 0xCA, 0xDA, 0x97, + 0xE3, 0x15, 0x63, 0x14, 0x52, 0x2A, 0xB0, 0x8C, 0x93, 0xBD, 0x0C, 0xDA, + 0x85, 0x68, 0x5C, 0x84, 0x10, 0x5A, 0x63, 0xB4, 0x0E, 0x54, 0xF6, 0x3F, + 0xFD, 0xED, 0x4F, 0xDE, 0xEA, 0xE7, 0xE7, 0x71, 0x99, 0x15, 0x46, 0x88, + 0x75, 0xDF, 0x24, 0x48, 0x4F, 0x2F, 0x3F, 0x6E, 0xF7, 0xEF, 0x86, 0xF1, + 0xF2, 0xF0, 0xE1, 0xBB, 0xA6, 0x6D, 0x8E, 0x2F, 0x6F, 0x8C, 0x00, 0x0C, + 0xC1, 0x62, 0x9C, 0x0F, 0xC9, 0xBB, 0xF0, 0xB5, 0x82, 0x90, 0x73, 0xA1, + 0x18, 0x6C, 0x6F, 0x3F, 0x61, 0xF5, 0xF9, 0xC0, 0x15, 0xA7, 0x84, 0xB2, + 0xAA, 0xE0, 0x3E, 0x47, 0x73, 0xD3, 0x39, 0x08, 0xC0, 0x7E, 0xDF, 0x3F, + 0x1F, 0x4F, 0x6F, 0xB3, 0xBA, 0xAA, 0x34, 0x7B, 0x36, 0x59, 0xF7, 0x76, + 0x99, 0xEF, 0xD7, 0x14, 0x80, 0x82, 0x11, 0x5E, 0x4C, 0x5C, 0x2C, 0x70, + 0x3E, 0x3E, 0x8F, 0x5E, 0x47, 0x84, 0x90, 0xFE, 0xFC, 0x66, 0x17, 0x9B, + 0x7F, 0xF7, 0x48, 0x7E, 0xF3, 0xBE, 0xFA, 0xF3, 0x2F, 0x9A, 0xE2, 0x94, + 0x10, 0xFE, 0x72, 0x36, 0x32, 0xBA, 0x21, 0xD1, 0xD3, 0x58, 0x40, 0xC1, + 0xC6, 0xBB, 0xBE, 0x95, 0x57, 0x8D, 0xD7, 0x2D, 0xF9, 0xA7, 0xEF, 0xDF, + 0xAF, 0x56, 0x2B, 0x41, 0x70, 0xD7, 0x56, 0xDE, 0x05, 0x1F, 0xD2, 0x30, + 0xAA, 0xA6, 0xA6, 0x94, 0xE2, 0x59, 0x19, 0x6B, 0x03, 0xA3, 0xAC, 0xAE, + 0xF9, 0xEF, 0xFE, 0xF0, 0x5E, 0x48, 0xB1, 0xEE, 0xAB, 0xDD, 0xA1, 0x5F, + 0xF7, 0xD5, 0xC7, 0x77, 0xF7, 0x5D, 0x57, 0x4B, 0x29, 0x08, 0xC3, 0xDB, + 0xC3, 0xEA, 0xF9, 0xF4, 0xF6, 0xE3, 0xAF, 0x5F, 0xB6, 0xDB, 0xF5, 0xAA, + 0x16, 0x21, 0x85, 0xA7, 0xE3, 0xC5, 0xFB, 0x14, 0x63, 0x7A, 0xFF, 0xFE, + 0x36, 0x07, 0xFB, 0xF2, 0x7A, 0x7D, 0x7E, 0x5B, 0xAC, 0xF3, 0x77, 0x87, + 0x5D, 0x4E, 0x65, 0x9E, 0xF4, 0x30, 0xAA, 0x45, 0x59, 0xED, 0x63, 0x53, + 0x57, 0x08, 0xA2, 0x18, 0x63, 0x4A, 0x19, 0x40, 0x40, 0x29, 0x8D, 0x21, + 0xBE, 0x7F, 0x77, 0xC8, 0xA0, 0x84, 0x10, 0xAF, 0xD3, 0xB2, 0x68, 0x7B, + 0x77, 0xD8, 0xEC, 0xB7, 0xFD, 0x75, 0x5E, 0x40, 0x29, 0x95, 0x14, 0x10, + 0x82, 0xA6, 0xE2, 0xA3, 0x72, 0x42, 0x4A, 0xEF, 0x22, 0x65, 0xF2, 0xED, + 0xED, 0xFA, 0xFC, 0x72, 0xED, 0xFA, 0x7E, 0x9A, 0x74, 0x4C, 0x65, 0xBB, + 0xEB, 0x11, 0x22, 0x39, 0xC3, 0x0C, 0x40, 0x08, 0x01, 0x80, 0x52, 0x72, + 0xA1, 0x9C, 0x14, 0x00, 0x8D, 0x0E, 0xCE, 0x86, 0x5A, 0x52, 0x2E, 0x08, + 0x17, 0xF4, 0x7A, 0x55, 0x21, 0x14, 0xA5, 0x4D, 0x2E, 0xA5, 0xE4, 0x92, + 0x52, 0x3E, 0x5E, 0xCC, 0xCB, 0xDB, 0x7C, 0xBA, 0x9C, 0xCF, 0xD7, 0x93, + 0x8F, 0xB9, 0xE4, 0xE8, 0x43, 0x39, 0x0D, 0x53, 0x4A, 0x91, 0x33, 0x6E, + 0x9D, 0x4D, 0x39, 0x48, 0xC1, 0xD7, 0xAB, 0x6E, 0xBF, 0xE9, 0xA6, 0x69, + 0x89, 0x39, 0xDC, 0xDD, 0xB6, 0x9B, 0xB5, 0x5C, 0x6D, 0x2A, 0x82, 0x09, + 0xC5, 0x25, 0x65, 0x5B, 0x20, 0x9A, 0x17, 0x9D, 0x4B, 0x0E, 0x29, 0x9D, + 0x86, 0x51, 0x5B, 0xDF, 0x76, 0x2D, 0x28, 0x45, 0x69, 0x43, 0x99, 0xB8, + 0x9C, 0x87, 0x98, 0xC2, 0x6E, 0xD7, 0x31, 0x86, 0x4B, 0x8E, 0x4A, 0x69, + 0x08, 0xC2, 0x6E, 0xDB, 0x0F, 0xB3, 0x1D, 0xC6, 0x85, 0x73, 0x69, 0xAC, + 0xFB, 0xF1, 0xE7, 0x2F, 0x10, 0x64, 0x42, 0xC9, 0x4F, 0x3F, 0xBF, 0x09, + 0xCE, 0xAD, 0x8F, 0x8B, 0x72, 0xB9, 0x40, 0xE7, 0xBC, 0xB1, 0xDE, 0x87, + 0xC8, 0x18, 0x1D, 0xA7, 0x79, 0xD1, 0x46, 0x70, 0x46, 0x10, 0x96, 0x14, + 0xEF, 0xB7, 0x9D, 0xAC, 0xC4, 0xF3, 0xCB, 0x11, 0x63, 0x48, 0x08, 0x42, + 0x25, 0x63, 0x4C, 0x0A, 0x42, 0xB1, 0xA0, 0x49, 0x1B, 0x8C, 0x60, 0x4A, + 0xF9, 0x2B, 0x49, 0xB1, 0xAB, 0x25, 0xE3, 0x34, 0xC4, 0x88, 0x20, 0x34, + 0x36, 0x16, 0x04, 0x21, 0x82, 0x31, 0x15, 0xAD, 0x55, 0x29, 0x80, 0x33, + 0xA1, 0xB5, 0xCA, 0x39, 0xA7, 0x94, 0x2E, 0xC3, 0x35, 0x95, 0x1C, 0x7C, + 0xF0, 0xCE, 0x85, 0xE8, 0xB5, 0x56, 0x3E, 0xF8, 0xAF, 0x40, 0xED, 0xF7, + 0xB7, 0xBB, 0x7F, 0xFD, 0xC3, 0xB7, 0x37, 0xDB, 0xDD, 0x7E, 0xB5, 0x7E, + 0x7F, 0x7B, 0xFB, 0xE1, 0xEE, 0xBE, 0xE6, 0xB5, 0x73, 0x11, 0x63, 0xBC, + 0xDF, 0xB4, 0xB7, 0xDB, 0xD6, 0x68, 0xE7, 0x7C, 0x08, 0x21, 0xCE, 0x8B, + 0xDE, 0xAC, 0x6B, 0xC1, 0x89, 0x5A, 0x54, 0x2D, 0xA5, 0xF3, 0x81, 0x40, + 0x54, 0x52, 0x52, 0xDA, 0xC6, 0x54, 0xAC, 0x0B, 0x42, 0xD4, 0x8C, 0x31, + 0x2E, 0x57, 0xA5, 0xA0, 0x5C, 0xCA, 0x69, 0x98, 0xC7, 0x79, 0x36, 0xD6, + 0x87, 0x94, 0xDA, 0xBA, 0xDE, 0x6F, 0xBA, 0x5D, 0xD7, 0x6C, 0x9A, 0x0E, + 0xC4, 0xB2, 0xE9, 0x6B, 0x0C, 0x1C, 0x86, 0x68, 0xD5, 0xAC, 0x50, 0x41, + 0x6A, 0xD1, 0xCE, 0x59, 0x3D, 0xAB, 0x1C, 0x13, 0xA1, 0x74, 0x18, 0x67, + 0x59, 0xB1, 0x79, 0x99, 0x39, 0x67, 0xC6, 0x86, 0x9C, 0x81, 0xA0, 0xF4, + 0x3C, 0xCC, 0x8C, 0xA3, 0xFB, 0x9B, 0x5D, 0x57, 0xD7, 0xDE, 0x85, 0xAA, + 0xA2, 0x21, 0xD9, 0xAA, 0x22, 0x29, 0x03, 0xC1, 0x04, 0xA5, 0x18, 0xC2, + 0xFC, 0xE9, 0xE3, 0xED, 0x6E, 0xD7, 0x85, 0x18, 0x4F, 0xD7, 0x49, 0x19, + 0x9F, 0x53, 0xD6, 0x8B, 0x75, 0x2E, 0x36, 0xB5, 0x00, 0x00, 0xCE, 0x4A, + 0x2F, 0xC6, 0x41, 0x04, 0x53, 0x2E, 0xFB, 0x4D, 0x4F, 0x09, 0x1E, 0xA7, + 0x85, 0x52, 0x42, 0x08, 0xC6, 0x08, 0xCE, 0xB3, 0xA5, 0x84, 0x9E, 0x87, + 0x09, 0x14, 0x80, 0x31, 0x9A, 0x16, 0xC5, 0x28, 0x4A, 0xA9, 0x4C, 0xB3, + 0xD6, 0xD6, 0x18, 0xE7, 0x53, 0xCA, 0xAB, 0xBE, 0x6B, 0xAA, 0x4A, 0x69, + 0x5B, 0x00, 0x98, 0x17, 0x13, 0x62, 0x44, 0x10, 0xF9, 0x98, 0x66, 0x65, + 0x6B, 0x29, 0x0B, 0xC0, 0x4D, 0x25, 0x56, 0x7D, 0xA7, 0xEC, 0x9C, 0xB2, + 0x4D, 0x3E, 0x69, 0xEB, 0x03, 0xC8, 0xCA, 0x6A, 0xE3, 0xBC, 0x36, 0x96, + 0x30, 0xEA, 0x42, 0xC4, 0x9B, 0xB6, 0x31, 0x21, 0x3E, 0x3C, 0x7E, 0xBA, + 0x3D, 0xAC, 0x36, 0xEB, 0x1D, 0xCA, 0xF1, 0xFE, 0xF1, 0x3D, 0x82, 0xEC, + 0xE1, 0xEE, 0x70, 0xB3, 0xEB, 0xB3, 0x8F, 0x9C, 0x30, 0x6B, 0x9D, 0xB2, + 0x0E, 0x34, 0x7B, 0x40, 0xC5, 0xE9, 0xE9, 0xEF, 0x0C, 0x86, 0x5C, 0xCA, + 0x30, 0xAB, 0x45, 0xDB, 0x97, 0xD3, 0x85, 0x71, 0xA2, 0x8C, 0x1B, 0x46, + 0x13, 0x13, 0x38, 0x9E, 0x67, 0x00, 0x11, 0x25, 0x14, 0x61, 0x32, 0x8E, + 0xD7, 0x4A, 0xCA, 0xEB, 0xA8, 0x51, 0x32, 0x9B, 0x4E, 0x9E, 0xCE, 0x23, + 0x26, 0x62, 0x9A, 0x35, 0x13, 0x5D, 0xD3, 0xAD, 0x9E, 0x3F, 0xFF, 0xB9, + 0xA9, 0xD7, 0x08, 0xB3, 0xBB, 0xC7, 0x0F, 0xBF, 0x7E, 0xFE, 0x91, 0x42, + 0xD7, 0xD5, 0x08, 0x12, 0xA4, 0x5C, 0xB4, 0x3E, 0x22, 0x84, 0x9D, 0x77, + 0x10, 0xC4, 0x92, 0x52, 0x0A, 0xA1, 0xED, 0x37, 0xD9, 0x5B, 0xB5, 0x2C, + 0x4D, 0x53, 0xE9, 0xC4, 0x18, 0xE7, 0xA7, 0x51, 0x69, 0x17, 0x6B, 0x49, + 0xAE, 0xA3, 0xB9, 0x8C, 0xD7, 0xD3, 0xE2, 0x05, 0x17, 0x87, 0xAA, 0x50, + 0x60, 0x4F, 0x53, 0xA9, 0x39, 0x69, 0x24, 0x41, 0x08, 0x7B, 0x1F, 0x66, + 0xE3, 0xCF, 0xCA, 0xD6, 0x92, 0x19, 0x97, 0xBA, 0x8A, 0x72, 0x86, 0xB9, + 0x80, 0xCA, 0xE4, 0x1F, 0x9E, 0x0C, 0x27, 0x84, 0x40, 0x3B, 0x2D, 0x81, + 0x42, 0x58, 0xB1, 0xFA, 0x6A, 0xEA, 0x55, 0xBF, 0xF2, 0x85, 0xBF, 0x0E, + 0x0E, 0x92, 0x56, 0x6B, 0xF3, 0xE5, 0xCB, 0xD3, 0xA0, 0xD2, 0x38, 0xDB, + 0xA6, 0xA9, 0xEF, 0xEE, 0x37, 0xD6, 0xFA, 0xEB, 0x34, 0x0B, 0x4A, 0x08, + 0x82, 0x8C, 0x50, 0x4A, 0xD0, 0xA7, 0x87, 0xDD, 0xA7, 0x87, 0xC3, 0xFB, + 0xC7, 0xED, 0x38, 0x2D, 0x25, 0x27, 0x21, 0x49, 0xB0, 0xCE, 0xEB, 0xA0, + 0x96, 0x65, 0x1C, 0x47, 0x88, 0xB2, 0xF5, 0xCE, 0x87, 0x00, 0x61, 0xD9, + 0xAD, 0x7B, 0x46, 0x30, 0x40, 0x45, 0x69, 0xB5, 0xEE, 0xDA, 0xC3, 0xCD, + 0x7A, 0x1A, 0x17, 0x49, 0x50, 0x0A, 0xCE, 0x39, 0x50, 0xB7, 0xDD, 0xA6, + 0x6F, 0xDF, 0xDD, 0x6D, 0xBA, 0xB6, 0x0E, 0x3E, 0x0C, 0xD3, 0xB2, 0x68, + 0x27, 0x6B, 0xAE, 0xB5, 0x79, 0xBB, 0x4C, 0x21, 0x46, 0x8C, 0x21, 0xC6, + 0xD8, 0x19, 0xBF, 0xEA, 0x1B, 0x1F, 0xC3, 0x75, 0x9C, 0xAD, 0xF3, 0x25, + 0xE7, 0x79, 0x31, 0x08, 0x14, 0xEB, 0xA2, 0x0F, 0xD9, 0x87, 0x38, 0x29, + 0x7D, 0xBB, 0x5B, 0x6B, 0xE3, 0xEA, 0xA6, 0x09, 0x31, 0xE7, 0x02, 0x9D, + 0x0F, 0xA9, 0x24, 0x6D, 0x1C, 0x61, 0x62, 0x9E, 0x95, 0xB5, 0x7E, 0x9E, + 0x2D, 0x22, 0x04, 0x21, 0xB4, 0xCC, 0x6A, 0x1C, 0x16, 0x21, 0x44, 0xDB, + 0xD4, 0x84, 0xE0, 0xB7, 0xD7, 0xE1, 0x32, 0x2E, 0xCA, 0x78, 0x8C, 0x91, + 0x10, 0xFC, 0x7C, 0x9E, 0xAD, 0x0B, 0x29, 0xA7, 0xBA, 0xA9, 0x04, 0x67, + 0x20, 0x17, 0x42, 0x40, 0x01, 0xF9, 0xED, 0x3C, 0xC5, 0x94, 0x8D, 0xF5, + 0xA8, 0xB8, 0xDF, 0x7D, 0x5A, 0xBF, 0x0D, 0x4E, 0x69, 0x87, 0x31, 0x32, + 0xCE, 0xDE, 0xAC, 0xE9, 0xBF, 0xFC, 0xA6, 0xCD, 0x48, 0x04, 0x57, 0x30, + 0x44, 0x08, 0x94, 0x7F, 0xFA, 0x6E, 0xBF, 0xDB, 0xB6, 0x9C, 0x02, 0xC1, + 0xD0, 0x78, 0x1D, 0x7C, 0x8A, 0xB3, 0xF2, 0xC7, 0xD3, 0x14, 0x73, 0x84, + 0x08, 0x4C, 0x7A, 0xD1, 0xCA, 0x8E, 0x93, 0x46, 0x18, 0xF5, 0x5D, 0xBD, + 0x2C, 0xFA, 0x97, 0x5F, 0x9E, 0x52, 0x8A, 0x00, 0xC2, 0x1C, 0xE2, 0x76, + 0xD7, 0x32, 0x86, 0x28, 0x2D, 0x84, 0x62, 0x65, 0xD3, 0xF9, 0x3C, 0x61, + 0x8C, 0x30, 0x2E, 0x7F, 0xFD, 0xF1, 0xE7, 0x69, 0x5E, 0x38, 0x67, 0xD7, + 0x41, 0x51, 0x4A, 0xA5, 0x94, 0x8B, 0xB2, 0x3E, 0xE5, 0x71, 0x52, 0x31, + 0x97, 0x9C, 0x4B, 0x4E, 0xA9, 0x16, 0x1C, 0x94, 0x1C, 0x63, 0xB8, 0xDB, + 0xAE, 0x18, 0x01, 0x6F, 0xA7, 0x41, 0x2B, 0xED, 0xBD, 0x37, 0xC6, 0x70, + 0xC9, 0x30, 0x86, 0xDE, 0x07, 0x59, 0x89, 0x58, 0xD0, 0xA8, 0x4C, 0x4A, + 0x09, 0x02, 0x54, 0x0A, 0xB8, 0xD9, 0x75, 0x29, 0xE5, 0x69, 0xD6, 0x10, + 0x41, 0x42, 0x89, 0xD1, 0x2E, 0xE5, 0x1C, 0x53, 0xB6, 0xD6, 0xE5, 0x52, + 0x4A, 0x29, 0x52, 0x56, 0xA5, 0x00, 0x67, 0xAD, 0x0F, 0xDE, 0x58, 0xEB, + 0x82, 0x4F, 0x29, 0x41, 0x00, 0x4A, 0xC9, 0x39, 0x67, 0xCE, 0x29, 0xC8, + 0x05, 0x40, 0x70, 0xBB, 0x5D, 0xFD, 0xEE, 0xFD, 0x47, 0x35, 0x59, 0x6D, + 0x42, 0xCA, 0x60, 0x9A, 0x4C, 0x4A, 0x59, 0xBB, 0xF0, 0xE5, 0xF9, 0xCD, + 0x87, 0xA0, 0x8D, 0xB7, 0x3E, 0xED, 0x36, 0xFD, 0xE3, 0xCD, 0x86, 0x52, + 0xF8, 0xED, 0xC7, 0x1B, 0x81, 0x31, 0xA7, 0x78, 0xBB, 0xEE, 0x40, 0x86, + 0x52, 0xD6, 0x08, 0x02, 0xA5, 0x54, 0xD3, 0x54, 0x04, 0x23, 0x8C, 0xD9, + 0x6A, 0xBD, 0x89, 0x21, 0x1D, 0xCF, 0x63, 0x08, 0xC1, 0x3A, 0x37, 0xCC, + 0x0B, 0xA3, 0xE8, 0x0F, 0xDF, 0xDE, 0x13, 0x4C, 0x5B, 0x29, 0x36, 0x0D, + 0xE7, 0x94, 0x5E, 0xC6, 0xD9, 0x85, 0xE0, 0xBD, 0x0F, 0xD1, 0x13, 0x8A, + 0x29, 0xC6, 0x31, 0x84, 0xED, 0xBE, 0x43, 0x04, 0xC4, 0xE2, 0x79, 0x25, + 0x4E, 0xC7, 0xB1, 0x00, 0xC0, 0x28, 0x22, 0x10, 0xC2, 0x08, 0xB5, 0x72, + 0x31, 0x64, 0x63, 0xED, 0x76, 0xDD, 0xFC, 0xE6, 0xFD, 0xED, 0xC3, 0xCD, + 0xFE, 0xF1, 0xB0, 0x5B, 0xF5, 0x62, 0xBF, 0xAD, 0xF7, 0xEB, 0xF6, 0xC3, + 0xC3, 0x81, 0x61, 0x96, 0x9D, 0x23, 0xB8, 0xDC, 0xDE, 0x6D, 0x8D, 0x35, + 0xD7, 0xEB, 0x84, 0x09, 0x4A, 0x19, 0x74, 0x9D, 0xAC, 0x1B, 0x11, 0x63, + 0x59, 0x94, 0xE1, 0x8C, 0x39, 0xE7, 0x63, 0x4C, 0xDA, 0xF9, 0x5C, 0x0A, + 0x25, 0x98, 0x73, 0xD2, 0xD4, 0xF2, 0xAB, 0x3A, 0x32, 0xA5, 0x14, 0x42, + 0xA4, 0x94, 0x5A, 0x1B, 0x53, 0xCA, 0xCE, 0x39, 0x84, 0xB2, 0x60, 0x94, + 0x62, 0xC2, 0x19, 0xD3, 0xD6, 0x10, 0x02, 0x53, 0x4A, 0x87, 0xDD, 0x8A, + 0x51, 0x74, 0xBE, 0x0E, 0x29, 0xE7, 0x59, 0x2F, 0xB3, 0xD6, 0x84, 0x16, + 0xC6, 0xA1, 0x35, 0xC1, 0x78, 0x3F, 0x19, 0x7B, 0xBC, 0x4E, 0x21, 0x96, + 0x92, 0x10, 0x82, 0x88, 0x72, 0x92, 0x13, 0x7C, 0x7D, 0x1D, 0x6D, 0xF0, + 0x00, 0xA2, 0xCB, 0x65, 0x62, 0x82, 0x62, 0x42, 0xA6, 0x49, 0xE1, 0xDF, + 0x7F, 0xFF, 0xCD, 0xCD, 0xDD, 0xA3, 0x56, 0xE6, 0xFE, 0xE6, 0x66, 0xDD, + 0xF5, 0xAB, 0x55, 0x4F, 0x38, 0xE1, 0x04, 0x1B, 0x65, 0xAC, 0xF1, 0x9C, + 0x8A, 0x69, 0x31, 0x93, 0x32, 0xDE, 0x5B, 0x9F, 0xD1, 0xE7, 0x9F, 0xFF, + 0x6E, 0xD5, 0xB0, 0x58, 0x37, 0x2E, 0x7A, 0x36, 0x2E, 0x95, 0x84, 0x40, + 0x0E, 0x21, 0x2A, 0x13, 0x0A, 0x80, 0x08, 0x41, 0xCA, 0xD8, 0x30, 0xD9, + 0x49, 0xD9, 0x65, 0x36, 0x94, 0x89, 0x4F, 0xBF, 0xF9, 0xA3, 0xD1, 0x7A, + 0xB3, 0xDE, 0xAE, 0x7B, 0x49, 0x45, 0x07, 0x20, 0xBD, 0x5E, 0x87, 0x55, + 0x03, 0xD7, 0x37, 0xBF, 0xE9, 0xE1, 0xB4, 0x16, 0x09, 0xB4, 0x1F, 0xFE, + 0xFA, 0xE7, 0x7F, 0xFB, 0xDB, 0x0F, 0x7F, 0xFA, 0x97, 0x7B, 0xB9, 0x6F, + 0xF1, 0x5F, 0x3E, 0x0F, 0x1C, 0x95, 0xEF, 0xEE, 0xFA, 0x49, 0x85, 0x69, + 0xD1, 0x31, 0xFC, 0xE3, 0x02, 0xDF, 0x6F, 0xF6, 0x35, 0x50, 0xFB, 0x26, + 0xF5, 0xD8, 0xFF, 0x38, 0xD1, 0x6F, 0x6F, 0x5B, 0x7D, 0xFD, 0x8C, 0x70, + 0xBE, 0x5F, 0x77, 0x46, 0xEB, 0xDF, 0x3F, 0x88, 0x9A, 0x63, 0x88, 0x50, + 0x8B, 0xCD, 0x68, 0x0B, 0x84, 0x64, 0xBF, 0x2E, 0x08, 0x85, 0x04, 0x22, + 0xA2, 0x65, 0xB1, 0xE1, 0x77, 0xB7, 0x7C, 0xD7, 0xF1, 0xBF, 0xBE, 0xD8, + 0xD9, 0xC4, 0x49, 0xC7, 0x97, 0x73, 0xC4, 0x08, 0x3C, 0xEE, 0xB9, 0x89, + 0x99, 0x32, 0xA8, 0x0C, 0xB8, 0x4C, 0x6E, 0x0A, 0xE0, 0xE7, 0xA7, 0x25, + 0xA7, 0xFC, 0xEB, 0xCB, 0xE9, 0xF9, 0xF4, 0xC2, 0x05, 0x57, 0x8B, 0x8F, + 0xF6, 0x4A, 0x91, 0x9B, 0xE7, 0xC5, 0x7B, 0x0F, 0x52, 0xAC, 0x24, 0xDB, + 0xAD, 0xEA, 0xFD, 0xBA, 0xFA, 0xE6, 0xE3, 0xCD, 0xFD, 0xFD, 0xFA, 0xC3, + 0xC3, 0x6E, 0xD3, 0x37, 0x39, 0x06, 0x88, 0x0A, 0x22, 0x50, 0x4A, 0x0A, + 0x60, 0xC1, 0x04, 0x1B, 0xED, 0xEB, 0x9A, 0x04, 0xEF, 0x17, 0x65, 0x4F, + 0xC7, 0xE5, 0xF5, 0xF9, 0x5A, 0x62, 0x71, 0x36, 0x68, 0xE5, 0x8C, 0xF6, + 0x52, 0x8A, 0xBE, 0x6D, 0x39, 0xC1, 0xEB, 0xB6, 0x69, 0x2B, 0x79, 0xB3, + 0xDF, 0x34, 0x55, 0xBD, 0xEA, 0xAA, 0x75, 0x5F, 0x7D, 0x85, 0xE2, 0x57, + 0x95, 0xDC, 0x6F, 0x57, 0xEB, 0xAE, 0x86, 0xA5, 0x5C, 0xC7, 0x19, 0x42, + 0x40, 0x10, 0x14, 0x82, 0xCD, 0xB3, 0x66, 0x8C, 0x4E, 0x4A, 0xFF, 0xFA, + 0x7C, 0xDE, 0x6F, 0xB7, 0x31, 0xC5, 0x02, 0xA0, 0x10, 0x5C, 0x99, 0xE0, + 0x7C, 0x00, 0x10, 0x7D, 0x75, 0x17, 0x0D, 0xB3, 0xEE, 0x9A, 0x6A, 0xB3, + 0xEE, 0xCE, 0x83, 0x9A, 0x16, 0xB5, 0x28, 0x0B, 0x20, 0x48, 0x09, 0x58, + 0x1B, 0x76, 0xDB, 0xF5, 0x7A, 0xB3, 0x1A, 0x27, 0x45, 0x29, 0x13, 0x9C, + 0xC5, 0x98, 0x28, 0xC7, 0x31, 0xA6, 0x10, 0x0B, 0x82, 0x90, 0x32, 0x8C, + 0x09, 0xB6, 0x2E, 0xA6, 0x94, 0x9D, 0x4F, 0x21, 0xC6, 0xAE, 0x97, 0xFB, + 0xFD, 0x0A, 0x41, 0x74, 0x3E, 0x0F, 0x18, 0x63, 0x4A, 0x51, 0xB7, 0xC2, + 0x9F, 0xBF, 0x1C, 0x73, 0xB6, 0x75, 0x2D, 0x7F, 0xFB, 0xAE, 0xD2, 0x6A, + 0xF1, 0xC1, 0xDF, 0xEC, 0xF0, 0xDB, 0x39, 0xFC, 0xD7, 0xEF, 0xAB, 0xDF, + 0x7D, 0xAA, 0x29, 0xC2, 0x75, 0xB7, 0xE1, 0x0C, 0xDF, 0x1E, 0xAA, 0x4D, + 0x4F, 0xA5, 0x20, 0x18, 0x33, 0x98, 0x32, 0x0C, 0x69, 0x98, 0x97, 0xBF, + 0xFD, 0x72, 0x55, 0xC6, 0x63, 0x82, 0xA6, 0x69, 0xA9, 0x6A, 0x02, 0x11, + 0xF0, 0xA1, 0x28, 0x6D, 0x9C, 0x4B, 0x31, 0xC4, 0x71, 0x5C, 0x08, 0x46, + 0x29, 0x84, 0xCB, 0x65, 0xF4, 0x21, 0x4C, 0x83, 0x2E, 0x39, 0x0A, 0x86, + 0x84, 0xE4, 0x29, 0x03, 0x42, 0x11, 0xA1, 0xE8, 0xF5, 0x78, 0x24, 0x18, + 0xF5, 0x2B, 0xB1, 0x68, 0xF7, 0x76, 0x9A, 0x41, 0x01, 0x10, 0x82, 0x54, + 0x8A, 0xB1, 0x5E, 0x72, 0x52, 0x09, 0xCE, 0x39, 0xDD, 0x74, 0xD5, 0xFD, + 0xCD, 0xED, 0xC7, 0xC7, 0xDB, 0x86, 0xB3, 0xF7, 0x0F, 0x7B, 0x00, 0x8B, + 0xF3, 0x0E, 0x13, 0x6C, 0x9C, 0x8B, 0x31, 0x52, 0x4A, 0xAA, 0x9A, 0xFA, + 0x5C, 0x0A, 0x00, 0x31, 0xE5, 0x98, 0xC3, 0xAA, 0x16, 0x0F, 0xFB, 0x1E, + 0x21, 0x18, 0x42, 0x7A, 0x38, 0x6C, 0x26, 0xA5, 0xBD, 0x8F, 0x39, 0x27, + 0x8C, 0x11, 0x97, 0x42, 0x56, 0x9C, 0x10, 0x3C, 0x2F, 0x1A, 0x42, 0x08, + 0x41, 0x19, 0xC6, 0xB1, 0xAA, 0xDB, 0x18, 0x82, 0x0F, 0x36, 0xE7, 0x02, + 0x00, 0x24, 0x04, 0x53, 0x4A, 0x4B, 0xCE, 0x8C, 0x12, 0x0C, 0xD1, 0xAA, + 0xA9, 0xDE, 0xDD, 0xDD, 0x23, 0xCC, 0x6D, 0x88, 0xE7, 0xCB, 0xD9, 0x87, + 0xD8, 0xD4, 0x0D, 0xA1, 0x98, 0x61, 0xF0, 0x72, 0x3C, 0x4D, 0x4A, 0x1B, + 0x1F, 0xCF, 0xC3, 0xEC, 0x43, 0x3C, 0x0D, 0xF3, 0x7A, 0xD5, 0x56, 0x92, + 0x5B, 0x1D, 0x18, 0xE5, 0x08, 0x40, 0x42, 0x68, 0x55, 0xB5, 0x55, 0x8D, + 0x05, 0xA7, 0x6D, 0xDB, 0x69, 0xE3, 0x38, 0x17, 0x31, 0x80, 0xE3, 0x75, + 0x3A, 0x0D, 0x63, 0x88, 0x61, 0x9A, 0x97, 0x55, 0x57, 0x7F, 0xFF, 0xEE, + 0xE1, 0x76, 0xD3, 0x82, 0x94, 0xFA, 0xA6, 0x62, 0x94, 0xBC, 0x5D, 0x46, + 0x65, 0x7D, 0x55, 0xD7, 0x00, 0xE2, 0xB7, 0xEB, 0x78, 0xBA, 0x0E, 0x25, + 0xE5, 0x0C, 0x12, 0x00, 0xE5, 0xF9, 0xE5, 0x34, 0x29, 0x7D, 0x7F, 0x73, + 0x28, 0x29, 0x6D, 0xB7, 0x9B, 0x87, 0xDB, 0xDB, 0x5A, 0x48, 0xC9, 0xE4, + 0xA6, 0x6B, 0x2B, 0xCE, 0x08, 0x61, 0xB5, 0xAC, 0x18, 0xE1, 0x29, 0xE6, + 0xE7, 0xD7, 0xF3, 0xE9, 0x3C, 0x45, 0x5F, 0xA2, 0x4F, 0x18, 0x92, 0xAE, + 0xAA, 0x6F, 0x77, 0xFD, 0xCD, 0x76, 0x7D, 0xBD, 0x4E, 0xAF, 0xA7, 0xE9, + 0x7C, 0x5D, 0x9C, 0x0B, 0x9C, 0xD2, 0x65, 0xD2, 0xA5, 0xC0, 0x46, 0xF0, + 0xC3, 0x76, 0x65, 0x6D, 0xD8, 0xF4, 0x2D, 0xC1, 0xF8, 0x32, 0x29, 0x29, + 0xE9, 0x61, 0xDB, 0x34, 0x95, 0x24, 0x18, 0x59, 0x1B, 0x86, 0x49, 0x9F, + 0xC7, 0xA5, 0x64, 0x40, 0x30, 0xA4, 0x04, 0x7E, 0x7C, 0xB7, 0xAF, 0x05, + 0xF9, 0xF8, 0xB0, 0xBE, 0xDD, 0x36, 0xEF, 0xEE, 0xB7, 0x7D, 0xC3, 0x6F, + 0x6E, 0xDA, 0xD5, 0xAA, 0x2A, 0x39, 0x3A, 0x6F, 0x8D, 0xD7, 0x4C, 0x52, + 0xCA, 0x40, 0x8E, 0xA1, 0x69, 0x99, 0x90, 0x04, 0x11, 0x58, 0x0A, 0x2A, + 0x25, 0xBF, 0x9E, 0xCF, 0x31, 0x64, 0xEF, 0xD3, 0x79, 0x98, 0xE6, 0xC5, + 0x2E, 0xCA, 0x87, 0xF8, 0x75, 0xD3, 0x80, 0x98, 0x0A, 0x80, 0xD0, 0x68, + 0xD7, 0xB5, 0x6D, 0x5B, 0x4B, 0xFC, 0xFE, 0xF1, 0x5D, 0x2C, 0xD2, 0x5A, + 0x1D, 0xCD, 0xA2, 0x97, 0x71, 0x18, 0xA7, 0x97, 0xD7, 0xA7, 0xE1, 0x7A, + 0x99, 0x86, 0x6B, 0xCA, 0x9E, 0x35, 0xDB, 0xB7, 0xD3, 0x65, 0x5E, 0x66, + 0xCA, 0x48, 0x48, 0xF1, 0x74, 0x3A, 0xF6, 0x5D, 0x1B, 0x42, 0x98, 0xB5, + 0x01, 0x05, 0x74, 0x35, 0x83, 0x10, 0x1A, 0xE3, 0x73, 0xCE, 0x05, 0x42, + 0x4E, 0x69, 0x88, 0x59, 0x19, 0x7B, 0xB3, 0x5D, 0xAD, 0x57, 0xEB, 0x0F, + 0xDF, 0xFE, 0xFE, 0x2F, 0x7F, 0xFA, 0x37, 0x9C, 0xFD, 0xE3, 0xBA, 0x7B, + 0x7E, 0xBB, 0xAC, 0xAB, 0x24, 0x80, 0xF3, 0x09, 0xCC, 0xB3, 0x8E, 0x89, + 0xEC, 0xFB, 0x6A, 0x59, 0xC6, 0x9F, 0x5E, 0x96, 0xE8, 0xEC, 0xA7, 0x2D, + 0xFA, 0x7E, 0x4F, 0xFE, 0xD7, 0xE7, 0xF1, 0x3A, 0x07, 0x49, 0x90, 0xB1, + 0x1E, 0x14, 0xFF, 0x61, 0xDF, 0xFE, 0xE1, 0xDD, 0xEA, 0x32, 0x2F, 0x48, + 0xEE, 0x36, 0x02, 0x3D, 0xA2, 0x1F, 0x0F, 0xDB, 0x36, 0x8B, 0x9B, 0x93, + 0xA3, 0x71, 0xF8, 0xF1, 0x6E, 0x4B, 0xEE, 0x0E, 0x5B, 0x14, 0x0D, 0x4A, + 0x3E, 0x79, 0x4B, 0x60, 0xAC, 0xEB, 0x6A, 0xD4, 0x61, 0xDB, 0xD3, 0x93, + 0x72, 0x67, 0x1D, 0x5F, 0xA6, 0x78, 0xD5, 0x31, 0xE4, 0x84, 0x12, 0xB6, + 0x21, 0xFF, 0x72, 0xB6, 0x88, 0x22, 0xED, 0x53, 0x57, 0x97, 0x02, 0xE1, + 0xAA, 0xA3, 0x94, 0xA2, 0xA7, 0x37, 0x37, 0xAA, 0xEC, 0x22, 0x46, 0xB4, + 0x7E, 0x7D, 0x55, 0x08, 0x94, 0x9B, 0x5D, 0x17, 0xA3, 0xA3, 0x1C, 0x54, + 0xF5, 0x6E, 0x1C, 0x06, 0x49, 0x4A, 0x55, 0x89, 0xB6, 0x6B, 0x10, 0x2C, + 0x31, 0xFA, 0x55, 0x5F, 0xF5, 0x35, 0x69, 0x1A, 0x76, 0x1D, 0x14, 0xA4, + 0x48, 0x3B, 0xFF, 0xF4, 0x74, 0x81, 0xA4, 0x5C, 0x66, 0x35, 0x4E, 0x86, + 0x10, 0x7C, 0xBE, 0x2E, 0x7F, 0xFB, 0xF1, 0x95, 0x31, 0x02, 0x31, 0x34, + 0x36, 0x2E, 0x3A, 0x00, 0xCC, 0x5C, 0x48, 0xB9, 0x80, 0x10, 0x13, 0x17, + 0x54, 0x48, 0xB1, 0xCC, 0x2E, 0x86, 0x18, 0x82, 0x8F, 0x31, 0x59, 0x1F, + 0xAF, 0x93, 0x76, 0x3E, 0x18, 0xEB, 0x43, 0x4C, 0x8B, 0x36, 0x5F, 0x69, + 0x4D, 0x31, 0xA5, 0xBE, 0xAD, 0xFB, 0x55, 0x75, 0xB3, 0xDF, 0xAE, 0x9A, + 0x86, 0x62, 0x94, 0x53, 0xDE, 0x74, 0xCD, 0xF1, 0x32, 0x5C, 0x86, 0x71, + 0xDD, 0x77, 0x7D, 0xD3, 0x0E, 0xF3, 0x42, 0x29, 0x8F, 0x21, 0x1D, 0x76, + 0x3D, 0xC2, 0x08, 0x13, 0x9C, 0x52, 0x1A, 0xE6, 0x25, 0xF8, 0xB0, 0xEA, + 0xBA, 0xBF, 0x7F, 0x7E, 0x9D, 0xE6, 0x45, 0x5B, 0xCB, 0x19, 0x4E, 0x39, + 0xA7, 0x98, 0xB7, 0xAB, 0xB6, 0xAA, 0x24, 0x63, 0x94, 0x4B, 0x9A, 0x72, + 0xC6, 0x18, 0x09, 0x29, 0xAD, 0xF6, 0xDE, 0x45, 0x6D, 0x9C, 0x77, 0xA1, + 0x96, 0x12, 0x21, 0x54, 0x0A, 0xE4, 0x15, 0x1D, 0x86, 0x25, 0xE5, 0xDC, + 0xD4, 0x32, 0xF9, 0x3C, 0x0C, 0x8B, 0x0D, 0x46, 0x48, 0x52, 0x42, 0xC0, + 0x28, 0xC5, 0x90, 0xBF, 0x7B, 0x5F, 0x7F, 0xFF, 0xA1, 0x21, 0x14, 0x6A, + 0xBD, 0xFC, 0xF3, 0x77, 0x0D, 0x04, 0x19, 0x02, 0xFC, 0xFD, 0x43, 0x95, + 0x52, 0x10, 0x15, 0xDF, 0x6E, 0x1B, 0x4E, 0x52, 0x5B, 0x11, 0xC9, 0x82, + 0xE4, 0x8C, 0x92, 0x42, 0x10, 0x2B, 0x21, 0xD9, 0xE8, 0x36, 0xB7, 0xBC, + 0xED, 0xB9, 0x73, 0x7E, 0xD5, 0x11, 0x8A, 0xD1, 0x30, 0x58, 0x88, 0x92, + 0x0F, 0x85, 0x10, 0x0A, 0x61, 0xBE, 0xB9, 0xED, 0xDA, 0x5A, 0x20, 0x00, + 0x6C, 0x44, 0x84, 0x22, 0xB5, 0x18, 0x58, 0x52, 0x25, 0xD8, 0xF5, 0x3C, + 0x41, 0x08, 0x5D, 0x0A, 0xC7, 0xF3, 0x9C, 0x73, 0xC6, 0x10, 0x9E, 0xAF, + 0x83, 0xD2, 0xBE, 0x6F, 0xEA, 0x56, 0xD2, 0xF7, 0x0F, 0xDB, 0xDD, 0xBA, + 0xFF, 0x70, 0xB7, 0xFB, 0xE7, 0xDF, 0x7E, 0xBC, 0xD9, 0xF4, 0x1F, 0xEE, + 0x77, 0xF7, 0x87, 0xED, 0xED, 0xBE, 0xBB, 0x59, 0x0B, 0x46, 0xE0, 0x3C, + 0xEB, 0x71, 0x56, 0x9B, 0xF5, 0x0A, 0x20, 0x18, 0x53, 0xA4, 0x94, 0x50, + 0x82, 0x11, 0xCA, 0x25, 0x16, 0x42, 0x50, 0xF0, 0x9E, 0x62, 0xF8, 0xFE, + 0x6E, 0x0F, 0x21, 0x88, 0x29, 0xC6, 0x5C, 0xCE, 0xC3, 0xA4, 0x8D, 0xF3, + 0x31, 0x53, 0x46, 0xFA, 0xBE, 0x4D, 0x29, 0xC7, 0x18, 0x62, 0x48, 0x8C, + 0x52, 0x08, 0xA0, 0x76, 0xBE, 0xAA, 0x1B, 0xEF, 0xBD, 0xF7, 0xAE, 0x80, + 0xAF, 0xB4, 0x63, 0x10, 0x62, 0x4C, 0x29, 0x15, 0x00, 0x08, 0x41, 0xEB, + 0xB6, 0xDE, 0xAC, 0xD6, 0x08, 0xF3, 0x90, 0x81, 0xF5, 0xC9, 0x58, 0xD7, + 0xB7, 0xED, 0x66, 0xD5, 0xE5, 0x9C, 0x8D, 0x35, 0xEB, 0x75, 0x5B, 0x40, + 0x96, 0x15, 0xA7, 0x8C, 0x12, 0x4A, 0x10, 0xC2, 0x6A, 0xB1, 0xE3, 0x62, + 0xDB, 0xAE, 0x91, 0x75, 0xF5, 0x76, 0x1A, 0x00, 0x84, 0xA5, 0x24, 0x67, + 0x4C, 0x5D, 0x55, 0xE3, 0x62, 0x00, 0xC0, 0x25, 0x03, 0x6D, 0xFD, 0xB2, + 0xE8, 0xBA, 0x6E, 0x32, 0x00, 0xFB, 0x5D, 0x7B, 0xB3, 0xD9, 0x01, 0x80, + 0x8D, 0xB1, 0x82, 0x53, 0x00, 0x80, 0x0B, 0x9E, 0x71, 0x12, 0x52, 0x8E, + 0x19, 0x2F, 0xC6, 0x5D, 0xA7, 0x39, 0xBA, 0xC0, 0x28, 0x79, 0xBB, 0xCC, + 0x29, 0xFA, 0xB6, 0x62, 0xF7, 0xFB, 0x9B, 0x8A, 0x71, 0x82, 0x70, 0x55, + 0x57, 0x6F, 0xC7, 0xE3, 0x62, 0x8C, 0xF5, 0x56, 0x7F, 0xED, 0xF7, 0x52, + 0x1E, 0x73, 0x7A, 0x7B, 0x3B, 0x2F, 0xD6, 0xFE, 0xF4, 0x74, 0x3C, 0x0D, + 0xF6, 0xE5, 0x34, 0xA6, 0x0C, 0x25, 0x17, 0x10, 0x63, 0x21, 0x24, 0xC6, + 0xA4, 0xEF, 0xE4, 0x7A, 0xDD, 0x72, 0x46, 0xEB, 0x8A, 0x8F, 0x93, 0xE2, + 0x8C, 0x31, 0x8C, 0x28, 0x46, 0x94, 0x60, 0x8C, 0x11, 0x67, 0x04, 0x94, + 0xB2, 0x6A, 0x44, 0x5D, 0x53, 0x08, 0xD0, 0xED, 0x76, 0x6B, 0x8C, 0x39, + 0x5E, 0xE7, 0x94, 0x0A, 0xA7, 0xE4, 0xE1, 0x6E, 0x43, 0x29, 0xEA, 0x1A, + 0xDA, 0x4A, 0xD6, 0x56, 0xD5, 0x32, 0x9B, 0xAE, 0xAD, 0x82, 0x8B, 0x39, + 0x17, 0xAD, 0x7C, 0x53, 0x8B, 0x52, 0x60, 0xD7, 0x49, 0x2E, 0x28, 0xA1, + 0x50, 0xD6, 0x22, 0xF8, 0x94, 0x73, 0xC2, 0x18, 0x4C, 0x83, 0x72, 0x21, + 0x26, 0x5C, 0x42, 0xC8, 0x5F, 0x0B, 0x73, 0x08, 0x82, 0xEB, 0xB4, 0xFC, + 0xF2, 0xE5, 0xB4, 0x59, 0xB5, 0x10, 0xE5, 0x61, 0x98, 0x0B, 0x2C, 0xD1, + 0x87, 0xBA, 0xAA, 0x20, 0x44, 0x97, 0x71, 0x22, 0x11, 0x94, 0xD5, 0xBA, + 0x39, 0x9E, 0x5E, 0x46, 0xA7, 0x08, 0x61, 0x00, 0x02, 0x6F, 0x6D, 0xD3, + 0xC8, 0x55, 0x5D, 0x55, 0xAB, 0x5B, 0x9B, 0xF1, 0xE9, 0x72, 0x2E, 0x25, + 0x2B, 0xAD, 0x9A, 0xCD, 0xDD, 0xCD, 0xFD, 0x87, 0xB7, 0xA7, 0xBF, 0x6B, + 0x63, 0x00, 0x00, 0x84, 0x91, 0xE3, 0x79, 0x24, 0x04, 0x43, 0x04, 0x8D, + 0x09, 0x02, 0x12, 0xE3, 0x42, 0x8C, 0xFE, 0xFD, 0xED, 0xB6, 0x11, 0xEC, + 0xF1, 0xDB, 0x7F, 0xBA, 0x5E, 0x4F, 0xFB, 0x1A, 0xDE, 0x1E, 0x56, 0xA5, + 0xB8, 0x3F, 0x3E, 0x22, 0x52, 0x32, 0x6A, 0xD8, 0x37, 0x1B, 0xE8, 0x63, + 0x20, 0xEC, 0xF8, 0x83, 0xFE, 0x34, 0x2E, 0xB2, 0x2D, 0x2F, 0x7F, 0xFC, + 0x7E, 0x87, 0x5C, 0xF8, 0x32, 0x4C, 0xE7, 0x39, 0x75, 0x92, 0x29, 0x9F, + 0x0F, 0x1B, 0xF9, 0xFB, 0xBB, 0xBC, 0xE9, 0x01, 0x41, 0x99, 0xA3, 0x8D, + 0xE5, 0x8F, 0xE5, 0xF2, 0xD7, 0xB2, 0x7A, 0x77, 0xA4, 0x1F, 0xE6, 0xE1, + 0xB4, 0x29, 0x9F, 0x9F, 0xC7, 0x78, 0x77, 0x53, 0x3D, 0x9F, 0x4E, 0x8B, + 0x8A, 0xEF, 0xB6, 0x02, 0xE3, 0xE6, 0x7F, 0xFC, 0xE7, 0xD3, 0xFB, 0x77, + 0x8D, 0xF5, 0xE0, 0xCF, 0xAF, 0xF3, 0x4F, 0xA7, 0x42, 0x10, 0x3C, 0xEC, + 0xF1, 0xDB, 0x35, 0x61, 0x00, 0x3E, 0x6D, 0xF3, 0x92, 0xF0, 0xEC, 0xCA, + 0xA8, 0x22, 0xE7, 0x60, 0x56, 0x05, 0x42, 0xE0, 0x63, 0xF9, 0xE5, 0xA7, + 0x18, 0x3C, 0x20, 0x34, 0x33, 0xEA, 0x2A, 0x01, 0xB7, 0x1D, 0x6C, 0xEB, + 0x15, 0xC6, 0x28, 0xC6, 0x58, 0x10, 0x34, 0x26, 0x42, 0x10, 0xA7, 0x69, + 0xA1, 0x92, 0x25, 0xEF, 0xBB, 0x5E, 0x70, 0x0C, 0x4A, 0x0A, 0xE7, 0xC1, + 0xFA, 0x9C, 0x5F, 0xBE, 0x0C, 0xF8, 0x8D, 0xE4, 0x5C, 0x96, 0xC9, 0xFC, + 0xF6, 0xBB, 0xFD, 0xB8, 0x58, 0x6B, 0xB3, 0xF6, 0xC9, 0xDA, 0x38, 0x6B, + 0x3F, 0x8D, 0x2F, 0x5D, 0x5F, 0xAB, 0xC5, 0x61, 0x42, 0x08, 0x26, 0x4D, + 0x25, 0x8D, 0x73, 0x8C, 0x11, 0x51, 0xD3, 0x79, 0xD6, 0xD3, 0x62, 0x82, + 0x8B, 0x08, 0x43, 0x6B, 0x3D, 0xE3, 0x14, 0x61, 0x84, 0x31, 0x82, 0x00, + 0xB5, 0xAC, 0xB2, 0x3A, 0x1A, 0x6F, 0xB7, 0xDB, 0x5E, 0x2D, 0xD6, 0x84, + 0x70, 0x7E, 0x1B, 0x00, 0x80, 0xBB, 0xF5, 0x6A, 0xB7, 0xED, 0x38, 0x41, + 0x00, 0xC4, 0x9B, 0x6D, 0xF5, 0xDF, 0xFF, 0xE7, 0x9F, 0xD6, 0x5D, 0x3B, + 0x8C, 0xCB, 0xB4, 0x18, 0xC1, 0x2B, 0x29, 0x65, 0x57, 0x57, 0x97, 0x59, + 0x05, 0x1F, 0x5D, 0x88, 0xA0, 0x14, 0x2E, 0xD8, 0x4F, 0xCF, 0xAF, 0xC6, + 0xDA, 0xC7, 0xDB, 0xC3, 0xDD, 0xCD, 0x81, 0x31, 0x72, 0xBD, 0x5C, 0x38, + 0x67, 0x5C, 0xF2, 0x98, 0xF2, 0xA2, 0x14, 0x13, 0x14, 0x22, 0x2E, 0x04, + 0xBB, 0x5E, 0xE6, 0xAA, 0x6D, 0x64, 0x25, 0x3E, 0xFF, 0xFA, 0xA2, 0x94, + 0x0F, 0x3E, 0x75, 0x7D, 0x2D, 0x24, 0xC9, 0x05, 0x40, 0x08, 0x05, 0xC5, + 0xCF, 0x2F, 0xC3, 0xFD, 0xED, 0xCA, 0x07, 0x57, 0x72, 0xF9, 0x70, 0x2F, + 0x61, 0x30, 0x42, 0xE4, 0x5E, 0x74, 0xEF, 0xF7, 0xF4, 0xA7, 0x57, 0x35, + 0x3B, 0xF7, 0xE9, 0x63, 0xBD, 0x65, 0xF0, 0xBA, 0xE0, 0xFF, 0xE7, 0x9F, + 0x9A, 0x61, 0x72, 0x3E, 0x80, 0xCD, 0x96, 0xCE, 0xCB, 0x15, 0x12, 0x92, + 0xC3, 0xC8, 0x44, 0x6B, 0x03, 0x08, 0xCE, 0x4A, 0x01, 0x49, 0x9D, 0x5B, + 0x94, 0x09, 0x25, 0x97, 0x31, 0xFC, 0xFE, 0x83, 0x30, 0x2E, 0xFC, 0xFB, + 0x5F, 0x26, 0x4C, 0xD0, 0x7E, 0x4F, 0xAF, 0x03, 0x70, 0xDE, 0x3F, 0x3C, + 0xD4, 0xF7, 0x77, 0xDD, 0xF1, 0x65, 0x94, 0x92, 0x7E, 0xEA, 0x7A, 0xAD, + 0x46, 0x86, 0x20, 0x86, 0xC5, 0xE8, 0xB0, 0xDB, 0xEE, 0x52, 0xC9, 0x12, + 0x64, 0x18, 0xE1, 0xC7, 0xF7, 0x0F, 0x20, 0xFB, 0x94, 0xBC, 0x94, 0x92, + 0x12, 0x5C, 0x32, 0xA0, 0x94, 0x29, 0xED, 0x09, 0x02, 0x25, 0x05, 0xAB, + 0xE7, 0x10, 0x01, 0x44, 0xC4, 0x3B, 0x7F, 0xC9, 0x8E, 0x30, 0x52, 0x55, + 0xF0, 0x8E, 0x35, 0x7D, 0xD7, 0xC7, 0xD4, 0x5D, 0x86, 0x6E, 0xB1, 0xE1, + 0x78, 0x1E, 0xB5, 0x51, 0xAB, 0x5A, 0x2E, 0xCA, 0xE7, 0x90, 0xBA, 0xBE, + 0xA6, 0x8C, 0x09, 0xCE, 0x67, 0xE5, 0x5E, 0xCF, 0x97, 0x5A, 0xD0, 0x5A, + 0xB0, 0xD9, 0x38, 0x08, 0x60, 0x0C, 0x41, 0x2B, 0x23, 0x18, 0x8D, 0x21, + 0xB9, 0x10, 0x4B, 0x01, 0x29, 0x25, 0x63, 0x74, 0x8C, 0x11, 0x43, 0x98, + 0x4A, 0x01, 0x00, 0x00, 0x00, 0x20, 0x00, 0xA5, 0x14, 0x08, 0xA1, 0x75, + 0x81, 0x6F, 0x39, 0x23, 0x34, 0x15, 0x94, 0x12, 0xA0, 0xA2, 0xFA, 0xB0, + 0xDD, 0x0B, 0x10, 0x9C, 0x35, 0xD6, 0xFB, 0x61, 0x5E, 0xA4, 0xA4, 0x00, + 0x94, 0xE3, 0xF9, 0x3A, 0xCF, 0x6E, 0xBB, 0xED, 0x01, 0x04, 0xA0, 0x00, + 0x58, 0xE0, 0xA4, 0xAC, 0x09, 0xBE, 0x40, 0x00, 0x11, 0xC8, 0xD1, 0xCB, + 0xAA, 0x53, 0x9E, 0xFF, 0xF2, 0xFC, 0x74, 0xB7, 0xDB, 0x96, 0x12, 0x2A, + 0x81, 0x0E, 0xBB, 0xD5, 0xEB, 0x79, 0x96, 0x5C, 0x40, 0x88, 0x31, 0x13, + 0x39, 0xA6, 0xE7, 0xD3, 0xD8, 0x4A, 0x16, 0x53, 0x76, 0x3E, 0x12, 0x8A, + 0x73, 0x41, 0x11, 0x64, 0xAD, 0x67, 0x49, 0x49, 0xC5, 0x99, 0xF3, 0x65, + 0xDD, 0xB5, 0x1F, 0xEE, 0x36, 0x4D, 0xC5, 0x43, 0xC4, 0xBF, 0x7C, 0x7E, + 0x5D, 0xAC, 0xCD, 0x00, 0x0E, 0xF3, 0x62, 0x9D, 0xDF, 0x6D, 0x5B, 0x08, + 0x20, 0xE7, 0xAC, 0xAA, 0x25, 0x63, 0x74, 0x7F, 0xD3, 0x82, 0x82, 0x66, + 0xED, 0x66, 0x9D, 0xC6, 0x69, 0xFC, 0xF8, 0xEE, 0xA6, 0x6B, 0x1B, 0x63, + 0xDC, 0xB4, 0x98, 0xBE, 0xEB, 0x8C, 0x71, 0x9C, 0xB2, 0xDF, 0x7E, 0x7A, + 0x98, 0x66, 0x43, 0x10, 0x61, 0x8C, 0x8E, 0xE3, 0x90, 0x0B, 0xC4, 0x84, + 0x11, 0x92, 0x16, 0xAD, 0x42, 0x4C, 0x92, 0x33, 0x6F, 0xE2, 0xCD, 0xCD, + 0x6E, 0x98, 0x97, 0xF3, 0xB8, 0x20, 0x04, 0x41, 0x49, 0x9F, 0xEE, 0x36, + 0x29, 0xA7, 0xEB, 0xAC, 0x71, 0x23, 0xBF, 0x4C, 0x17, 0xE7, 0xFC, 0xEF, + 0xBF, 0x7B, 0xCC, 0x09, 0x8D, 0xA3, 0x0D, 0x29, 0xC9, 0x0A, 0x4B, 0x8A, + 0x34, 0x42, 0x6A, 0xB4, 0x98, 0x62, 0xC2, 0xB0, 0x5A, 0x0C, 0x93, 0x54, + 0x08, 0x89, 0x40, 0x16, 0x9C, 0x52, 0x42, 0x31, 0x63, 0xE8, 0x00, 0x9E, + 0x3E, 0x5F, 0x65, 0x55, 0x1B, 0x1D, 0x52, 0x4E, 0xDF, 0x7C, 0xD8, 0x1C, + 0xB6, 0xF2, 0xE9, 0x55, 0x63, 0x02, 0x77, 0xDB, 0xDE, 0x28, 0xEB, 0x62, + 0xFA, 0xF5, 0xE5, 0x88, 0x08, 0xC2, 0x08, 0x67, 0x88, 0x79, 0xD0, 0xE7, + 0x9E, 0x78, 0x2A, 0x1A, 0x97, 0x8A, 0x60, 0xA8, 0x60, 0xE1, 0x12, 0xC1, + 0xB4, 0x2A, 0x00, 0x9C, 0x8E, 0x2F, 0x8C, 0x12, 0xCE, 0x69, 0xD5, 0xED, + 0xCE, 0x97, 0xA3, 0xF7, 0x8E, 0x57, 0xB5, 0xD1, 0xEA, 0xAB, 0x29, 0xA8, + 0x64, 0x50, 0x4A, 0xF9, 0xD7, 0x6F, 0xB8, 0x09, 0xE5, 0x32, 0xE9, 0xBB, + 0x4D, 0xFB, 0xC7, 0xC7, 0x1D, 0xAF, 0xD7, 0xCF, 0xA7, 0xEB, 0x43, 0x13, + 0xBE, 0x5D, 0x99, 0x9A, 0xC4, 0x35, 0xF1, 0x92, 0x97, 0x94, 0x9D, 0xB3, + 0x7A, 0x57, 0x25, 0xC4, 0xC9, 0xD3, 0xF1, 0x0D, 0xB2, 0xDE, 0xBB, 0xF0, + 0x58, 0x9D, 0x1F, 0xB7, 0x38, 0x25, 0x77, 0xBB, 0x15, 0x77, 0x3B, 0x5E, + 0x91, 0xF2, 0x70, 0x4B, 0x36, 0x2D, 0x3A, 0x6A, 0xEB, 0x53, 0xB2, 0x2E, + 0x80, 0x22, 0xDE, 0xF5, 0x0C, 0x8A, 0xEE, 0x3F, 0x8E, 0xD8, 0xCE, 0xBF, + 0xEC, 0x2B, 0xBD, 0x62, 0xB1, 0xE6, 0x5E, 0x7B, 0xE6, 0x8A, 0xFC, 0xF1, + 0xA4, 0xD6, 0xDB, 0xCD, 0x64, 0x20, 0x00, 0x59, 0x85, 0x94, 0x8B, 0xFE, + 0x75, 0x20, 0x92, 0xC1, 0xDB, 0x75, 0x19, 0x54, 0x19, 0xAF, 0xB9, 0xA9, + 0xE1, 0xD3, 0x35, 0x11, 0x02, 0x85, 0x2C, 0xB3, 0x01, 0xCE, 0x17, 0xC6, + 0x10, 0x43, 0xA0, 0xE2, 0x4C, 0x99, 0xC4, 0x28, 0xC2, 0x10, 0xC6, 0x98, + 0x09, 0x2E, 0x6D, 0x25, 0x0A, 0xC0, 0x39, 0x17, 0x17, 0xE2, 0xAC, 0x33, + 0x84, 0x14, 0x66, 0x53, 0x4B, 0xD2, 0x76, 0x22, 0x45, 0xC7, 0x29, 0xF2, + 0xD6, 0x3F, 0x7D, 0xB9, 0x1E, 0x2F, 0x6A, 0x98, 0x4C, 0x2A, 0x80, 0x70, + 0x9E, 0x63, 0xAC, 0x24, 0xCF, 0x10, 0xBA, 0x08, 0xE6, 0xC9, 0x11, 0x84, + 0x73, 0x49, 0x18, 0x81, 0xAA, 0x12, 0x29, 0xE7, 0x52, 0xC0, 0x6A, 0xD5, + 0xD4, 0x8D, 0x04, 0x20, 0x57, 0x4D, 0x05, 0x09, 0x36, 0x3A, 0x2C, 0x8B, + 0x1D, 0x06, 0x05, 0x21, 0xC4, 0x14, 0x53, 0x8A, 0x8D, 0xF5, 0x31, 0x46, + 0x8C, 0x51, 0x4C, 0x25, 0xE5, 0xA2, 0xB4, 0xF1, 0x31, 0x8E, 0xB3, 0x52, + 0xC6, 0x19, 0xEB, 0x7D, 0x48, 0x97, 0x61, 0xD6, 0xCE, 0x10, 0x82, 0x63, + 0x49, 0xB3, 0xD6, 0x84, 0x94, 0x9B, 0x4D, 0xCF, 0x30, 0xBB, 0xCE, 0x9A, + 0x33, 0x78, 0xD8, 0x6F, 0x09, 0x86, 0x2F, 0xC7, 0xCB, 0xB0, 0x98, 0xD7, + 0xF3, 0xF5, 0xF1, 0x66, 0xBB, 0xEE, 0xEB, 0xF3, 0x30, 0x0B, 0x4E, 0xF7, + 0xEB, 0xFE, 0xB0, 0x59, 0x13, 0x0C, 0xCF, 0x97, 0x6B, 0xD7, 0xAF, 0x08, + 0x15, 0xD6, 0x58, 0x1F, 0xBD, 0x8F, 0x71, 0x99, 0x14, 0xA5, 0xD0, 0xDA, + 0xA0, 0x54, 0x60, 0x8C, 0x54, 0x95, 0x44, 0x10, 0x71, 0x81, 0x72, 0x06, + 0x6D, 0xC3, 0x9D, 0x8B, 0xE3, 0x64, 0xBF, 0x7D, 0xEC, 0x6B, 0x81, 0x0F, + 0x87, 0xAA, 0x17, 0xF8, 0x71, 0x0B, 0x1A, 0x49, 0xB7, 0x15, 0x58, 0xB7, + 0x19, 0xC0, 0xC2, 0x10, 0xB0, 0xDA, 0x27, 0x10, 0x21, 0x2A, 0xB8, 0x64, + 0x1D, 0x32, 0xAD, 0xF8, 0xE9, 0x6A, 0x78, 0x05, 0xDB, 0x8E, 0x65, 0xA7, + 0x1A, 0x01, 0x95, 0x76, 0xC1, 0xA4, 0x82, 0x50, 0x82, 0x30, 0x17, 0x84, + 0x90, 0x8F, 0x79, 0xB1, 0x46, 0x5F, 0x86, 0xCC, 0x18, 0xAD, 0x65, 0x0C, + 0x10, 0x66, 0x0C, 0x61, 0xF1, 0xD6, 0x45, 0x0C, 0xCB, 0xBF, 0xFE, 0x41, + 0x0A, 0x86, 0xAE, 0xD7, 0x31, 0xC4, 0x80, 0x09, 0x4B, 0xCE, 0x1D, 0xD6, + 0xFD, 0xB6, 0xAF, 0x39, 0xA3, 0x94, 0x8A, 0x4A, 0xB0, 0x56, 0xCA, 0x8A, + 0x92, 0xBE, 0xE1, 0x84, 0xF0, 0x14, 0x0B, 0x28, 0xD0, 0xF9, 0x80, 0x28, + 0x4D, 0x00, 0x68, 0x9B, 0x6C, 0x08, 0xB9, 0x64, 0x2A, 0xE8, 0x34, 0xCD, + 0xC3, 0x34, 0x23, 0x02, 0x17, 0x63, 0x62, 0x0C, 0x8B, 0xB5, 0xE7, 0x41, + 0x69, 0x13, 0x43, 0x02, 0xA0, 0x94, 0x9C, 0x72, 0xDF, 0x4A, 0x6D, 0xDD, + 0xB2, 0x18, 0xCE, 0x64, 0x2E, 0x45, 0xD6, 0x12, 0x13, 0x7A, 0xB3, 0xDB, + 0xCF, 0xF3, 0xF2, 0xF4, 0x7A, 0xFA, 0xF8, 0x70, 0x8B, 0x21, 0x08, 0x29, + 0x02, 0x88, 0x63, 0x8C, 0x5F, 0x55, 0x58, 0xA0, 0x00, 0xEF, 0x63, 0x2E, + 0xB0, 0x14, 0x50, 0x4A, 0xF9, 0x6A, 0x8A, 0xF8, 0xC7, 0x0C, 0xFB, 0xBF, + 0x1F, 0x82, 0xE8, 0x6E, 0xBF, 0x5F, 0x94, 0x8A, 0x19, 0xF4, 0x9B, 0x03, + 0x28, 0x05, 0xE5, 0x68, 0x96, 0x69, 0xD1, 0xC6, 0x78, 0x8F, 0x10, 0x9C, + 0x16, 0xFD, 0xF9, 0xF5, 0x0C, 0x20, 0x32, 0xD6, 0x1B, 0x6B, 0x0B, 0x04, + 0x31, 0x15, 0xE7, 0xD3, 0xA2, 0xFD, 0xAC, 0x5C, 0xCA, 0xE5, 0x32, 0x6A, + 0xE3, 0x02, 0x00, 0x20, 0x16, 0x90, 0x4B, 0x4A, 0x39, 0x84, 0xE8, 0x39, + 0x06, 0x4A, 0xCD, 0x4D, 0xDB, 0x4B, 0x29, 0xCE, 0xC3, 0x15, 0x40, 0xE0, + 0xBD, 0x3B, 0x5D, 0x06, 0x59, 0x37, 0x21, 0x16, 0x97, 0xA1, 0xF1, 0x01, + 0x63, 0x32, 0xCD, 0x73, 0x4A, 0x51, 0x32, 0x2A, 0x38, 0xE7, 0x8C, 0x7E, + 0xB8, 0xDB, 0x2F, 0x8B, 0x79, 0x3D, 0x4D, 0x7F, 0xF9, 0xF9, 0x65, 0x36, + 0xEE, 0x78, 0x9D, 0x86, 0xC5, 0xA6, 0x0C, 0x38, 0xA3, 0x94, 0x10, 0x00, + 0x60, 0xCC, 0x69, 0x18, 0xE7, 0xF3, 0x79, 0x40, 0x10, 0xAD, 0xDB, 0x6E, + 0xBF, 0x6E, 0x38, 0x01, 0xF7, 0xFB, 0x76, 0xD5, 0x72, 0x90, 0xF3, 0xD3, + 0xEB, 0x79, 0xD1, 0xEE, 0xF9, 0xED, 0xF2, 0x7C, 0x1C, 0x08, 0xC6, 0x25, + 0x17, 0x29, 0xAB, 0x75, 0xDF, 0x43, 0x98, 0x9C, 0xF7, 0x5D, 0xDF, 0x87, + 0x50, 0x16, 0xAD, 0x21, 0x2A, 0xD6, 0x39, 0xCE, 0x18, 0xE7, 0x74, 0x9A, + 0xCD, 0xDB, 0xF9, 0x1A, 0x72, 0x41, 0xA0, 0xAC, 0x1A, 0x06, 0x72, 0x9A, + 0x26, 0xAB, 0x4D, 0x30, 0x36, 0xBC, 0x5E, 0x17, 0x59, 0x89, 0xC3, 0x76, + 0xFB, 0x97, 0xBF, 0x3F, 0x17, 0x00, 0xD6, 0xEB, 0x66, 0xBB, 0x92, 0xC7, + 0xF3, 0x32, 0x8C, 0x76, 0x98, 0xCC, 0xB4, 0xB8, 0x71, 0xB6, 0x97, 0xF3, + 0x24, 0x18, 0x36, 0x8B, 0x45, 0x10, 0x46, 0x1F, 0x09, 0x46, 0x39, 0x44, + 0x41, 0xE1, 0xAA, 0x6B, 0x04, 0x67, 0x5C, 0x92, 0x87, 0x43, 0xBF, 0x5F, + 0xB3, 0x10, 0x03, 0x17, 0xE4, 0xBB, 0x6F, 0xEE, 0xEF, 0x6F, 0x36, 0x5C, + 0xD0, 0x71, 0x9E, 0xB5, 0xB2, 0x4C, 0x70, 0x5C, 0xD7, 0x1D, 0x22, 0x92, + 0x03, 0xBB, 0xAE, 0xD0, 0xA8, 0xE2, 0xE6, 0xF6, 0x23, 0xE6, 0x8D, 0x73, + 0x11, 0x95, 0x60, 0x8C, 0x3A, 0x9E, 0x4E, 0xCA, 0xCC, 0x84, 0x10, 0x65, + 0xDC, 0xE1, 0xFE, 0xD3, 0x97, 0xCF, 0x7F, 0xBF, 0x7F, 0xFC, 0xB0, 0x8C, + 0x97, 0x92, 0xA3, 0x0B, 0x81, 0x89, 0x86, 0x52, 0xB6, 0x92, 0xF0, 0xBF, + 0x7D, 0x4B, 0x7F, 0x78, 0xB1, 0xDB, 0xBE, 0x7E, 0xDC, 0x34, 0x77, 0x77, + 0x77, 0xFF, 0xEB, 0xF3, 0x40, 0xCC, 0xE7, 0xDF, 0x6D, 0xA2, 0x76, 0xA1, + 0xAB, 0x49, 0xDB, 0xF0, 0xCB, 0xF8, 0xD6, 0x89, 0xBC, 0x6E, 0x45, 0x48, + 0xE9, 0xAF, 0xAF, 0xCB, 0xCB, 0x92, 0xB6, 0x15, 0xDB, 0x70, 0xD5, 0x55, + 0xEE, 0xA2, 0x67, 0x4E, 0x59, 0x4C, 0x38, 0x66, 0xB0, 0x59, 0x8B, 0x1F, + 0x5E, 0xC7, 0xC9, 0x2D, 0x10, 0x41, 0x89, 0xC9, 0x4A, 0x70, 0x8E, 0x80, + 0xC9, 0xF0, 0xDF, 0x7E, 0x7C, 0x7E, 0xA8, 0xA7, 0x6E, 0x55, 0xFF, 0xED, + 0xC5, 0x50, 0x06, 0x7C, 0x4E, 0xBF, 0x7D, 0x7F, 0xB3, 0x38, 0x4F, 0x71, + 0xBE, 0xED, 0x44, 0xC8, 0x71, 0xBD, 0xDD, 0xBE, 0x5C, 0xA7, 0xB3, 0x4E, + 0x00, 0xA1, 0xC7, 0x1E, 0xDC, 0x08, 0x78, 0xD3, 0x22, 0x42, 0xF0, 0x64, + 0x31, 0x67, 0x68, 0xD6, 0x65, 0x9C, 0xF3, 0xB6, 0xC7, 0x14, 0x63, 0xC9, + 0xC1, 0x77, 0xF7, 0x1D, 0xA1, 0xE4, 0xF9, 0x68, 0x30, 0x28, 0x9C, 0x21, + 0x8C, 0x80, 0xF5, 0xC5, 0xD8, 0x9C, 0x53, 0x36, 0xC6, 0xB9, 0x90, 0x66, + 0x15, 0x19, 0xAB, 0x1E, 0x1F, 0xB6, 0x18, 0x2A, 0x67, 0x13, 0x26, 0xBD, + 0xD6, 0xE8, 0xE5, 0xE5, 0x24, 0x1A, 0xA9, 0xB5, 0x0B, 0x05, 0x54, 0xAD, + 0x0C, 0xCE, 0xC6, 0x18, 0x9B, 0x55, 0xF5, 0xFC, 0x32, 0x4A, 0xC9, 0xFF, + 0xB1, 0x96, 0x31, 0x34, 0xCA, 0xC7, 0x98, 0x08, 0x25, 0x25, 0x67, 0xA3, + 0x7D, 0x01, 0x19, 0x63, 0x68, 0x5D, 0xC0, 0x04, 0x69, 0x6D, 0x11, 0x42, + 0x8C, 0x11, 0x21, 0xA9, 0xE0, 0x94, 0x71, 0x8A, 0x30, 0x4C, 0x29, 0x79, + 0x17, 0x29, 0x25, 0x29, 0xA5, 0x04, 0x0A, 0x80, 0xA0, 0x6E, 0x2A, 0xAB, + 0xFD, 0x34, 0xAB, 0x52, 0x40, 0xDD, 0x54, 0xDE, 0xC7, 0xD3, 0x79, 0x2C, + 0xB0, 0x84, 0x9C, 0x16, 0xE5, 0xBA, 0xAE, 0xA6, 0x94, 0x7E, 0xFB, 0x78, + 0x97, 0x52, 0x26, 0x18, 0x6B, 0x63, 0x84, 0xA4, 0xDE, 0xFB, 0x4A, 0xF2, + 0x02, 0xD0, 0x38, 0xA9, 0x9C, 0xCB, 0x7E, 0xD3, 0xE7, 0x1C, 0x31, 0xC2, + 0xC7, 0xD3, 0xA5, 0x5D, 0x1F, 0x10, 0xC1, 0xA5, 0x00, 0x46, 0xD0, 0xF1, + 0x32, 0x42, 0x00, 0x39, 0x85, 0x9C, 0x42, 0x00, 0xC2, 0x38, 0xE9, 0xD3, + 0x71, 0xC1, 0xB0, 0xDC, 0xEE, 0xFB, 0xC7, 0x7B, 0xDA, 0x37, 0xF8, 0xF5, + 0xD5, 0x34, 0x82, 0x3C, 0xEC, 0xD9, 0x3F, 0x7F, 0xD3, 0x31, 0x18, 0xEF, + 0xF6, 0x14, 0xE4, 0xBC, 0xE9, 0x05, 0x67, 0x69, 0x5D, 0xF3, 0xD1, 0xC6, + 0x45, 0xFB, 0x71, 0x0C, 0x3E, 0x7A, 0x65, 0xCD, 0x68, 0x81, 0xD2, 0xDE, + 0xB9, 0xB4, 0xE8, 0x38, 0xD9, 0xE8, 0x5C, 0x80, 0x39, 0x42, 0x84, 0x5E, + 0x8F, 0x7A, 0x9C, 0x3C, 0xE7, 0x72, 0x5A, 0xD4, 0x62, 0x54, 0x2B, 0x90, + 0x37, 0x56, 0x5B, 0x5D, 0x02, 0x9B, 0x2D, 0xCC, 0x40, 0x33, 0xE2, 0x67, + 0x65, 0x19, 0xF5, 0x9B, 0x35, 0x93, 0xB2, 0xBC, 0xBB, 0x43, 0x6B, 0xE2, + 0x4F, 0xE7, 0xEC, 0x13, 0xB6, 0xD6, 0xFF, 0xFA, 0xE5, 0x55, 0x32, 0x68, + 0xF4, 0xF4, 0x7A, 0x7E, 0xBB, 0x2C, 0x1A, 0x14, 0x60, 0xAC, 0xF6, 0xC9, + 0xFA, 0xA0, 0x17, 0x67, 0x67, 0xE5, 0x8F, 0xE7, 0xA5, 0x14, 0xF0, 0xE5, + 0xF9, 0x12, 0x12, 0x0A, 0xC9, 0xBF, 0x1C, 0xAF, 0xF3, 0x62, 0x7C, 0x8C, + 0xD7, 0xD1, 0xE6, 0x52, 0x52, 0x4C, 0xB1, 0x64, 0x29, 0x00, 0x48, 0x69, + 0x9A, 0x17, 0x46, 0xD1, 0xEB, 0x49, 0xBD, 0x9E, 0xE7, 0xEB, 0x64, 0x2F, + 0xA3, 0x19, 0x26, 0xDD, 0xB7, 0x52, 0x72, 0x8C, 0x30, 0xCE, 0x10, 0x42, + 0x08, 0x9A, 0xAA, 0x6E, 0xAA, 0xEA, 0xE9, 0xF9, 0xF4, 0x8F, 0x6F, 0x29, + 0xA5, 0xCC, 0xDA, 0x03, 0x80, 0x52, 0x4A, 0x08, 0x21, 0xE7, 0x62, 0xD7, + 0x48, 0x82, 0x89, 0x0F, 0x11, 0x61, 0x88, 0x00, 0xA8, 0x04, 0x2B, 0x00, + 0xFC, 0x9F, 0x34, 0x06, 0x20, 0x00, 0x6D, 0xC5, 0x01, 0x00, 0xFF, 0xF5, + 0xB7, 0xB7, 0x37, 0xEB, 0xE6, 0xF6, 0xB0, 0xED, 0xD6, 0x07, 0x1F, 0x43, + 0x8C, 0xB9, 0xE4, 0x64, 0xB4, 0x5A, 0xB4, 0x9A, 0x95, 0x0E, 0x31, 0x2A, + 0xEB, 0xAE, 0xD3, 0x62, 0x9D, 0x23, 0x98, 0x72, 0xCE, 0x10, 0xC6, 0x00, + 0x40, 0x63, 0x3D, 0x26, 0x2C, 0xE5, 0xEC, 0x43, 0xD4, 0x36, 0xFA, 0x90, + 0x39, 0xE7, 0x21, 0x85, 0xEB, 0x34, 0x59, 0xEF, 0x5D, 0xB0, 0xA0, 0x24, + 0xEF, 0x43, 0x21, 0x1C, 0x40, 0x68, 0xCC, 0x5C, 0x60, 0x66, 0x9C, 0x9F, + 0xCE, 0xE7, 0xA6, 0x6E, 0x0A, 0xE2, 0xDA, 0x3A, 0x88, 0x59, 0xCA, 0x0E, + 0x81, 0x12, 0x63, 0x14, 0x82, 0x09, 0x86, 0xDF, 0x2E, 0x43, 0x23, 0x30, + 0x86, 0x68, 0x98, 0xF4, 0x4F, 0xCF, 0x67, 0xE3, 0xE2, 0xA4, 0x35, 0x66, + 0x8C, 0x31, 0x36, 0xCC, 0x4B, 0x57, 0x4B, 0x4A, 0xD0, 0xB4, 0x18, 0xAD, + 0xBD, 0xB7, 0x89, 0x20, 0xCC, 0x10, 0x89, 0x3E, 0x86, 0x10, 0x05, 0xC5, + 0x08, 0x94, 0xF3, 0x75, 0xB2, 0xDE, 0x09, 0x41, 0xFB, 0x96, 0x71, 0x0E, + 0xF6, 0xDB, 0x36, 0xA5, 0x3C, 0x4E, 0xF3, 0xA2, 0xED, 0xA2, 0x2D, 0xA6, + 0xB0, 0x69, 0x65, 0xBF, 0x6E, 0x00, 0x28, 0x39, 0x07, 0x90, 0xB3, 0xB3, + 0x69, 0xD5, 0x49, 0x50, 0xD2, 0xF5, 0x32, 0x0F, 0xCA, 0xEE, 0xD7, 0x55, + 0x5B, 0xF1, 0x52, 0xB0, 0xB5, 0xC1, 0xE7, 0x32, 0x1B, 0x0F, 0x20, 0xB8, + 0x2A, 0x5B, 0x73, 0x51, 0x4A, 0xD6, 0xDE, 0x69, 0xE3, 0x31, 0x82, 0x7F, + 0xFE, 0xFB, 0x6B, 0xCC, 0x38, 0xE7, 0xA2, 0x9D, 0x87, 0x18, 0x2E, 0xDA, + 0xC6, 0x94, 0x00, 0x84, 0x18, 0x22, 0xA5, 0x2C, 0x80, 0x70, 0xD1, 0x56, + 0x2F, 0x1E, 0x23, 0x42, 0x28, 0x9B, 0x67, 0x43, 0x71, 0xB1, 0xCE, 0xFF, + 0xFC, 0xEB, 0xF5, 0x78, 0x5A, 0x56, 0x6D, 0x9F, 0x63, 0x99, 0x26, 0x9D, + 0x63, 0x5E, 0x75, 0x8D, 0x31, 0xF6, 0x7A, 0x99, 0xF0, 0xBE, 0x97, 0xF7, + 0x8F, 0xDF, 0x82, 0x12, 0x7F, 0x7E, 0x7A, 0x06, 0x6C, 0x9B, 0x21, 0x9C, + 0x17, 0xBB, 0x67, 0xE6, 0xB1, 0xCD, 0x93, 0x36, 0x9F, 0x5F, 0x4E, 0x94, + 0x30, 0x17, 0xE2, 0x66, 0x7F, 0xEF, 0xBC, 0x47, 0x08, 0xE4, 0x18, 0x82, + 0x1E, 0x22, 0xC0, 0x9F, 0xF6, 0x62, 0xDD, 0xF2, 0x10, 0xE2, 0x6F, 0x6E, + 0x24, 0xA7, 0x30, 0x64, 0xFE, 0x5F, 0xBE, 0x59, 0xED, 0xD6, 0x9B, 0x9F, + 0x07, 0xF8, 0xFA, 0xF2, 0xAB, 0xC4, 0xE9, 0x6E, 0x55, 0xF6, 0x1B, 0xE1, + 0x83, 0xF9, 0x65, 0x98, 0x01, 0x32, 0x18, 0xE7, 0x5F, 0xCE, 0xD0, 0x25, + 0xD8, 0xF0, 0x78, 0xD8, 0xD4, 0x14, 0x24, 0x81, 0xD5, 0xAB, 0x72, 0x2E, + 0x62, 0x8E, 0xB1, 0x0B, 0xC5, 0x97, 0x72, 0x9C, 0xA6, 0x51, 0xC7, 0xAA, + 0xE2, 0x02, 0x40, 0x0C, 0xF0, 0x0F, 0x27, 0xF8, 0x9F, 0x4F, 0x69, 0x72, + 0xA3, 0xAC, 0x5C, 0xD3, 0x88, 0xB3, 0x4A, 0xBB, 0xAE, 0xF6, 0x01, 0xED, + 0x65, 0x72, 0x09, 0xFC, 0xE5, 0x69, 0x12, 0xBC, 0x7A, 0x1B, 0xA2, 0x07, + 0xF9, 0xA4, 0xFD, 0x2F, 0xAF, 0xCA, 0x7A, 0xB8, 0x68, 0xBF, 0xED, 0xF8, + 0xA6, 0x65, 0x1C, 0xC4, 0xFB, 0x03, 0x92, 0x1C, 0xD4, 0x92, 0xEA, 0x00, + 0xB4, 0xC9, 0x35, 0x2F, 0x8C, 0x62, 0xE7, 0xF2, 0xC3, 0xCD, 0xDD, 0x7F, + 0xFE, 0x72, 0x4D, 0xA9, 0xC4, 0x98, 0x11, 0x86, 0x00, 0x40, 0xE7, 0x0A, + 0x2C, 0x25, 0xE5, 0x5C, 0x00, 0xC8, 0x05, 0xF8, 0x00, 0x1A, 0x49, 0xEE, + 0x1E, 0x3E, 0x60, 0xBE, 0x62, 0xDD, 0x3D, 0xA4, 0xF5, 0xAF, 0x5F, 0x3E, + 0x07, 0x6F, 0x39, 0xC3, 0x10, 0x15, 0x8C, 0x51, 0x0C, 0x69, 0x9E, 0x74, + 0xCA, 0x25, 0x86, 0x94, 0x4A, 0x81, 0x05, 0x40, 0x50, 0xCE, 0xA3, 0x1E, + 0xAE, 0x3A, 0xA6, 0x82, 0x19, 0x59, 0x16, 0x5B, 0x72, 0x29, 0x08, 0x62, + 0x8C, 0x85, 0xE0, 0x5A, 0x87, 0x18, 0x32, 0x28, 0x00, 0x00, 0x18, 0x42, + 0xCC, 0x39, 0x41, 0x04, 0x73, 0x2E, 0x94, 0x51, 0xCA, 0x08, 0x80, 0xC0, + 0x5A, 0x07, 0x10, 0x4E, 0xA5, 0x5C, 0x2F, 0xB3, 0x73, 0x51, 0x1B, 0x4B, + 0x08, 0x01, 0x00, 0x20, 0x84, 0xB8, 0x60, 0x18, 0xE3, 0x65, 0xD6, 0x2E, + 0x44, 0xC2, 0xD8, 0x69, 0x58, 0x10, 0x02, 0xF7, 0xBB, 0xBE, 0xE2, 0x3C, + 0xC6, 0xB4, 0xDB, 0xAD, 0x77, 0x3D, 0xC7, 0xB8, 0xF8, 0x04, 0xC6, 0xD9, + 0x60, 0x82, 0x57, 0xAD, 0x68, 0x2A, 0x51, 0x0A, 0x80, 0x20, 0xCB, 0xBA, + 0x49, 0x05, 0xBE, 0xBE, 0xBC, 0xF6, 0xFD, 0xE6, 0x74, 0x3E, 0x5E, 0x87, + 0x89, 0x61, 0x4C, 0x50, 0x98, 0x75, 0xEA, 0x7B, 0x5E, 0x4B, 0x5C, 0x51, + 0xF0, 0x9B, 0xF7, 0x55, 0x57, 0x11, 0x01, 0xD3, 0xB2, 0xD8, 0xAA, 0x66, + 0xFB, 0x2D, 0x6F, 0x78, 0xE1, 0x38, 0xA4, 0x0C, 0xAF, 0xE3, 0x22, 0x2A, + 0x6A, 0xBD, 0xD3, 0x4E, 0x29, 0xE7, 0x42, 0x04, 0x5A, 0xC5, 0xF3, 0x68, + 0x06, 0x95, 0x9F, 0xCE, 0xE1, 0xDD, 0x01, 0xE4, 0x18, 0x21, 0x14, 0x00, + 0xC1, 0xCB, 0x14, 0x87, 0x31, 0xEC, 0x6A, 0x72, 0x19, 0xDD, 0x5F, 0x9F, + 0x23, 0x24, 0x6C, 0x58, 0xAC, 0xCF, 0x89, 0x62, 0x34, 0x0C, 0xCB, 0x75, + 0xD4, 0x29, 0x17, 0x48, 0x79, 0x46, 0x01, 0x66, 0x95, 0x62, 0x58, 0xE6, + 0x50, 0x73, 0xE2, 0x73, 0x06, 0x29, 0x7B, 0xEB, 0x7F, 0x79, 0x1E, 0x23, + 0xC2, 0x31, 0x41, 0x63, 0x73, 0xCA, 0x68, 0xD6, 0xF3, 0x55, 0xB9, 0xC5, + 0x82, 0x75, 0xDF, 0xE8, 0xA0, 0xB9, 0x00, 0xDA, 0xCC, 0x4F, 0xE7, 0x81, + 0x0B, 0x1C, 0x52, 0x29, 0x00, 0x87, 0xE8, 0x52, 0x86, 0x42, 0x50, 0x00, + 0xE2, 0xCB, 0xDB, 0xC5, 0xF9, 0xB4, 0xDB, 0xB6, 0xC3, 0x30, 0x4D, 0xB3, + 0x0D, 0x31, 0x1A, 0xE3, 0xBC, 0x8F, 0x21, 0x04, 0x1F, 0x8A, 0x75, 0x69, + 0xB3, 0x5E, 0x6D, 0x56, 0x9D, 0xAC, 0x45, 0xDF, 0x4A, 0x4A, 0xA8, 0x31, + 0xB1, 0xA9, 0x2B, 0xCE, 0x79, 0x55, 0x71, 0xC9, 0xD8, 0xFB, 0xDB, 0xFB, + 0xB7, 0xE3, 0x79, 0x98, 0x14, 0xE7, 0x7C, 0x52, 0xBA, 0x14, 0xA8, 0x8C, + 0x8B, 0x31, 0x41, 0x88, 0x28, 0x21, 0x15, 0xA7, 0x30, 0xE7, 0xC5, 0xF9, + 0x98, 0xD2, 0x57, 0x4A, 0xAD, 0x0B, 0x11, 0xFE, 0xE3, 0x9A, 0x04, 0x00, + 0x80, 0xDB, 0x4D, 0xFB, 0x78, 0xE8, 0x9A, 0x5A, 0x3C, 0xDC, 0xAC, 0x41, + 0x01, 0x8B, 0x8E, 0x6F, 0xE7, 0x61, 0x9A, 0x67, 0x1F, 0x62, 0x88, 0xB1, + 0x00, 0xE0, 0xBD, 0x4D, 0x39, 0xEF, 0x76, 0xFB, 0xD3, 0xE5, 0x62, 0xAC, + 0x05, 0x10, 0x00, 0x00, 0x18, 0xC7, 0xD6, 0xBA, 0x18, 0x0B, 0xA1, 0x24, + 0x84, 0x00, 0x0A, 0x70, 0xDE, 0x11, 0x8C, 0xB5, 0x9E, 0x73, 0xC9, 0xCA, + 0x38, 0xAD, 0x0D, 0x67, 0x74, 0x9A, 0x66, 0x46, 0x59, 0x06, 0x04, 0x12, + 0x96, 0xA3, 0x8E, 0x29, 0xD5, 0x75, 0xFD, 0xF2, 0xF2, 0xD2, 0x34, 0x0D, + 0xA1, 0xDC, 0x06, 0x4F, 0x10, 0x2C, 0x29, 0x96, 0x92, 0x4A, 0xF6, 0xAB, + 0x55, 0x4F, 0x29, 0x9A, 0x97, 0x79, 0xBF, 0x69, 0x0E, 0xEB, 0x95, 0xF5, + 0xF9, 0xBA, 0x18, 0x80, 0x50, 0x53, 0x57, 0x94, 0x10, 0x17, 0xE2, 0xF1, + 0x3A, 0xE6, 0x52, 0x56, 0xB5, 0xFC, 0x4A, 0xD3, 0xAB, 0x65, 0x55, 0x57, + 0xD5, 0x6E, 0xB3, 0xA6, 0x94, 0x0D, 0xB3, 0xBE, 0x8C, 0xCB, 0xDB, 0x79, + 0x3A, 0x0D, 0x0A, 0x02, 0x98, 0x01, 0xD0, 0xD6, 0xA6, 0x14, 0x08, 0x81, + 0x04, 0x43, 0x21, 0x69, 0xD3, 0x0A, 0x88, 0xC9, 0x3C, 0xAB, 0x7E, 0xD5, + 0x1E, 0xDF, 0x86, 0x65, 0xD1, 0x9B, 0x4D, 0xB7, 0xDD, 0x34, 0xDB, 0x4D, + 0xFB, 0xE1, 0xDD, 0x76, 0xB5, 0x6A, 0xA5, 0x64, 0x8C, 0xE3, 0xA6, 0xAD, + 0x6B, 0x8E, 0x00, 0x2C, 0xCE, 0x86, 0xBE, 0x91, 0x93, 0xF6, 0x31, 0x45, + 0x9F, 0x32, 0x27, 0xE4, 0x9B, 0xC7, 0x9E, 0x53, 0x24, 0x18, 0x5D, 0xAF, + 0xAB, 0xCD, 0xA6, 0x9D, 0x97, 0x10, 0x52, 0x28, 0x00, 0x68, 0x1B, 0x94, + 0x32, 0xCE, 0x07, 0x8A, 0xF1, 0x30, 0x1A, 0x63, 0x52, 0x8C, 0x71, 0x18, + 0xF5, 0xFE, 0x6A, 0xF4, 0xC4, 0x7C, 0x00, 0x00, 0x03, 0x78, 0x49, 0x44, + 0x41, 0x54, 0xD0, 0xBF, 0x9D, 0x17, 0x6B, 0x83, 0x94, 0xE2, 0xE9, 0xF9, + 0xD2, 0xD4, 0xDC, 0x58, 0xDF, 0x37, 0xF5, 0xED, 0x7E, 0x3B, 0x4C, 0xE1, + 0x32, 0xA8, 0x69, 0xB1, 0xD7, 0xC9, 0x12, 0x84, 0xEE, 0x6E, 0x56, 0x4E, + 0x5B, 0xFC, 0x78, 0xB3, 0x22, 0x04, 0x39, 0x50, 0x4D, 0xD3, 0x70, 0xB8, + 0xFB, 0xD6, 0x2F, 0x43, 0x4C, 0xF9, 0x3A, 0x9C, 0x42, 0x88, 0xA7, 0xEB, + 0xDC, 0xF6, 0x5B, 0x8C, 0x51, 0x2E, 0x80, 0x32, 0x51, 0x11, 0x20, 0x85, + 0xBC, 0x9C, 0x7E, 0xFD, 0x70, 0xBB, 0xDB, 0x54, 0xF4, 0xD3, 0x8E, 0xFC, + 0xFE, 0xB1, 0x79, 0xD8, 0xB0, 0x4D, 0x8B, 0x18, 0x15, 0x87, 0x8E, 0x45, + 0x28, 0xFF, 0xFD, 0xD7, 0x10, 0xE7, 0x9F, 0xB6, 0x0D, 0x52, 0xAE, 0x6C, + 0x57, 0xD8, 0x86, 0x00, 0x4A, 0x79, 0x99, 0xED, 0x97, 0x6B, 0x76, 0x11, + 0x57, 0x04, 0x31, 0x02, 0x32, 0x30, 0x00, 0x82, 0xFF, 0xEF, 0xB3, 0xFF, + 0xFB, 0x51, 0x45, 0x54, 0x06, 0x05, 0x16, 0x67, 0x95, 0xB3, 0x31, 0x23, + 0x1B, 0x9C, 0xCF, 0x40, 0x54, 0xDB, 0xE2, 0xED, 0xA0, 0xCA, 0x0F, 0x2F, + 0x11, 0x13, 0xCB, 0x25, 0x0D, 0x11, 0x28, 0x1B, 0x62, 0xCA, 0x10, 0x51, + 0xED, 0xE1, 0xEB, 0xC5, 0xCC, 0x09, 0xBD, 0xCD, 0xC5, 0x04, 0x8C, 0xE4, + 0x23, 0xC0, 0xD5, 0x97, 0x97, 0xD7, 0x79, 0xF6, 0x82, 0x82, 0xEF, 0x1F, + 0x6B, 0x26, 0xC4, 0x71, 0xD4, 0x7F, 0x7E, 0x8E, 0x4F, 0x43, 0x5A, 0xC9, + 0x32, 0x2F, 0xF9, 0x34, 0x67, 0x4A, 0x61, 0x2C, 0x10, 0x22, 0x54, 0x57, + 0xDC, 0xF8, 0xFC, 0xF4, 0x3A, 0xC9, 0x8A, 0x31, 0x06, 0x53, 0x81, 0xC3, + 0x14, 0x41, 0x01, 0x04, 0xA3, 0x90, 0x20, 0x21, 0xD8, 0x38, 0x9F, 0x01, + 0x6E, 0x05, 0x4C, 0x09, 0x2E, 0x0E, 0x0E, 0xE7, 0x23, 0x84, 0xE0, 0x7A, + 0xFA, 0x52, 0x0A, 0xE4, 0x9C, 0xC4, 0x10, 0xA7, 0xD1, 0xA4, 0x94, 0x7D, + 0xCC, 0xCE, 0x27, 0x6F, 0xA3, 0x10, 0xD4, 0x87, 0xAC, 0xB4, 0x07, 0xA5, + 0x74, 0x9D, 0x2C, 0x19, 0xB6, 0x75, 0x35, 0xCE, 0x26, 0x84, 0xD4, 0xAF, + 0x1A, 0xC6, 0x99, 0xD1, 0xC1, 0xB9, 0xA0, 0x94, 0x57, 0xDA, 0x96, 0x52, + 0x52, 0x29, 0xB3, 0x72, 0xD6, 0xC5, 0xCB, 0xB0, 0x20, 0x04, 0x3E, 0x7F, + 0x39, 0x5D, 0x86, 0x99, 0x50, 0x0A, 0x00, 0xF2, 0x2E, 0x60, 0x82, 0x11, + 0x82, 0x8C, 0x61, 0xC6, 0x48, 0x4E, 0x69, 0xB3, 0xAA, 0x83, 0x77, 0x5D, + 0x25, 0xDA, 0x9A, 0x6D, 0xD6, 0x75, 0x55, 0x51, 0x6B, 0x5C, 0x2D, 0x19, + 0x23, 0x84, 0x60, 0x7C, 0x7F, 0x7F, 0x58, 0xF5, 0x8D, 0x36, 0x26, 0xC3, + 0x82, 0x28, 0x8B, 0xDE, 0x3F, 0x1E, 0x36, 0xBB, 0x8D, 0xBC, 0x5E, 0xD5, + 0xFE, 0xB0, 0x6F, 0xDB, 0x2A, 0x25, 0xD7, 0xD4, 0x31, 0x46, 0x28, 0x45, + 0x03, 0xA1, 0xCF, 0xD1, 0x03, 0x90, 0x9B, 0x1A, 0xC7, 0x84, 0x19, 0x49, + 0x30, 0xE7, 0x77, 0x37, 0x82, 0xF3, 0x32, 0x8E, 0x0B, 0x28, 0x09, 0x20, + 0x76, 0x7B, 0x10, 0xB5, 0xC8, 0x28, 0xC7, 0xCB, 0xA4, 0x01, 0xC5, 0x29, + 0xE7, 0xF3, 0xE0, 0xDE, 0x2E, 0xAA, 0x20, 0xC0, 0x38, 0x8C, 0x3E, 0xCE, + 0x4B, 0x9C, 0x6C, 0x06, 0x10, 0x42, 0x04, 0x0F, 0x6D, 0x79, 0x3B, 0x15, + 0xCA, 0xC4, 0x30, 0x87, 0xB7, 0x93, 0xBF, 0xDD, 0xB1, 0x14, 0x92, 0x4D, + 0x45, 0xD4, 0x7C, 0x98, 0x03, 0xA1, 0xB0, 0xA9, 0xE9, 0xBC, 0xA4, 0xE7, + 0xB3, 0x75, 0x11, 0xDB, 0x84, 0x66, 0x6B, 0x18, 0xF6, 0x18, 0x97, 0x51, + 0x15, 0x82, 0xA1, 0x8B, 0x7E, 0xB6, 0x25, 0x66, 0xA2, 0x94, 0xF3, 0x91, + 0x74, 0x7D, 0x35, 0xA9, 0xD0, 0x76, 0x9B, 0xEB, 0x38, 0x87, 0x08, 0xEA, + 0xA6, 0xFA, 0xE6, 0xE3, 0x3B, 0xE3, 0xCC, 0x75, 0xD4, 0xCE, 0x59, 0x90, + 0x93, 0x0F, 0xA0, 0xAB, 0x2B, 0x6B, 0x0B, 0x63, 0x28, 0x94, 0x80, 0x29, + 0x8B, 0xCE, 0x84, 0x68, 0xB9, 0xA4, 0x84, 0x22, 0x4A, 0x90, 0xB5, 0x8A, + 0x32, 0x48, 0x08, 0xD8, 0xF4, 0x14, 0xC2, 0x3C, 0x2B, 0x9F, 0x0A, 0xD1, + 0x1E, 0x4C, 0x2A, 0x14, 0x88, 0xDA, 0xBE, 0x26, 0x18, 0x60, 0x84, 0x25, + 0xE7, 0x14, 0x93, 0xA6, 0xAE, 0x10, 0x2A, 0x14, 0x63, 0x4E, 0xB9, 0xB1, + 0x8E, 0x73, 0xA9, 0x6D, 0xF0, 0x31, 0x95, 0x02, 0x20, 0xA1, 0xFB, 0xDD, + 0x01, 0x40, 0x24, 0x08, 0x5E, 0x77, 0x0D, 0xC6, 0x64, 0x58, 0x34, 0x82, + 0x90, 0x53, 0x12, 0x62, 0x8E, 0x39, 0xA7, 0x5C, 0xCA, 0xFF, 0x89, 0x64, + 0xDB, 0x55, 0xDD, 0x37, 0x32, 0xF8, 0x02, 0x60, 0x41, 0x08, 0x7D, 0x79, + 0x1B, 0x7F, 0x7A, 0x7A, 0x89, 0x31, 0x7A, 0x1F, 0xB8, 0xAC, 0xDA, 0xBA, + 0xEA, 0x6B, 0x31, 0x8C, 0x63, 0x4E, 0x31, 0x97, 0x12, 0x52, 0xC4, 0x08, + 0x37, 0x6D, 0x6D, 0x9D, 0x73, 0xCE, 0x97, 0x52, 0x28, 0xA3, 0x29, 0x06, + 0x6B, 0x8D, 0x10, 0x3C, 0xE7, 0x64, 0xAD, 0x91, 0x52, 0x84, 0x18, 0x1F, + 0x6E, 0x36, 0x1F, 0x6F, 0x77, 0xC7, 0x8B, 0x8A, 0x09, 0x9C, 0x87, 0xD9, + 0x5A, 0x0B, 0x21, 0xE0, 0xB2, 0x2A, 0x25, 0x41, 0x44, 0x98, 0x6C, 0x08, + 0x25, 0xDB, 0x9E, 0x31, 0x0A, 0x61, 0xC9, 0x5D, 0xCB, 0x29, 0x01, 0x5D, + 0x5B, 0xE5, 0x12, 0x21, 0xF2, 0xAB, 0x46, 0xE4, 0x8C, 0x5C, 0xC2, 0xC6, + 0xF9, 0x5C, 0x40, 0x08, 0x3E, 0xE5, 0x32, 0x2B, 0x15, 0x62, 0x02, 0x00, + 0xC6, 0x98, 0x63, 0x2E, 0xA3, 0x32, 0xCE, 0xC7, 0x94, 0x4B, 0x25, 0xE5, + 0x0F, 0x3F, 0x7D, 0x79, 0xBB, 0x4E, 0xE7, 0x69, 0x01, 0x05, 0xB6, 0x75, + 0x25, 0x44, 0x65, 0xAD, 0x15, 0x8C, 0x5E, 0xC6, 0x45, 0x69, 0x5B, 0x20, + 0x50, 0xD6, 0x86, 0x94, 0xD6, 0xAB, 0xA6, 0xEF, 0x24, 0x84, 0x65, 0x99, + 0xF5, 0xCB, 0xCB, 0x59, 0xAB, 0xF8, 0xF2, 0x32, 0x8D, 0xA3, 0xA1, 0x0C, + 0x23, 0x84, 0x21, 0x44, 0x6D, 0xDB, 0x3E, 0xDC, 0xEF, 0xD7, 0xEB, 0xDE, + 0xEA, 0xA5, 0x91, 0xD0, 0xD8, 0x70, 0x1C, 0x16, 0x82, 0xD0, 0x7E, 0x2D, + 0x25, 0x17, 0x7D, 0x5B, 0x73, 0xCE, 0xA7, 0xC9, 0x20, 0x4A, 0x9E, 0x5F, + 0x27, 0x82, 0xE1, 0xA2, 0x0D, 0xA6, 0x58, 0x5B, 0xBF, 0x28, 0x5B, 0x55, + 0x94, 0x60, 0x12, 0x52, 0xD9, 0x6C, 0xDA, 0x79, 0x31, 0xA7, 0x51, 0x35, + 0x82, 0x7D, 0x4D, 0xBC, 0x39, 0x33, 0xC6, 0x64, 0x0C, 0xA9, 0xAA, 0x19, + 0x15, 0xD5, 0xAC, 0xEC, 0xCB, 0xDB, 0x95, 0x32, 0xE4, 0xBC, 0x7F, 0x39, + 0x5E, 0x38, 0xA7, 0xD3, 0xA4, 0x57, 0xAB, 0xEA, 0x7F, 0x03, 0x1E, 0x8C, + 0xFD, 0x5B, 0xC8, 0xB2, 0x7A, 0x25, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, + 0x4E, 0x44, 0xAE, 0x42, 0x60, 0x82 +}; diff --git a/samples/core/blur/main.c b/samples/core/blur/main.c new file mode 100644 index 00000000..777c9c2b --- /dev/null +++ b/samples/core/blur/main.c @@ -0,0 +1,1221 @@ +/* + * Copyright (c) 2021 The Khronos Group Inc. + * + * 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. + */ + +// OpenCL SDK includes +#include +#include +#include +#include + +// STL includes +#include +#include +#include +#include + +// Default image +#include "default_image.h" + +// Sample-specific option +struct options_Blur +{ + float size; + const char *in, *out, *op; +}; + +cag_option BlurOptions[] = { { .identifier = 'i', + .access_letters = "i", + .access_name = "in", + .value_name = "(name)", + .description = "Input image file" }, + + { .identifier = 'o', + .access_letters = "o", + .access_name = "out", + .value_name = "(name)", + .description = "Output image file" }, + + { .identifier = 's', + .access_letters = "s", + .access_name = "size", + .value_name = "(positive float)", + .description = "Size of blur kernel" }, + + { .identifier = 'b', + .access_letters = "b", + .access_name = "blur", + .value_name = "(box|gauss)", + .description = + "Operation of blur to perform" } }; + +ParseState parse_BlurOptions(const char identifier, + cag_option_context *cag_context, + struct options_Blur *opts) +{ + const char *value; + +#define IF_ERR(op) \ + if ((value = cag_option_get_value(cag_context))) \ + { \ + op; \ + return ParsedOK; \ + } \ + else \ + return ParseError; + + switch (identifier) + { + case 'i': IF_ERR(opts->in = value) + case 'o': IF_ERR(opts->out = value) + case 's': IF_ERR(opts->size = fabsf(strtof(value, NULL))) + case 'b': + if ((value = cag_option_get_value(cag_context)) + && (!strcmp(value, "box") || !strcmp(value, "gauss"))) + { + opts->op = value; + return ParsedOK; + } + else + return ParseError; + } + return NotParsed; +} + +cl_int parse_options(int argc, char *argv[], + struct cl_sdk_options_Diagnostic *diag_opts, + struct cl_sdk_options_SingleDevice *dev_opts, + struct options_Blur *blur_opts) +{ + cl_int error = CL_SUCCESS; + struct cag_option *opts = NULL, *tmp = NULL; + size_t n = 0; + + /* Prepare all options array. */ + MEM_CHECK(opts = add_CLI_options(opts, &n, DiagnosticOptions, + CAG_ARRAY_SIZE(DiagnosticOptions)), + error, end); + MEM_CHECK(tmp = add_CLI_options(opts, &n, SingleDeviceOptions, + CAG_ARRAY_SIZE(SingleDeviceOptions)), + error, end); + opts = tmp; + MEM_CHECK(tmp = add_CLI_options(opts, &n, BlurOptions, + CAG_ARRAY_SIZE(BlurOptions)), + error, end); + opts = tmp; + + char identifier; + cag_option_context cag_context; + + /* Prepare the context and iterate over all options. */ + cag_option_prepare(&cag_context, opts, n, argc, argv); + while (cag_option_fetch(&cag_context)) + { + ParseState state = NotParsed; + identifier = cag_option_get(&cag_context); + + PARS_OPTIONS(parse_DiagnosticOptions(identifier, diag_opts), state); + PARS_OPTIONS( + parse_SingleDeviceOptions(identifier, &cag_context, dev_opts), + state); + PARS_OPTIONS(parse_BlurOptions(identifier, &cag_context, blur_opts), + state); + + if (identifier == 'h') + { + printf("Usage: blur [OPTION]...\n"); + printf("Option name and value should be separated by '=' or a " + "space\n"); + /*printf("Demonstrates how to query various OpenCL extensions + applicable " "in the context of a reduction algorithm and to + touch up kernel sources " "at runtime to select the best kernel + implementation for the task.\n\n");*/ + cag_option_print(opts, n, stdout); + exit((state == ParseError) ? CL_INVALID_ARG_VALUE : CL_SUCCESS); + } + } + +end: + free(opts); + return error; +} + +float Gaussian(float x, float radius) +{ + const float pi = 3.141592653589793238462f; + return expf(-x * x / (2 * radius * radius)) / (sqrtf(2 * pi) * radius); +} + +// note that the kernel is not normalized and has size of 2*(*size)+1 elements +cl_int create_gaussian_kernel(float radius, float **const kernel, + int *const size) +{ + cl_int error = CL_SUCCESS; + + radius = fabsf(radius); + *size = (int)ceilf(3 * radius); + int span = 2 * (*size) + 1; + *kernel = NULL; + MEM_CHECK(*kernel = (float *)malloc(sizeof(float) * span), error, end); + + for (int i = 0; i <= *size; ++i) + { + float gx = Gaussian((float)i, radius); + (*kernel)[*size + i] = gx; + (*kernel)[*size - i] = gx; + } + +end: + return error; +} + +typedef struct state +{ + cl_device_id device; + cl_context context; + cl_command_queue queue; + char *kernel; + size_t program_size; + char *options; + cl_program program; + cl_uint step; + cl_sdk_image input_image; + cl_mem input_image_buf; + cl_sdk_image output_image; + cl_mem output_image_buf; + cl_mem temp_image_buf; + const char *filename; + bool verbose; +} state; + +cl_image_format set_image_format(state *const s, cl_int *const error) +{ + // this format is always supported + cl_image_format res = { .image_channel_order = CL_RGBA, + .image_channel_data_type = CL_UNSIGNED_INT8 }; + *error = CL_SUCCESS; + + if ((s->input_image.pixel_size == 1) || (s->input_image.pixel_size == 3)) + { + // search for 1/3 channels of uint8_t + cl_image_format *formats = NULL; + cl_uint formats_number = 0; + OCLERROR_RET(clGetSupportedImageFormats(s->context, CL_MEM_READ_ONLY, + CL_MEM_OBJECT_IMAGE2D, 0, NULL, + &formats_number), + *error, end); + MEM_CHECK(formats = (cl_image_format *)malloc(sizeof(cl_image_format) + * formats_number), + *error, end); + OCLERROR_RET(clGetSupportedImageFormats(s->context, CL_MEM_READ_ONLY, + CL_MEM_OBJECT_IMAGE2D, + formats_number, formats, NULL), + *error, end); + for (cl_uint i = 0; i < formats_number; ++i) + if (((s->input_image.pixel_size == 3) + && (formats[i].image_channel_order == CL_RGB) + && (formats[i].image_channel_data_type == CL_UNSIGNED_INT8)) + || ((s->input_image.pixel_size == 1) + && (formats[i].image_channel_order == CL_R) + && (formats[i].image_channel_data_type + == CL_UNSIGNED_INT8))) + { + return formats[i]; + } + + // if not found, default to 4 channels of uint8_t + if (s->verbose) printf("Converting picture into supported format... "); + + const size_t pixels = s->input_image.width * s->input_image.height; + const size_t new = sizeof(unsigned char) * pixels * 4; + unsigned char *tmp = NULL; + MEM_CHECK(tmp = (unsigned char *)realloc(s->input_image.pixels, new), + *error, end); + s->input_image.pixels = tmp; + MEM_CHECK(tmp = (unsigned char *)realloc(s->output_image.pixels, new), + *error, end); + s->output_image.pixels = tmp; + + // change picture + const size_t pixel_size = s->input_image.pixel_size; + for (size_t i = pixels - 1; i != 0; --i) + { + memcpy(s->input_image.pixels + 4 * i, + s->input_image.pixels + pixel_size * i, pixel_size); + memset(s->input_image.pixels + 4 * i + pixel_size, 0, + 4 - pixel_size); + } + memset(s->input_image.pixels + pixel_size, 0, 4 - pixel_size); + s->input_image.pixel_size = 4; + // store initial pixel_size in s->output_image.pixel_size + if (s->verbose) printf("done.\n"); + } + else if (s->input_image.pixel_size != 4) + { + fprintf(stderr, "Unknown image format!\n"); + *error = CL_INVALID_IMAGE_FORMAT_DESCRIPTOR; + return res; + } + + // show image format used + if (s->verbose) + { + printf("Format: "); + if (res.image_channel_order == CL_R) + printf("CL_R, "); + else if (res.image_channel_order == CL_RGB) + printf("CL_RBG, "); + else if (res.image_channel_order == CL_RGBA) + printf("CL_RBGA, "); + if (res.image_channel_data_type == CL_UNSIGNED_INT8) + printf("CL_UNSIGNED_INT8\n\n"); + } + +end: + return res; +} + +cl_int finalize_blur(state *const s) +{ + cl_int error = CL_SUCCESS; + + // restore image type if needed + if (s->input_image.pixel_size != s->output_image.pixel_size) + { + const size_t pixels = s->input_image.width * s->input_image.height, + pixel_size = s->output_image.pixel_size; + for (size_t i = 1; i < pixels; ++i) + memcpy(s->output_image.pixels + pixel_size * i, + s->output_image.pixels + 4 * i, pixel_size); + } + + char name[1024]; + sprintf(name, "%u", (unsigned int)s->step); + strncat(name, s->filename, sizeof(name) - 2); + error = cl_sdk_write_image(name, &s->output_image); + if (error == CL_SUCCESS) printf("Image %s written.\n\n", name); + + return error; +} + +cl_int print_timings(struct timespec start, struct timespec end, + const cl_event *const event_list, cl_uint event_number) +{ + cl_int error = CL_SUCCESS; + + cl_ulong time_host, time_device = 0; + TIMER_DIFFERENCE(time_host, start, end) + for (cl_uint i = 0; i < event_number; ++i) + { + time_device += cl_util_get_event_duration( + event_list[i], CL_PROFILING_COMMAND_START, CL_PROFILING_COMMAND_END, + &error); + if (error != CL_SUCCESS) return error; + } + printf("Execution time as seen by host: %llu us, by device: %llu us\n", + (unsigned long long)(time_host + 500) / 1000, + (unsigned long long)(time_device + 500) / 1000); + + return error; +} + +cl_int single_pass_box_blur(state *const s, cl_int size) +{ + cl_int error = CL_SUCCESS; + printf("Single-pass blur\n"); + ++(s->step); + + size_t image_size[3] = { s->input_image.width, s->input_image.height, 1 }; + size_t origin[3] = { 0, 0, 0 }; + + // compile kernel + cl_kernel blur; + OCLERROR_PAR(blur = clCreateKernel(s->program, "blur_box", &error), error, + end); + + // set kernel parameters + OCLERROR_RET(clSetKernelArg(blur, 0, sizeof(cl_mem), &s->input_image_buf), + error, blr); + OCLERROR_RET(clSetKernelArg(blur, 1, sizeof(cl_mem), &s->output_image_buf), + error, blr); + OCLERROR_RET(clSetKernelArg(blur, 2, sizeof(cl_int), &size), error, blr); + + // blur + cl_event pass; + GET_CURRENT_TIMER(start) + OCLERROR_RET(clEnqueueNDRangeKernel(s->queue, blur, 2, origin, image_size, + NULL, 0, NULL, &pass), + error, blr); + OCLERROR_RET(clWaitForEvents(1, &pass), error, blr); + GET_CURRENT_TIMER(end) + + OCLERROR_RET(clEnqueueReadImage(s->queue, s->output_image_buf, CL_BLOCKING, + origin, image_size, 0, 0, + s->output_image.pixels, 0, NULL, NULL), + error, blr); + + if (s->verbose) print_timings(start, end, &pass, 1); + + // write output file + OCLERROR_RET(finalize_blur(s), error, blr); + +blr: + clReleaseKernel(blur); +end: + return error; +} + +cl_int dual_pass_box_blur(state *const s, cl_int size) +{ + cl_int error = CL_SUCCESS, end_error = CL_SUCCESS; + printf("Dual-pass blur\n"); + ++(s->step); + + size_t image_size[3] = { s->input_image.width, s->input_image.height, 1 }; + size_t origin[3] = { 0, 0, 0 }; + + // create kernels + cl_kernel blur1, blur2; + OCLERROR_PAR(blur1 = + clCreateKernel(s->program, "blur_box_horizontal", &error), + error, end); + OCLERROR_PAR(blur2 = + clCreateKernel(s->program, "blur_box_vertical", &error), + error, blr1); + + // set kernel parameters + OCLERROR_RET(clSetKernelArg(blur1, 0, sizeof(cl_mem), &s->input_image_buf), + error, blr2); + OCLERROR_RET(clSetKernelArg(blur1, 1, sizeof(cl_mem), &s->temp_image_buf), + error, blr2); + OCLERROR_RET(clSetKernelArg(blur1, 2, sizeof(cl_int), &size), error, blr2); + + OCLERROR_RET(clSetKernelArg(blur2, 0, sizeof(cl_mem), &s->temp_image_buf), + error, blr2); + OCLERROR_RET(clSetKernelArg(blur2, 1, sizeof(cl_mem), &s->output_image_buf), + error, blr2); + OCLERROR_RET(clSetKernelArg(blur2, 2, sizeof(cl_int), &size), error, blr2); + + // blur + cl_event pass[2]; + GET_CURRENT_TIMER(start) + OCLERROR_RET(clEnqueueNDRangeKernel(s->queue, blur1, 2, origin, image_size, + NULL, 0, NULL, pass + 0), + error, blr2); + OCLERROR_RET(clEnqueueNDRangeKernel(s->queue, blur2, 2, origin, image_size, + NULL, 0, NULL, pass + 1), + error, blr2); + OCLERROR_RET(clWaitForEvents(2, pass), error, blr2); + GET_CURRENT_TIMER(end) + + OCLERROR_RET(clEnqueueReadImage(s->queue, s->output_image_buf, CL_BLOCKING, + origin, image_size, 0, 0, + s->output_image.pixels, 0, NULL, NULL), + error, blr2); + + if (s->verbose) print_timings(start, end, pass, 2); + + // write output file + OCLERROR_RET(finalize_blur(s), error, blr2); + +blr2: + OCLERROR_RET(clReleaseKernel(blur2), end_error, blr1); +blr1: + OCLERROR_RET(clReleaseKernel(blur1), end_error, end); +end: + return error; +} + +cl_int dual_pass_local_memory_exchange_box_blur(state *const s, cl_int size) +{ + cl_int error = CL_SUCCESS, end_error = CL_SUCCESS; + printf("Dual-pass local memory exchange blur\n"); + ++(s->step); + + size_t image_size[3] = { s->input_image.width, s->input_image.height, 1 }; + size_t origin[3] = { 0, 0, 0 }; + + // create kernels + cl_kernel blur1, blur2; + OCLERROR_PAR(blur1 = clCreateKernel(s->program, + "blur_box_horizontal_exchange", &error), + error, end); + OCLERROR_PAR(blur2 = clCreateKernel(s->program, + "blur_box_vertical_exchange", &error), + error, blr1); + + // query maximum supported WGS of kernel on device based on private mem + // (register) constraints + size_t wgs1, psm1, wgs2, psm2; + OCLERROR_RET(clGetKernelWorkGroupInfo(blur1, s->device, + CL_KERNEL_WORK_GROUP_SIZE, + sizeof(size_t), &wgs1, NULL), + error, blr2); + OCLERROR_RET( + clGetKernelWorkGroupInfo(blur1, s->device, + CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE, + sizeof(size_t), &psm1, NULL), + error, blr2); + OCLERROR_RET(clGetKernelWorkGroupInfo(blur2, s->device, + CL_KERNEL_WORK_GROUP_SIZE, + sizeof(size_t), &wgs2, NULL), + error, blr2); + OCLERROR_RET( + clGetKernelWorkGroupInfo(blur2, s->device, + CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE, + sizeof(size_t), &psm2, NULL), + error, blr2); + + // Further constrain (reduce) WGS based on shared mem size on device + cl_ulong loc_mem; + OCLERROR_RET(clGetDeviceInfo(s->device, CL_DEVICE_LOCAL_MEM_SIZE, + sizeof(cl_ulong), &loc_mem, NULL), + error, blr2); + + if (loc_mem >= ((psm1 > psm2 ? psm1 : psm2) + 2 * size) * sizeof(cl_uchar4)) + { + while (loc_mem < (wgs1 + 2 * size) * sizeof(cl_uchar4)) wgs1 -= psm1; + while (loc_mem < (wgs2 + 2 * size) * sizeof(cl_uchar4)) wgs2 -= psm2; + } + else + { + printf("Not enough local memory to serve a single sub-group.\n"); + error = CL_OUT_OF_RESOURCES; + goto blr2; + } + + // set kernel parameters + OCLERROR_RET(clSetKernelArg(blur1, 0, sizeof(cl_mem), &s->input_image_buf), + error, blr2); + OCLERROR_RET(clSetKernelArg(blur1, 1, sizeof(cl_mem), &s->temp_image_buf), + error, blr2); + OCLERROR_RET(clSetKernelArg(blur1, 2, sizeof(cl_int), &size), error, blr2); + OCLERROR_RET( + clSetKernelArg(blur1, 3, sizeof(cl_uchar4) * (wgs1 + 2 * size), NULL), + error, blr2); + + OCLERROR_RET(clSetKernelArg(blur2, 0, sizeof(cl_mem), &s->temp_image_buf), + error, blr2); + OCLERROR_RET(clSetKernelArg(blur2, 1, sizeof(cl_mem), &s->output_image_buf), + error, blr2); + OCLERROR_RET(clSetKernelArg(blur2, 2, sizeof(cl_int), &size), error, blr2); + OCLERROR_RET( + clSetKernelArg(blur2, 3, sizeof(cl_uchar4) * (wgs2 + 2 * size), NULL), + error, blr2); + + // blur + cl_event pass[2]; + GET_CURRENT_TIMER(start) + size_t work_size1[3] = { (s->input_image.width + wgs1 - 1) / wgs1 * wgs1, + s->input_image.height, 1 }; + size_t wgsf[3] = { wgs1, 1, 1 }; + OCLERROR_RET(clEnqueueNDRangeKernel(s->queue, blur1, 2, origin, work_size1, + wgsf, 0, NULL, pass + 0), + error, blr2); + size_t work_size2[3] = { s->input_image.width, + (s->input_image.height + wgs2 - 1) / wgs2 * wgs2, + 1 }; + size_t wgss[3] = { 1, wgs2, 1 }; + OCLERROR_RET(clEnqueueNDRangeKernel(s->queue, blur2, 2, origin, work_size2, + wgss, 0, NULL, pass + 1), + error, blr2); + OCLERROR_RET(clWaitForEvents(2, pass), error, blr2); + GET_CURRENT_TIMER(end) + + OCLERROR_RET(clEnqueueReadImage(s->queue, s->output_image_buf, CL_BLOCKING, + origin, image_size, 0, 0, + s->output_image.pixels, 0, NULL, NULL), + error, blr2); + + if (s->verbose) print_timings(start, end, pass, 2); + + // write output file + OCLERROR_RET(finalize_blur(s), error, blr2); + +blr2: + OCLERROR_RET(clReleaseKernel(blur2), end_error, blr1); +blr1: + OCLERROR_RET(clReleaseKernel(blur1), end_error, end); +end: + return error; +} + +cl_int dual_pass_subgroup_exchange_box_blur(state *const s, cl_int size) +{ + cl_int error = CL_SUCCESS, end_error = CL_SUCCESS; + ++(s->step); + + size_t image_size[3] = { s->input_image.width, s->input_image.height, 1 }; + size_t origin[3] = { 0, 0, 0 }; + + // build program with options + cl_program program; + OCLERROR_PAR(program = clCreateProgramWithSource(s->context, 1, + (const char **)&s->kernel, + &s->program_size, &error), + error, end); + OCLERROR_RET(cl_util_build_program(program, s->device, s->options), error, + prg); + + // create kernels + cl_kernel blur1, blur2; + OCLERROR_PAR(blur1 = clCreateKernel( + program, "blur_box_horizontal_subgroup_exchange", &error), + error, prg); + OCLERROR_PAR(blur2 = clCreateKernel( + program, "blur_box_vertical_subgroup_exchange", &error), + error, blr1); + + // set kernel parameters + OCLERROR_RET(clSetKernelArg(blur1, 0, sizeof(cl_mem), &s->input_image_buf), + error, blr2); + OCLERROR_RET(clSetKernelArg(blur1, 1, sizeof(cl_mem), &s->temp_image_buf), + error, blr2); + OCLERROR_RET(clSetKernelArg(blur1, 2, sizeof(cl_int), &size), error, blr2); + + OCLERROR_RET(clSetKernelArg(blur2, 0, sizeof(cl_mem), &s->temp_image_buf), + error, blr2); + OCLERROR_RET(clSetKernelArg(blur2, 1, sizeof(cl_mem), &s->output_image_buf), + error, blr2); + OCLERROR_RET(clSetKernelArg(blur2, 2, sizeof(cl_int), &size), error, blr2); + + // query preferred subgroup size of kernel on device + size_t wgs1, wgs2; + OCLERROR_RET( + clGetKernelWorkGroupInfo(blur1, s->device, + CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE, + sizeof(size_t), &wgs1, NULL), + error, blr2); + OCLERROR_RET( + clGetKernelWorkGroupInfo(blur2, s->device, + CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE, + sizeof(size_t), &wgs2, NULL), + error, blr2); + + // blur + cl_event pass[2]; + GET_CURRENT_TIMER(start) + size_t work_size1[3] = { (s->input_image.width + wgs1 - 1) / wgs1 * wgs1, + s->input_image.height, 1 }; + size_t wgsf[3] = { wgs1, 1, 1 }; + OCLERROR_RET(clEnqueueNDRangeKernel(s->queue, blur1, 2, origin, work_size1, + wgsf, 0, NULL, pass + 0), + error, blr2); + size_t work_size2[3] = { s->input_image.width, + (s->input_image.height + wgs2 - 1) / wgs2 * wgs2, + 1 }; + size_t wgss[3] = { 1, wgs2, 1 }; + OCLERROR_RET(clEnqueueNDRangeKernel(s->queue, blur2, 2, origin, work_size2, + wgss, 0, NULL, pass + 1), + error, blr2); + OCLERROR_RET(clWaitForEvents(2, pass), error, blr2); + GET_CURRENT_TIMER(end) + + OCLERROR_RET(clEnqueueReadImage(s->queue, s->output_image_buf, CL_BLOCKING, + origin, image_size, 0, 0, + s->output_image.pixels, 0, NULL, NULL), + error, blr2); + + if (s->verbose) print_timings(start, end, pass, 2); + + // write output file + OCLERROR_RET(finalize_blur(s), error, blr2); + + // cleanup for error handling +blr2: + OCLERROR_RET(clReleaseKernel(blur2), end_error, blr1); +blr1: + OCLERROR_RET(clReleaseKernel(blur1), end_error, prg); +prg: + OCLERROR_RET(clReleaseProgram(program), end_error, end); + ; +end: + return error; +} + +cl_int dual_pass_kernel_blur(state *const s, cl_int size, cl_mem kern) +{ + cl_int error = CL_SUCCESS, end_error = CL_SUCCESS; + ++(s->step); + + size_t image_size[3] = { s->input_image.width, s->input_image.height, 1 }; + size_t origin[3] = { 0, 0, 0 }; + + cl_kernel blur1, blur2; + OCLERROR_PAR( + blur1 = clCreateKernel(s->program, "blur_kernel_horizontal", &error), + error, end); + OCLERROR_PAR(blur2 = + clCreateKernel(s->program, "blur_kernel_vertical", &error), + error, blr1); + + // set kernel parameters + OCLERROR_RET(clSetKernelArg(blur1, 0, sizeof(cl_mem), &s->input_image_buf), + error, blr2); + OCLERROR_RET(clSetKernelArg(blur1, 1, sizeof(cl_mem), &s->temp_image_buf), + error, blr2); + OCLERROR_RET(clSetKernelArg(blur1, 2, sizeof(cl_int), &size), error, blr2); + OCLERROR_RET(clSetKernelArg(blur1, 3, sizeof(cl_mem), &kern), error, blr2); + + OCLERROR_RET(clSetKernelArg(blur2, 0, sizeof(cl_mem), &s->temp_image_buf), + error, blr2); + OCLERROR_RET(clSetKernelArg(blur2, 1, sizeof(cl_mem), &s->output_image_buf), + error, blr2); + OCLERROR_RET(clSetKernelArg(blur2, 2, sizeof(cl_int), &size), error, blr2); + OCLERROR_RET(clSetKernelArg(blur2, 3, sizeof(cl_mem), &kern), error, blr2); + + // blur + cl_event pass[2]; + GET_CURRENT_TIMER(start) + OCLERROR_RET(clEnqueueNDRangeKernel(s->queue, blur1, 2, origin, image_size, + NULL, 0, NULL, pass + 0), + error, blr2); + OCLERROR_RET(clEnqueueNDRangeKernel(s->queue, blur2, 2, origin, image_size, + NULL, 0, NULL, pass + 1), + error, blr2); + OCLERROR_RET(clWaitForEvents(2, pass), error, blr2); + GET_CURRENT_TIMER(end) + + OCLERROR_RET(clEnqueueReadImage(s->queue, s->output_image_buf, CL_BLOCKING, + origin, image_size, 0, 0, + s->output_image.pixels, 0, NULL, NULL), + error, blr2); + + if (s->verbose) print_timings(start, end, pass, 2); + + // write output file + OCLERROR_RET(finalize_blur(s), error, blr2); + +blr2: + OCLERROR_RET(clReleaseKernel(blur2), end_error, blr1); +blr1: + OCLERROR_RET(clReleaseKernel(blur1), end_error, end); +end: + return error; +} + +cl_int dual_pass_local_memory_exchange_kernel_blur(state *const s, cl_int size, + cl_mem kern) +{ + cl_int error = CL_SUCCESS, end_error = CL_SUCCESS; + ++(s->step); + + size_t image_size[3] = { s->input_image.width, s->input_image.height, 1 }; + size_t origin[3] = { 0, 0, 0 }; + + // create kernels + cl_kernel blur1, blur2; + OCLERROR_PAR(blur1 = clCreateKernel( + s->program, "blur_kernel_horizontal_exchange", &error), + error, end); + OCLERROR_PAR(blur2 = clCreateKernel( + s->program, "blur_kernel_vertical_exchange", &error), + error, blr1); + + // query maximum supported WGS of kernel on device based on private mem + // (register) constraints + size_t wgs1, psm1, wgs2, psm2; + OCLERROR_RET(clGetKernelWorkGroupInfo(blur1, s->device, + CL_KERNEL_WORK_GROUP_SIZE, + sizeof(size_t), &wgs1, NULL), + error, blr2); + OCLERROR_RET( + clGetKernelWorkGroupInfo(blur1, s->device, + CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE, + sizeof(size_t), &psm1, NULL), + error, blr2); + OCLERROR_RET(clGetKernelWorkGroupInfo(blur2, s->device, + CL_KERNEL_WORK_GROUP_SIZE, + sizeof(size_t), &wgs2, NULL), + error, blr2); + OCLERROR_RET( + clGetKernelWorkGroupInfo(blur2, s->device, + CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE, + sizeof(size_t), &psm2, NULL), + error, blr2); + + // Further constrain (reduce) WGS based on shared mem size on device + cl_ulong loc_mem; + OCLERROR_RET(clGetDeviceInfo(s->device, CL_DEVICE_LOCAL_MEM_SIZE, + sizeof(cl_ulong), &loc_mem, NULL), + error, blr2); + + if (loc_mem >= ((psm1 > psm2 ? psm1 : psm2) + 2 * size) * sizeof(cl_uchar4)) + { + while (loc_mem < (wgs1 + 2 * size) * sizeof(cl_uchar4)) wgs1 -= psm1; + while (loc_mem < (wgs2 + 2 * size) * sizeof(cl_uchar4)) wgs2 -= psm2; + } + else + { + printf("Not enough local memory to serve a single sub-group.\n"); + error = CL_OUT_OF_RESOURCES; + goto blr2; + } + + // set kernel parameters + OCLERROR_RET(clSetKernelArg(blur1, 0, sizeof(cl_mem), &s->input_image_buf), + error, blr2); + OCLERROR_RET(clSetKernelArg(blur1, 1, sizeof(cl_mem), &s->temp_image_buf), + error, blr2); + OCLERROR_RET(clSetKernelArg(blur1, 2, sizeof(cl_int), &size), error, blr2); + OCLERROR_RET(clSetKernelArg(blur1, 3, sizeof(cl_mem), &kern), error, blr2); + OCLERROR_RET( + clSetKernelArg(blur1, 4, sizeof(cl_uchar4) * (wgs1 + 2 * size), NULL), + error, blr2); + + OCLERROR_RET(clSetKernelArg(blur2, 0, sizeof(cl_mem), &s->temp_image_buf), + error, blr2); + OCLERROR_RET(clSetKernelArg(blur2, 1, sizeof(cl_mem), &s->output_image_buf), + error, blr2); + OCLERROR_RET(clSetKernelArg(blur2, 2, sizeof(cl_int), &size), error, blr2); + OCLERROR_RET(clSetKernelArg(blur2, 3, sizeof(cl_mem), &kern), error, blr2); + OCLERROR_RET( + clSetKernelArg(blur2, 4, sizeof(cl_uchar4) * (wgs2 + 2 * size), NULL), + error, blr2); + + // blur + cl_event pass[2]; + GET_CURRENT_TIMER(start) + size_t work_size1[3] = { (s->input_image.width + wgs1 - 1) / wgs1 * wgs1, + s->input_image.height, 1 }; + size_t wgsf[3] = { wgs1, 1, 1 }; + OCLERROR_RET(clEnqueueNDRangeKernel(s->queue, blur1, 2, origin, work_size1, + wgsf, 0, NULL, pass + 0), + error, blr2); + size_t work_size2[3] = { s->input_image.width, + (s->input_image.height + wgs2 - 1) / wgs2 * wgs2, + 1 }; + size_t wgss[3] = { 1, wgs2, 1 }; + OCLERROR_RET(clEnqueueNDRangeKernel(s->queue, blur2, 2, origin, work_size2, + wgss, 0, NULL, pass + 1), + error, blr2); + OCLERROR_RET(clWaitForEvents(2, pass), error, blr2); + GET_CURRENT_TIMER(end) + + OCLERROR_RET(clEnqueueReadImage(s->queue, s->output_image_buf, CL_BLOCKING, + origin, image_size, 0, 0, + s->output_image.pixels, 0, NULL, NULL), + error, blr2); + + if (s->verbose) print_timings(start, end, pass, 2); + + // write output file + OCLERROR_RET(finalize_blur(s), error, blr2); + +blr2: + OCLERROR_RET(clReleaseKernel(blur2), end_error, blr1); +blr1: + OCLERROR_RET(clReleaseKernel(blur1), end_error, end); +end: + return error; +} + +cl_int dual_pass_subgroup_exchange_kernel_blur(state *const s, cl_int size, + cl_mem kern) +{ + cl_int error = CL_SUCCESS, end_error = CL_SUCCESS; + ++(s->step); + + size_t image_size[3] = { s->input_image.width, s->input_image.height, 1 }; + size_t origin[3] = { 0, 0, 0 }; + + // build program with options + cl_program program; + OCLERROR_PAR(program = clCreateProgramWithSource(s->context, 1, + (const char **)&s->kernel, + &s->program_size, &error), + error, end); + OCLERROR_RET(cl_util_build_program(program, s->device, s->options), error, + prg); + + // create kernels + cl_kernel blur1, blur2; + OCLERROR_PAR( + blur1 = clCreateKernel( + program, "blur_kernel_horizontal_subgroup_exchange", &error), + error, prg); + OCLERROR_PAR(blur2 = clCreateKernel( + program, "blur_kernel_vertical_subgroup_exchange", &error), + error, blr1); + + // set kernel parameters + OCLERROR_RET(clSetKernelArg(blur1, 0, sizeof(cl_mem), &s->input_image_buf), + error, blr2); + OCLERROR_RET(clSetKernelArg(blur1, 1, sizeof(cl_mem), &s->temp_image_buf), + error, blr2); + OCLERROR_RET(clSetKernelArg(blur1, 2, sizeof(cl_int), &size), error, blr2); + OCLERROR_RET(clSetKernelArg(blur1, 3, sizeof(cl_mem), &kern), error, blr2); + + OCLERROR_RET(clSetKernelArg(blur2, 0, sizeof(cl_mem), &s->temp_image_buf), + error, blr2); + OCLERROR_RET(clSetKernelArg(blur2, 1, sizeof(cl_mem), &s->output_image_buf), + error, blr2); + OCLERROR_RET(clSetKernelArg(blur2, 2, sizeof(cl_int), &size), error, blr2); + OCLERROR_RET(clSetKernelArg(blur2, 3, sizeof(cl_mem), &kern), error, blr2); + + // query preferred subgroup size of kernel on device + size_t wgs1, wgs2; + OCLERROR_RET( + clGetKernelWorkGroupInfo(blur1, s->device, + CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE, + sizeof(size_t), &wgs1, NULL), + error, blr2); + OCLERROR_RET( + clGetKernelWorkGroupInfo(blur2, s->device, + CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE, + sizeof(size_t), &wgs2, NULL), + error, blr2); + + // blur + cl_event pass[2]; + GET_CURRENT_TIMER(start) + size_t work_size1[3] = { (s->input_image.width + wgs1 - 1) / wgs1 * wgs1, + s->input_image.height, 1 }; + size_t wgsf[3] = { wgs1, 1, 1 }; + OCLERROR_RET(clEnqueueNDRangeKernel(s->queue, blur1, 2, origin, work_size1, + wgsf, 0, NULL, pass + 0), + error, blr2); + size_t work_size2[3] = { s->input_image.width, + (s->input_image.height + wgs2 - 1) / wgs2 * wgs2, + 1 }; + size_t wgss[3] = { 1, wgs2, 1 }; + OCLERROR_RET(clEnqueueNDRangeKernel(s->queue, blur2, 2, origin, work_size2, + wgss, 0, NULL, pass + 1), + error, blr2); + OCLERROR_RET(clWaitForEvents(2, pass), error, blr2); + GET_CURRENT_TIMER(end) + + OCLERROR_RET(clEnqueueReadImage(s->queue, s->output_image_buf, CL_BLOCKING, + origin, image_size, 0, 0, + s->output_image.pixels, 0, NULL, NULL), + error, blr2); + + if (s->verbose) print_timings(start, end, pass, 2); + + // write output file + OCLERROR_RET(finalize_blur(s), error, blr2); + + // cleanup for error handling +blr2: + OCLERROR_RET(clReleaseKernel(blur2), end_error, blr1); +blr1: + OCLERROR_RET(clReleaseKernel(blur1), end_error, prg); +prg: + OCLERROR_RET(clReleaseProgram(program), end_error, end); + ; +end: + return error; +} + + +int main(int argc, char *argv[]) +{ + cl_int error = CL_SUCCESS, end_error = CL_SUCCESS; + state s; + cl_platform_id platform; + + /// Parse command-line options + struct cl_sdk_options_Diagnostic diag_opts = { .quiet = false, + .verbose = false }; + struct cl_sdk_options_SingleDevice dev_opts = { + .triplet = { 0, 0, CL_DEVICE_TYPE_ALL } + }; + struct options_Blur blur_opts = { + .size = 1, .op = "box", .in = NULL, .out = "out.png" + }; + + OCLERROR_RET(parse_options(argc, argv, &diag_opts, &dev_opts, &blur_opts), + error, end); + s.verbose = diag_opts.verbose; + s.filename = blur_opts.out; + s.step = 0; + + /// Create runtime objects based on user preference or default + OCLERROR_PAR(s.device = cl_util_get_device( + dev_opts.triplet.plat_index, dev_opts.triplet.dev_index, + dev_opts.triplet.dev_type, &error), + error, end); + OCLERROR_PAR(s.context = + clCreateContext(NULL, 1, &s.device, NULL, NULL, &error), + error, end); + OCLERROR_RET(clGetDeviceInfo(s.device, CL_DEVICE_PLATFORM, + sizeof(cl_platform_id), &platform, NULL), + error, cont); +#if CL_HPP_TARGET_OPENCL_VERSION >= 200 + cl_command_queue_properties props[] = { CL_QUEUE_PROPERTIES, + CL_QUEUE_PROFILING_ENABLE, 0 }; + OCLERROR_PAR(s.queue = clCreateCommandQueueWithProperties( + s.context, s.device, props, &error), + error, cont); +#else + OCLERROR_PAR(s.queue = clCreateCommandQueue( + s.context, s.device, CL_QUEUE_PROFILING_ENABLE, &error), + error, cont); +#endif + + if (!diag_opts.quiet) cl_util_print_device_info(s.device); + + /// Read input image and prepare output image + const char fname[] = "andrew_svk_7oJ4D_ewB7c_unsplash.png"; + if (!blur_opts.in) + { + printf("No file given, use standard image %s\n", fname); + const unsigned char *fcont = andrew_svk_7oJ4D_ewB7c_unsplash_png; + const size_t fsize = andrew_svk_7oJ4D_ewB7c_unsplash_png_size; + FILE *f; + if ((f = fopen(fname, "wb")) != NULL) + { + if (fwrite(fcont, 1, fsize, f) != fsize) + { + fprintf(stderr, "File write error!\n"); + error = CL_UTIL_FILE_OPERATION_ERROR; + fclose(f); + goto que; + } + fclose(f); + } + else + { + fprintf(stderr, "Cannot open the file to write!\n"); + error = CL_INVALID_VALUE; + goto que; + } + blur_opts.in = fname; + } + OCLERROR_PAR(s.input_image = cl_sdk_read_image(blur_opts.in, &error), error, + que); + + s.output_image = s.input_image; + s.output_image.pixels = NULL; + MEM_CHECK(s.output_image.pixels = (unsigned char *)malloc( + sizeof(unsigned char) * s.output_image.width + * s.output_image.height * s.output_image.pixel_size), + error, inim); + + /// Query device and runtime capabilities + // 1) query image support + cl_bool image_support = false; + OCLERROR_RET(clGetDeviceInfo(s.device, CL_DEVICE_IMAGE_SUPPORT, + sizeof(cl_bool), &image_support, NULL), + error, outim); + if (!image_support) + { + fprintf(stderr, "No image support on device!\n"); + error = CL_INVALID_DEVICE; + goto outim; + } + + // 2) query if the image format is supported and change image if not + cl_image_format format; + OCLERROR_PAR(format = set_image_format(&s, &error), error, outim); + + // 3) query if device have local memory and its size + bool use_local_mem = false; + cl_device_local_mem_type mt; + OCLERROR_RET(clGetDeviceInfo(s.device, CL_DEVICE_LOCAL_MEM_TYPE, + sizeof(cl_device_local_mem_type), &mt, NULL), + error, outim); + if (mt == CL_LOCAL) use_local_mem = true; + + // 4) query if device allow subgroup shuffle operations + bool use_subgroup_exchange = false, use_subgroup_exchange_relative = false; + { + char *name = NULL, *tmp1 = NULL, *tmp2 = NULL; + OCLERROR_PAR(name = cl_util_get_device_info( + s.device, CL_DEVICE_EXTENSIONS, &error), + error, nam); + tmp1 = strstr(name, "cl_khr_subgroup_shuffle_relative"); + if (tmp1) use_subgroup_exchange_relative = true; + tmp2 = strstr(name, "cl_khr_subgroup_shuffle"); + if (tmp2 && (tmp2 == tmp1)) // exclude relative + tmp2 = strstr(tmp2 + 1, "cl_khr_subgroup_shuffle"); + if (tmp2) use_subgroup_exchange = true; + + nam: + free(name); + } + + /// Create image buffers + const cl_image_desc desc = { .image_type = CL_MEM_OBJECT_IMAGE2D, + .image_width = s.input_image.width, + .image_height = s.input_image.height, + .image_row_pitch = 0, + .num_mip_levels = 0, + .num_samples = 0, + .mem_object = NULL }; + OCLERROR_PAR(s.input_image_buf = clCreateImage( + s.context, CL_MEM_READ_ONLY | CL_MEM_HOST_WRITE_ONLY, + &format, &desc, NULL, &error), + error, outim); + OCLERROR_PAR(s.output_image_buf = clCreateImage( + s.context, CL_MEM_READ_WRITE | CL_MEM_HOST_READ_ONLY, + &format, &desc, NULL, &error), + error, inbuf); + OCLERROR_PAR(s.temp_image_buf = clCreateImage( + s.context, CL_MEM_READ_WRITE | CL_MEM_HOST_READ_ONLY, + &format, &desc, NULL, &error), + error, outbuf); + + size_t image_size[3] = { s.input_image.width, s.input_image.height, 1 }; + size_t origin[3] = { 0, 0, 0 }; + + OCLERROR_RET(clEnqueueWriteImage(s.queue, s.input_image_buf, + CL_NON_BLOCKING, origin, image_size, 0, 0, + s.input_image.pixels, 0, NULL, NULL), + error, tmpbuf); + + /// Create OpenCL program + const char *kernel_location = "./blur.cl"; + s.kernel = NULL; + s.program_size = 0; + char kernel_op[1024] = ""; // here we put some dynamic definitions + s.options = kernel_op; + + OCLERROR_PAR(s.kernel = cl_util_read_text_file(kernel_location, + &s.program_size, &error), + error, tmpbuf); + + OCLERROR_PAR(s.program = clCreateProgramWithSource(s.context, 1, + (const char **)&s.kernel, + &s.program_size, &error), + error, ker); + OCLERROR_RET(cl_util_build_program(s.program, s.device, kernel_op), error, + prg); + kernel_op[0] = '\0'; + + /// Box blur + if (strstr(blur_opts.op, "box")) + { + /// Single-pass blur + OCLERROR_RET(single_pass_box_blur(&s, (cl_int)blur_opts.size), error, + prg); + + /// Dual-pass blur + OCLERROR_RET(dual_pass_box_blur(&s, (cl_int)blur_opts.size), error, + prg); + + /// Use local memory exchange in dual-pass blur + if (use_local_mem) + OCLERROR_RET(dual_pass_local_memory_exchange_box_blur( + &s, (cl_int)blur_opts.size), + error, prg); + + /// Subgroup exchange in dual-pass blur + if (use_subgroup_exchange_relative) + { + printf("Dual-pass subgroup relative exchange blur\n"); + + kernel_op[0] = '\0'; + strcat(kernel_op, "-D USE_SUBGROUP_EXCHANGE_RELATIVE "); + + OCLERROR_RET(dual_pass_subgroup_exchange_box_blur( + &s, (cl_int)blur_opts.size), + error, prg); + } + if (use_subgroup_exchange) + { + printf("Dual-pass subgroup exchange blur\n"); + + kernel_op[0] = '\0'; + strcat(kernel_op, "-D USE_SUBGROUP_EXCHANGE "); + + OCLERROR_RET(dual_pass_subgroup_exchange_box_blur( + &s, (cl_int)blur_opts.size), + error, prg); + } + } // Box blur + + /// Gaussian blur + if (strstr(blur_opts.op, "gauss")) + { + // create Gaussian convolution kernel + float *gauss = NULL; + int gauss_size = 0; + OCLERROR_RET( + create_gaussian_kernel(blur_opts.size, &gauss, &gauss_size), error, + gau); + cl_mem gauss_kern; + OCLERROR_PAR(gauss_kern = clCreateBuffer( + s.context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, + sizeof(float) * (2 * gauss_size + 1), gauss, &error), + error, gau); + + /// Dual-pass Gaussian blur + printf("Dual-pass Gaussian blur\n"); + OCLERROR_RET(dual_pass_kernel_blur(&s, gauss_size, gauss_kern), error, + gkrn); + + /// Local memory exchange Gaussian blur + if (use_local_mem) + { + printf("Dual-pass local memory exchange Gaussian blur\n"); + OCLERROR_RET(dual_pass_local_memory_exchange_kernel_blur( + &s, gauss_size, gauss_kern), + error, gkrn); + } + + /// Subgroup exchange in dual-pass Gaussian blur + if (use_subgroup_exchange_relative) + { + printf("Dual-pass subgroup relative exchange Gaussian blur\n"); + + kernel_op[0] = '\0'; + strcat(kernel_op, "-D USE_SUBGROUP_EXCHANGE_RELATIVE "); + + OCLERROR_RET(dual_pass_subgroup_exchange_kernel_blur(&s, gauss_size, + gauss_kern), + error, gkrn); + } + if (use_subgroup_exchange) + { + printf("Dual-pass subgroup exchange Gaussian blur\n"); + + kernel_op[0] = '\0'; + strcat(kernel_op, "-D USE_SUBGROUP_EXCHANGE "); + + OCLERROR_RET(dual_pass_subgroup_exchange_kernel_blur(&s, gauss_size, + gauss_kern), + error, gkrn); + } + + gkrn: + OCLERROR_RET(clReleaseMemObject(gauss_kern), end_error, gau); + gau: + free(gauss); + } // Gaussian blur + + /// Cleanup +prg: + OCLERROR_RET(clReleaseProgram(s.program), end_error, ker); +ker: + free(s.kernel); +tmpbuf: + OCLERROR_RET(clReleaseMemObject(s.temp_image_buf), end_error, outbuf); +outbuf: + OCLERROR_RET(clReleaseMemObject(s.output_image_buf), end_error, inbuf); +inbuf: + OCLERROR_RET(clReleaseMemObject(s.input_image_buf), end_error, outim); +outim: + free(s.output_image.pixels); +inim: + free(s.input_image.pixels); +que: + OCLERROR_RET(clReleaseCommandQueue(s.queue), end_error, cont); +cont: + OCLERROR_RET(clReleaseContext(s.context), end_error, end); +end: + if (error != CL_SUCCESS) cl_util_print_error(error); + return error; +} diff --git a/samples/core/copybuffer/main.cpp b/samples/core/copybuffer/main.cpp index 7466fd60..e9b53f45 100644 --- a/samples/core/copybuffer/main.cpp +++ b/samples/core/copybuffer/main.cpp @@ -77,9 +77,7 @@ static void checkResults(Sample& sample) printf("Success.\n"); } - sample.commandQueue.enqueueUnmapMemObject( - sample.deviceMemDst, - (void*)pDst); + sample.commandQueue.enqueueUnmapMemObject(sample.deviceMemDst, (void*)pDst); // Ensure that the unmap operation is complete. sample.commandQueue.finish(); @@ -88,8 +86,8 @@ static void checkResults(Sample& sample) int main(int argc, char** argv) { bool printUsage = false; - int platformIndex = 0; - int deviceIndex = 0; + cl_uint platformIndex = 0; + cl_uint deviceIndex = 0; if (argc < 1) { @@ -104,7 +102,7 @@ int main(int argc, char** argv) ++i; if (i < argc) { - deviceIndex = strtol(argv[i], NULL, 10); + deviceIndex = strtoul(argv[i], NULL, 10); } } else if (!strcmp(argv[i], "-p")) @@ -112,7 +110,7 @@ int main(int argc, char** argv) ++i; if (i < argc) { - platformIndex = strtol(argv[i], NULL, 10); + platformIndex = strtoul(argv[i], NULL, 10); } } else diff --git a/samples/core/copybufferkernel/main.cpp b/samples/core/copybufferkernel/main.cpp index 8945d709..26d046d6 100644 --- a/samples/core/copybufferkernel/main.cpp +++ b/samples/core/copybufferkernel/main.cpp @@ -88,9 +88,7 @@ static void checkResults(Sample& sample) printf("Success.\n"); } - sample.commandQueue.enqueueUnmapMemObject( - sample.deviceMemDst, - (void*)pDst); + sample.commandQueue.enqueueUnmapMemObject(sample.deviceMemDst, (void*)pDst); // Ensure that the unmap operation is complete. sample.commandQueue.finish(); @@ -99,8 +97,8 @@ static void checkResults(Sample& sample) int main(int argc, char** argv) { bool printUsage = false; - int platformIndex = 0; - int deviceIndex = 0; + cl_uint platformIndex = 0; + cl_uint deviceIndex = 0; if (argc < 1) { @@ -115,7 +113,7 @@ int main(int argc, char** argv) ++i; if (i < argc) { - deviceIndex = strtol(argv[i], NULL, 10); + deviceIndex = strtoul(argv[i], NULL, 10); } } else if (!strcmp(argv[i], "-p")) @@ -123,7 +121,7 @@ int main(int argc, char** argv) ++i; if (i < argc) { - platformIndex = strtol(argv[i], NULL, 10); + platformIndex = strtoul(argv[i], NULL, 10); } } else diff --git a/samples/core/reduce/CMakeLists.txt b/samples/core/reduce/CMakeLists.txt new file mode 100644 index 00000000..e74e01ed --- /dev/null +++ b/samples/core/reduce/CMakeLists.txt @@ -0,0 +1,27 @@ +# Copyright (c) 2021 The Khronos Group Inc. +# +# 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. + +add_sample( + TEST + TARGET reduce + VERSION 300 + SOURCES main.c + KERNELS reduce.cl) + +add_sample( + TEST + TARGET reducecpp + VERSION 300 + SOURCES main.cpp + KERNELS reduce.cl) diff --git a/samples/core/reduce/README.md b/samples/core/reduce/README.md new file mode 100644 index 00000000..4f2ba4ff --- /dev/null +++ b/samples/core/reduce/README.md @@ -0,0 +1,188 @@ +# Reduce + +## Sample Purpose + +This sample intends to demonstrate how to query various extensions applicable in the context of a reduction algorithm, touch up kernel sources at runtime to select the best kernel implementation for the task. + +## Key APIs and Concepts + +The most important aspect of this sample is querying exntensions in ways compatible both with 1.x, 2.y, and 3.z runtimes which were introduced at different API versions. The sample also queries the compiled kernel for optimal work-group sizes and launches batches of kernels accordingly. + +### Application flow + +The application once a device is selected queries whether it's capable of executing built-in `work_group_reduce_` and/or `sub_group_reduce_` intrinsics. Depending on whether the user selects sum calculation or minimum search on the random input, the operation is baked into the kernel. + +The kernel supports two reduction operations which is selected via the command-line. The core part of the algorithm is only declared in source code, the definition of the key functions are appended to the source code at runtime. + +The reduction kernel otherwise is conceptually simple, it reduces the input to a scalar result in potentially multiple steps. In each step, the output size is that of the input divided by max work-group size * 2. Input isn't overwritten, so double buffering is used where the size of the temporary is the size of the input after one reduction. (Note that other reduction algorithms can be devised which don't need temporary storage.) + +#### Explicit host-device-host buffer movement + +The sample uses the `cl::Buffer{ cl::CommandQueue, Iter, Iter, bool }` overload when creating the input, which still inside the CTOR invokes obtains the context of the queue, creates the buffer with it, followed by a `cl::copy( cl::CommandQueue, Iter, Iter, cl::Buffer )` which copies to the device associated with the queue using `cl::CommandQueue::enqueueMapBuffer`. The temporary (back) buffer is allocated using the `cl::Buffer{ cl::Context, cl_mem_flags, cl::size_type }` CTOR overload to denote that the initial contents are indeterminate. + +```c++ +cl::Buffer front{ queue, std::begin(arr), std::end(arr), false }, + back{ context, CL_MEM_READ_WRITE, new_size(arr.size()) * sizeof(cl_int) }; +``` + +Fetching the scalar result is done using `cl::copy`: + +```c++ +cl_int dev_res; + cl::copy(queue, back, &dev_res, &dev_res + 1); +``` + +#### Event profiling + +While events are multi-purpose in OpenCL, they are the handles through which synchronization and profiling can be done, here we only demonstrate their profiling capabilities. We can safely omit synchronizing the steps of reduction, because our queue is in-order (no `cl::QueueProperties::OutOfOrder`), so commands in our queue are executed in the order of their enqueue and don't overtake. + +Event profiling is turned on by creating the queue as such: +```c++ +cl::CommandQueue queue{ context, device, cl::QueueProperties::Profiling }; +``` +We do not have to test for this capability, as it's mandatory for a device to provide profiling capabilities. + +To record the execution time of every reduction step, we save the associated events like this: +```c++ +std::vector passes; +while ( need_to_continue ) +{ + passes.push_back(reduce(...)); +} +cl::WaitForEvents(passes); +``` +The `cl::KernelFunctor` utility of the C++ API exposes a kernel launch as a type-checked C++ function object. Calling the kernel returns the event associated with it. (Type safety means that the arguments provided to the kernel otherwise passing a C ABI are checked to match the promise given when the wrapper was created.) Our `reduce` kernel functor was created as such: +``` +auto reduce = cl::KernelFunctor(program, "reduce"); +``` +Instead calling finish on the queue, we may as well wait for all events in `passes` to signal completion. (For a complete list of event state, refer to the [Execution Model](https://www.khronos.org/registry/OpenCL/specs/3.0-unified/html/OpenCL_API.html#_execution_model) chapter of the OpenCL API spec). + +Because most often we measure durations between event state transitions, we use the utility `cl::util::get_duration(cl::Event&)` to get a `std::chrono::duaration` object between the states `From` and `To`. The utility defaults to returing `std::chrono::nanoseconds`, as that is what the OpenCL API uses to store timepoints, but we can request any unit of measurement, such as in this sample: +```c++ +for (auto& pass : passes) + std::cout << "\t" << + cl::util::get_duration< + CL_PROFILING_COMMAND_START, + CL_PROFILING_COMMAND_END, + std::chrono::microseconds + >(pass).count() << + " us." << std::endl; +``` +_(Note: the main reason why net kernel execution time doesn't amount to the time measured by the host are due to dispatching kernel binaries to the device which happen on the first execution, as the sample doesn't invoke a so called warm-up kernel. By doing so, one can reduce the difference to minimal runtime overhead.)_ + +## Kernel logic + +The sample implements a special case of reduction, where the binary operation can meaningfully operate on any combination of input data and accumulators. (For the non-special case interface, refer to [`std::reduce`](https://en.cppreference.com/w/cpp/algorithm/reduce).) The kernel holds three implementations which are all enabled/disabled based on host side queries. + +### Vanilla work-group reduction + +When no relevant extensions are supported, the sample does the textbook tree-like reduction. + +```cl +int read_local(local int* shared, size_t count, int zero, size_t i) +{ + return i < count ? shared[i] : zero; +} + +kernel void reduce( + global int* front, + global int* back, + local int* shared, + unsigned int length, + int zero_elem +) +{ + const size_t lid = get_local_id(0), + lsi = get_local_size(0), + wid = get_group_id(0), + wsi = get_num_groups(0); + + const size_t wg_stride = lsi * 2, + valid_count = wid != wsi - 1 ? // If not last group + wg_stride : // as much as possible + length - wid * wg_stride; // only the remaining + + // Copy real data to local + event_t read; + async_work_group_copy( + shared, + front + wid * wg_stride, + valid_count, + read); + wait_group_events(1, &read); + barrier(CLK_LOCAL_MEM_FENCE); + + for (int i = lsi; i != 0; i /= 2) + { + if (lid < i) + shared[lid] = + op( + read_local(shared, valid_count, zero_elem, lid), + read_local(shared, valid_count, zero_elem, lid + i) + ); + barrier(CLK_LOCAL_MEM_FENCE); + } + if (lid == 0) back[wid] = shared[0]; +} +``` + +Every workgroup loads their share of input into local memory using `async_workgroup_copy`. The last work-group may load slightly less if input size isn't divisible by the max work-group size. Whenever a kernel changes between read/write mode of local memory, a barrier is needed syncing local memory operations denoted by `CLK_LOCAL_MEM_FENCE`. + +A decreasing number of work-items participate in each loop iteration. Initially all threads are active, until only one thread is left. `read_local` takes care of uniformity in the algorithmic scheme, even though not every thread may have valid inputs. Threads without valid input data read `zero_elem` instances, leaving the result unchanged. + +### Work-group reduction built-in + +A simpler implementation is changing the loop to instead invoke a similar work-group collective function like `async_work_group_copy`, but this time `work_group_reduce_`, that way the kernel ends like: +```cl + int temp = work_group_reduce_op( + op( + read_local(shared, valid_count, zero_elem, lid), + read_local(shared, valid_count, zero_elem, lid + lsi) + ) + ); +if (lid == 0) back[wid] = temp; +``` +(Note that `work_group_reduce_op` will be an inline relay to `work_group_reduce_min` or `work_group_reduce_add` based on user preference via command-line options.) + +### Sub-group reduction built-in + +A slightly more complex variant of the vanilla implementation is provided when the device support sub-group operations. The loop doing the reduction at the end of the kernel then looks like: +```cl + const uint sid = get_sub_group_id(); + const uint ssi = get_sub_group_size(); + const uint slid= get_sub_group_local_id(); + for(int i = valid_count ; i != 0 ; i /= ssi*2) + { + int temp = zero_elem; + if (sid*ssi < valid_count) + { + temp = sub_group_reduce_op( + op( + read_local(shared, i, zero_elem, sid * 2 * ssi + slid), + read_local(shared, i, zero_elem, sid * 2 * ssi + slid + ssi) + ) + ); + } + barrier(CLK_LOCAL_MEM_FENCE); + if (sid*ssi < valid_count) + shared[sid] = temp; + barrier(CLK_LOCAL_MEM_FENCE); + } + if (lid == 0) back[wid] = shared[0]; +``` +Every sub-group (typically coinciding with some SIMD-like width of the executing device) having at least one valid input performs a sub-group collective primitive, `sub_group_reduce_`. Communicating the results between sub-groups is done via local memory. Because typically sub-groups correlate to the SIMD natue of the executing hardware, syncing work-items in sub-groups is often for free (lockstep execution) or cheaper than syncing an entire work-group. By doing sub-group reducing the input, every loop divides the input size by sub-group size * 2, as opposed to the vanilla algorithm dividing by 2 only. If the sub-group size is larger than 2, then the two barriers required for this particular implementation will still result in a net decrease in the number of work-group barriers issued, resulting in faster execution on most architectures, especially wide SIMD architectures. +### Used API surface + +```c++ +cl::util::get_context(cl::util::Triplet) +cl::Context::getInfo() +cl::CommandQueue(cl::Context, cl::Device) +cl::Device::getInfo() +cl::Platform::getInfo() +cl::util::get_program(cl::Context, cl::string) +cl::Kernel.getWorkGroupInfo<...>() +cl::KernelFunctor<...>(cl::Program, const char*) +cl::sdk::fill_with_random(...) +cl::Buffer(cl::CommandQueue, Iter, Iter, bool) +cl::copy(cl::CommandQueue, cl::Buffer, Iter, Iter) +``` diff --git a/samples/core/reduce/main.c b/samples/core/reduce/main.c new file mode 100644 index 00000000..0c307ac2 --- /dev/null +++ b/samples/core/reduce/main.c @@ -0,0 +1,540 @@ +/* + * Copyright (c) 2021 The Khronos Group Inc. + * + * 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. + */ + +// OpenCL SDK includes +#include +#include +#include +#include + +// STL includes +#include +#include +#include + +// Sample-specific option +struct options_Reduce +{ + size_t length; + const char *op; +}; + +cag_option ReduceOptions[] = { { .identifier = 'l', + .access_letters = "l", + .access_name = "length", + .value_name = "(positive integer)", + .description = "Length of input" }, + + { .identifier = 'o', + .access_letters = "o", + .access_name = "op", + .value_name = "(min|sum)", + .description = "Operation to perform" } }; + +ParseState parse_ReduceOptions(const char identifier, + cag_option_context *cag_context, + struct options_Reduce *opts) +{ + const char *value; + switch (identifier) + { + case 'l': + if ((value = cag_option_get_value(cag_context))) + { + opts->length = strtoul(value, NULL, 0); + return ParsedOK; + } + else + return ParseError; + case 'o': + if ((value = cag_option_get_value(cag_context)) + && (!strcmp(value, "min") || !strcmp(value, "sum"))) + { + opts->op = value; + return ParsedOK; + } + else + return ParseError; + } + return NotParsed; +} + +cl_int parse_options(int argc, char *argv[], + struct cl_sdk_options_Diagnostic *diag_opts, + struct cl_sdk_options_SingleDevice *dev_opts, + struct options_Reduce *reduce_opts) +{ + cl_int error = CL_SUCCESS; + struct cag_option *opts = NULL, *tmp = NULL; + size_t n = 0; + + /* Prepare all options array. */ + MEM_CHECK(opts = add_CLI_options(opts, &n, DiagnosticOptions, + CAG_ARRAY_SIZE(DiagnosticOptions)), + error, end); + MEM_CHECK(tmp = add_CLI_options(opts, &n, SingleDeviceOptions, + CAG_ARRAY_SIZE(SingleDeviceOptions)), + error, end); + opts = tmp; + MEM_CHECK(tmp = add_CLI_options(opts, &n, ReduceOptions, + CAG_ARRAY_SIZE(ReduceOptions)), + error, end); + opts = tmp; + + char identifier; + cag_option_context cag_context; + + /* Prepare the context and iterate over all options. */ + cag_option_prepare(&cag_context, opts, n, argc, argv); + while (cag_option_fetch(&cag_context)) + { + ParseState state = NotParsed; + identifier = cag_option_get(&cag_context); + + PARS_OPTIONS(parse_DiagnosticOptions(identifier, diag_opts), state); + PARS_OPTIONS( + parse_SingleDeviceOptions(identifier, &cag_context, dev_opts), + state); + PARS_OPTIONS(parse_ReduceOptions(identifier, &cag_context, reduce_opts), + state); + + if (identifier == 'h') + { + printf("Usage: reduce [OPTION]...\n"); + printf("Demonstrates how to query various OpenCL extensions " + "applicable " + "in the context of a reduction algorithm and to touch up " + "kernel sources " + "at runtime to select the best kernel implementation for " + "the task.\n\n"); + cag_option_print(opts, n, stdout); + exit((state == ParseError) ? CL_INVALID_ARG_VALUE : CL_SUCCESS); + } + } + +end: + free(opts); + return error; +} + +int check_use_work_group_reduce(cl_platform_id platform, cl_device_id device, + cl_int *error) +{ + int res = 0; + char *name = NULL; + + OCLERROR_PAR( + name = cl_util_get_platform_info(platform, CL_PLATFORM_VERSION, error), + *error, nam); + + if (strstr(name, "OpenCL 2.")) + { + free(name); + OCLERROR_PAR(name = cl_util_get_device_info( + device, CL_DEVICE_OPENCL_C_VERSION, error), + *error, nam); + if (strstr(name, "OpenCL C 2.")) res = 2; + } + else if (strstr(name, "OpenCL 3.")) + { + cl_bool coll_func; + OCLERROR_RET( + clGetDeviceInfo(device, + CL_DEVICE_WORK_GROUP_COLLECTIVE_FUNCTIONS_SUPPORT, + sizeof(cl_bool), &coll_func, NULL), + *error, nam); + + if (coll_func) + { + cl_name_version *c_features = NULL; + size_t n = 0; + + OCLERROR_RET(clGetDeviceInfo(device, CL_DEVICE_OPENCL_C_FEATURES, 0, + NULL, &n), + *error, nam); + MEM_CHECK(c_features = (cl_name_version *)malloc(sizeof(char) * n), + *error, nam); + OCLERROR_RET(clGetDeviceInfo(device, CL_DEVICE_OPENCL_C_FEATURES, + sizeof(char) * n, c_features, NULL), + *error, cf); + + const size_t feat = sizeof(char) * n / sizeof(cl_name_version); + for (size_t i = 0; i < feat; ++i) + if (strstr(c_features[i].name, + "__opencl_c_work_group_collective_functions")) + { + res = 3; + break; + } + cf: + free(c_features); + } + } +nam: + free(name); + return res; +} + +int check_use_sub_group_reduce(cl_platform_id platform, cl_device_id device, + cl_int *error) +{ + int res = 0; + char *name = NULL; + + OCLERROR_PAR( + name = cl_util_get_platform_info(platform, CL_PLATFORM_VERSION, error), + *error, nam); + + if (strstr(name, "OpenCL 3.")) + { + free(name); + OCLERROR_PAR( + name = cl_util_get_device_info(device, CL_DEVICE_EXTENSIONS, error), + *error, nam); + if (strstr(name, "cl_khr_subgroups")) res = 3; + } +nam: + free(name); + return res; +} + +cl_int min_op(cl_int x, cl_int y) { return x < y ? x : y; } + +cl_int plus_op(cl_int x, cl_int y) { return x + y; } + +cl_int accumulate(cl_int *arr, size_t len, cl_int zero_elem, + cl_int (*host_op)(cl_int, cl_int)) +{ + cl_int res = zero_elem; + for (size_t i = len; i > 0; res = (*host_op)(res, arr[--i])) + ; + return res; +} + +// Every pass reduces input length by 'factor'. +// If actual size is not divisible by factor, +// an extra output element is produced using some +// number of zero_elem inputs. +cl_ulong new_size(const cl_ulong actual, const cl_ulong factor) +{ + return actual / factor + (actual % factor == 0 ? 0 : 1); +}; +// NOTE: because one work-group produces one output +// new_size == number_of_work_groups +size_t global(const size_t actual, const cl_ulong factor, const size_t wgs) +{ + return new_size(actual, factor) * wgs; +}; + +// Random number generator state +pcg32_random_t rng; + +int main(int argc, char *argv[]) +{ + cl_int error = CL_SUCCESS, end_error = CL_SUCCESS; + cl_platform_id platform; + cl_device_id device; + cl_context context; + cl_command_queue queue; + + // Parse command-line options + struct cl_sdk_options_Diagnostic diag_opts = { .quiet = false, + .verbose = false }; + struct cl_sdk_options_SingleDevice dev_opts = { + .triplet = { 0, 0, CL_DEVICE_TYPE_ALL } + }; + struct options_Reduce reduce_opts = { .length = 1048576, .op = "min" }; + + OCLERROR_RET(parse_options(argc, argv, &diag_opts, &dev_opts, &reduce_opts), + error, end); + + // Create runtime objects based on user preference or default + OCLERROR_PAR(device = cl_util_get_device(dev_opts.triplet.plat_index, + dev_opts.triplet.dev_index, + dev_opts.triplet.dev_type, &error), + error, end); + OCLERROR_PAR(context = + clCreateContext(NULL, 1, &device, NULL, NULL, &error), + error, end); + OCLERROR_RET(clGetDeviceInfo(device, CL_DEVICE_PLATFORM, + sizeof(cl_platform_id), &platform, NULL), + error, cont); +#if CL_HPP_TARGET_OPENCL_VERSION >= 200 + cl_command_queue_properties props[] = { CL_QUEUE_PROPERTIES, + CL_QUEUE_PROFILING_ENABLE, 0 }; + OCLERROR_PAR(queue = clCreateCommandQueueWithProperties(context, device, + props, &error), + error, cont); +#else + OCLERROR_PAR(queue = clCreateCommandQueue( + context, device, CL_QUEUE_PROFILING_ENABLE, &error), + error, cont); +#endif + + if (!diag_opts.quiet) + { + cl_util_print_device_info(device); + } + + // Query device and runtime capabilities + int may_use_work_group_reduce; + OCLERROR_PAR(may_use_work_group_reduce = + check_use_work_group_reduce(platform, device, &error), + error, que); + + int may_use_sub_group_reduce; + OCLERROR_PAR(may_use_sub_group_reduce = + check_use_sub_group_reduce(platform, device, &error), + error, que); + + if (diag_opts.verbose) + { + if (may_use_work_group_reduce) + printf("Device supports work-group reduction intrinsics.\n"); + else if (may_use_sub_group_reduce) + printf("Device supports sub-group reduction intrinsics.\n"); + else + printf("Device doesn't support any reduction intrinsics.\n"); + } + + // User defined input + char kernel_op[1023] = ""; + strcat(kernel_op, + !strcmp(reduce_opts.op, "min") + ? "int op(int lhs, int rhs) { return min(lhs, rhs); }\n" + : "int op(int lhs, int rhs) { return lhs + rhs; }\n"); + if (may_use_work_group_reduce) + strcat(kernel_op, + !strcmp(reduce_opts.op, "min") + ? "int work_group_reduce_op(int val) { return " + "work_group_reduce_min(val); }\n" + : "int work_group_reduce_op(int val) { return " + "work_group_reduce_add(val); }\n"); + else if (may_use_sub_group_reduce) + strcat(kernel_op, + !strcmp(reduce_opts.op, "min") + ? "int sub_group_reduce_op(int val) { return " + "sub_group_reduce_min(val); }\n" + : "int sub_group_reduce_op(int val) { return " + "sub_group_reduce_add(val); }\n"); + cl_int (*host_op)(cl_int, cl_int) = + !strcmp(reduce_opts.op, "min") ? &min_op : &plus_op; + cl_int zero_elem = !strcmp(reduce_opts.op, "min") ? CL_INT_MAX : 0; + + // Compile kernel + const char *kernel_location = "./reduce.cl"; + char *kernel = NULL, *tmp = NULL; + size_t program_size = 0; + cl_program program = NULL; + + OCLERROR_PAR( + kernel = cl_util_read_text_file(kernel_location, &program_size, &error), + error, que); + // Note append of definitions + program_size += 1 + strlen(kernel_op); + MEM_CHECK(tmp = (char *)realloc(kernel, program_size), error, ker); + strcat(tmp, kernel_op); + + kernel = tmp; + // printf("%s", kernel); + + OCLERROR_PAR(program = clCreateProgramWithSource( + context, 1, (const char **)&kernel, &program_size, &error), + error, ker); + kernel_op[0] = '\0'; + if (may_use_work_group_reduce == 2) + strcat(kernel_op, "-D USE_WORK_GROUP_REDUCE -cl-std=CL2.0 "); + else if (may_use_work_group_reduce == 3) + strcat(kernel_op, "-D USE_WORK_GROUP_REDUCE -cl-std=CL3.0 "); + else if (may_use_sub_group_reduce) + strcat(kernel_op, "-D USE_SUB_GROUP_REDUCE -cl-std=CL3.0 "); + + OCLERROR_RET(cl_util_build_program(program, device, kernel_op), error, prg); + + cl_kernel reduce; + OCLERROR_PAR(reduce = clCreateKernel(program, "reduce", &error), error, + prg); + + // Query maximum supported WGS of kernel on device based on private mem + // (register) constraints + size_t wgs, psm; + OCLERROR_RET(clGetKernelWorkGroupInfo(reduce, device, + CL_KERNEL_WORK_GROUP_SIZE, + sizeof(size_t), &wgs, NULL), + error, red); + OCLERROR_RET( + clGetKernelWorkGroupInfo(reduce, device, + CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE, + sizeof(size_t), &psm, NULL), + error, red); + + // Further constrain (reduce) WGS based on shared mem size on device + cl_ulong loc_mem; + OCLERROR_RET(clGetDeviceInfo(device, CL_DEVICE_LOCAL_MEM_SIZE, + sizeof(cl_ulong), &loc_mem, NULL), + error, red); + while (loc_mem < wgs * 2 * sizeof(cl_int)) wgs -= psm; + + if (wgs == 0) + { + printf("Not enough local memory to serve a single sub-group.\n"); + error = CL_OUT_OF_RESOURCES; + goto red; + } + + cl_ulong factor = wgs * 2; + + // Initialize host-side storage + const size_t length = reduce_opts.length; + + pcg32_srandom_r(&rng, 11111, -2222); + cl_int *arr; + MEM_CHECK(arr = (cl_int *)malloc(sizeof(cl_int) * length), error, red); + + if (diag_opts.verbose) + printf("Generating %zu random numbers for reduction.\n", length); + cl_sdk_fill_with_random_ints_range(&rng, arr, length, -1000, 1000); + + // Initialize device-side storage + cl_mem front, back; + OCLERROR_PAR(front = clCreateBuffer( + context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, + sizeof(cl_int) * length, arr, &error), + error, harr); + OCLERROR_PAR(back = clCreateBuffer( + context, CL_MEM_READ_WRITE, + sizeof(cl_int) * new_size(length, factor), NULL, &error), + error, buff); + + // Launch kernels + if (diag_opts.verbose) + { + printf("Executing on device... "); + fflush(stdout); + } + + cl_ulong curr = length; + cl_uint steps = 0; + while (curr > 1) + { + curr = new_size(curr, factor); + ++steps; + } + cl_event *passes = NULL, *pass = NULL; + MEM_CHECK(passes = (cl_event *)malloc(sizeof(cl_event) * steps), error, + bufb); + + OCLERROR_RET(clSetKernelArg(reduce, 2, factor * sizeof(cl_int), NULL), + error, pas); + OCLERROR_RET(clSetKernelArg(reduce, 4, sizeof(cl_int), &zero_elem), error, + pas); + + GET_CURRENT_TIMER(dev_start) + curr = length; + pass = passes; + while (curr > 1) + { + OCLERROR_RET(clSetKernelArg(reduce, 0, sizeof(cl_mem), &front), error, + pas); + OCLERROR_RET(clSetKernelArg(reduce, 1, sizeof(cl_mem), &back), error, + pas); + OCLERROR_RET(clSetKernelArg(reduce, 3, sizeof(cl_ulong), &curr), error, + pas); + + size_t gl = global(curr, factor, wgs); + OCLERROR_RET(clEnqueueNDRangeKernel(queue, reduce, 1, NULL, &gl, &wgs, + 0, NULL, pass), + error, pas); + + curr = new_size(curr, factor); + ++pass; + if (curr > 1) + { + cl_mem tmp = front; + front = back; + back = tmp; + } + } + + OCLERROR_RET(clWaitForEvents(steps, passes), error, pas); + + GET_CURRENT_TIMER(dev_end) + cl_ulong dev_time; + TIMER_DIFFERENCE(dev_time, dev_start, dev_end) + if (diag_opts.verbose) printf("done.\n\n"); + + // calculate reference dataset + GET_CURRENT_TIMER(host_start) + cl_int seq_ref = accumulate(arr, length, zero_elem, host_op); + GET_CURRENT_TIMER(host_end) + cl_ulong host_time; + TIMER_DIFFERENCE(host_time, host_start, host_end) + + // Fetch results + cl_int dev_res; + OCLERROR_RET(clEnqueueReadBuffer(queue, back, CL_BLOCKING, 0, + sizeof(cl_int), (void *)&dev_res, 0, NULL, + NULL), + error, pas); + + // Validate + if (dev_res != seq_ref) + fprintf(stderr, + "Sequential reference: %i\nDevice result: %i\nValidation " + "failed!\n\n", + seq_ref, dev_res); + else + printf("Validation passed!\n\n"); + + if (!diag_opts.quiet) + { + printf("Total device execution as seen by host: %llu us.\n", + (unsigned long long)(dev_time + 500) / 1000); + printf("Reduction steps as measured by device :\n"); + for (size_t i = 0; i < steps; ++i) + printf( + "\t%llu us.\n", + (unsigned long long)(cl_util_get_event_duration( + passes[i], CL_PROFILING_COMMAND_START, + CL_PROFILING_COMMAND_END, &error) + + 500) + / 1000); + printf("Reference execution as seen by host: %llu us.\n", + (unsigned long long)(host_time + 500) / 1000); + } + +pas: + free(passes); +bufb: + OCLERROR_RET(clReleaseMemObject(back), end_error, buff); +buff: + OCLERROR_RET(clReleaseMemObject(front), end_error, harr); +harr: + free(arr); +red: + OCLERROR_RET(clReleaseKernel(reduce), end_error, prg); +prg: + OCLERROR_RET(clReleaseProgram(program), end_error, ker); +ker: + free(kernel); +que: + OCLERROR_RET(clReleaseCommandQueue(queue), end_error, cont); +cont: + OCLERROR_RET(clReleaseContext(context), end_error, end); +end: + if (error) cl_util_print_error(error); + return error; +} diff --git a/samples/core/reduce/main.cpp b/samples/core/reduce/main.cpp new file mode 100644 index 00000000..cfa5361a --- /dev/null +++ b/samples/core/reduce/main.cpp @@ -0,0 +1,325 @@ +/* + * Copyright (c) 2020 The Khronos Group Inc. + * + * 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. + */ + +// OpenCL SDK includes +#include +#include +#include +#include +#include + +// STL includes +#include +#include +#include +#include +#include +#include // std::make_tuple +#include // std::accumulate + +// TCLAP includes +#include + +// Sample-specific option +struct ReduceOptions +{ + size_t length; + std::string op; +}; + +std::unique_ptr> valid_op_constraint; + +// Add option to CLI parsing SDK utility +template <> auto cl::sdk::parse() +{ + std::vector valid_op_strings{ "min", "sum" }; + valid_op_constraint = + std::make_unique>( + valid_op_strings); + + return std::make_tuple(std::make_shared>( + "l", "length", "Length of input", false, + 1'048'576, "positive integral"), + std::make_shared>( + "o", "op", "Operation to perform", false, "min", + valid_op_constraint.get())); +} +template <> +ReduceOptions cl::sdk::comprehend( + std::shared_ptr> length_arg, + std::shared_ptr> op_arg) +{ + return ReduceOptions{ length_arg->getValue(), op_arg->getValue() }; +} + + +int main(int argc, char* argv[]) +{ + try + { + // Parse command-line options + auto opts = + cl::sdk::parse_cli( + argc, argv); + const auto& diag_opts = std::get<0>(opts); + const auto& dev_opts = std::get<1>(opts); + const auto& reduce_opts = std::get<2>(opts); + + // Create runtime objects based on user preference or default + cl::Context context = cl::sdk::get_context(dev_opts.triplet); + cl::Device device = context.getInfo().at(0); + cl::CommandQueue queue{ context, device, + cl::QueueProperties::Profiling }; + cl::Platform platform{ + device.getInfo() + }; // https://github.com/KhronosGroup/OpenCL-CLHPP/issues/150 + + if (!diag_opts.quiet) + std::cout << "Selected platform: " + << platform.getInfo() << "\n" + << "Selected device: " << device.getInfo() + << "\n" + << std::endl; + + // Query device and runtime capabilities + auto highest_device_opencl_c_is_2_x = + cl::util::opencl_c_version_contains(device, "2."); + auto highest_device_opencl_c_is_3_x = + cl::util::opencl_c_version_contains(device, "3."); + auto may_use_work_group_reduce = [&]() // IILE + { + if (cl::util::platform_version_contains(platform, "2.")) + return highest_device_opencl_c_is_2_x; + else if (cl::util::platform_version_contains(platform, "3.")) + return device.getInfo< + CL_DEVICE_WORK_GROUP_COLLECTIVE_FUNCTIONS_SUPPORT>() + && cl::util::supports_feature( + device, + "__opencl_c_work_group_collective_functions"); + else + return false; + }(); + auto may_use_sub_group_reduce = + cl::util::supports_extension(device, "cl_khr_subgroups"); + + if (diag_opts.verbose) + { + if (may_use_work_group_reduce) + std::cout << "Device supports work-group reduction intrinsics." + << std::endl; + else if (may_use_sub_group_reduce) + std::cout << "Device supports sub-group reduction intrinsics." + << std::endl; + else + std::cout << "Device doesn't support any reduction intrinsics." + << std::endl; + } + + // User defined input + std::string kernel_op = reduce_opts.op == "min" + ? "int op(int lhs, int rhs) { return min(lhs, rhs); }\n" + : "int op(int lhs, int rhs) { return lhs + rhs; }\n"; + if (may_use_work_group_reduce) + kernel_op += reduce_opts.op == "min" + ? "int work_group_reduce_op(int val) { return " + "work_group_reduce_min(val); }" + : "int work_group_reduce_op(int val) { return " + "work_group_reduce_add(val); }"; + else if (may_use_sub_group_reduce) + kernel_op += reduce_opts.op == "min" + ? "int sub_group_reduce_op(int val) { return " + "sub_group_reduce_min(val); }" + : "int sub_group_reduce_op(int val) { return " + "sub_group_reduce_add(val); }"; + auto host_op = reduce_opts.op == "min" + ? std::function{ [](int lhs, int rhs) { + return std::min(lhs, rhs); + } } + : std::function{ std::plus{} }; + auto zero_elem = reduce_opts.op == "min" + ? std::numeric_limits().max() + : static_cast(0); + + // Compile kernel + const char* kernel_location = "./reduce.cl"; + std::ifstream kernel_stream{ kernel_location }; + if (!kernel_stream.is_open()) + throw std::runtime_error{ + std::string{ "Cannot open kernel source: " } + kernel_location + }; + + cl::Program program{ context, + std::string{ std::istreambuf_iterator{ + kernel_stream }, + std::istreambuf_iterator{} } + .append(kernel_op) }; // Note append + cl::string compiler_options = + cl::string{ may_use_work_group_reduce ? "-D USE_WORK_GROUP_REDUCE " + : "" } + + cl::string{ highest_device_opencl_c_is_2_x ? "-cl-std=CL2.0 " + : "" } + + cl::string{ highest_device_opencl_c_is_3_x ? "-cl-std=CL3.0 " + : "" } + + cl::string{ may_use_sub_group_reduce ? "-D USE_SUB_GROUP_REDUCE " + : "" }; + program.build(device, compiler_options.c_str()); + + auto reduce = + cl::KernelFunctor(program, "reduce"); + + // Query maximum supported WGS of kernel on device based on private mem + // (register) constraints + auto wgs = + reduce.getKernel().getWorkGroupInfo( + device); + + // Further constrain (reduce) WGS based on shared mem size on device + while (device.getInfo() + < wgs * 2 * sizeof(cl_int)) + wgs -= + reduce.getKernel() + .getWorkGroupInfo< + CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE>(device); + + if (wgs == 0) + throw std::runtime_error{ + "Not enough local memory to serve a single sub-group." + }; + + cl_ulong factor = wgs * 2; + // Every pass reduces input length by 'factor'. + // If actual size is not divisible by factor, + // an extra output element is produced using some + // number of zero_elem inputs. + auto new_size = [factor](const cl_ulong actual) { + return actual / factor + (actual % factor == 0 ? 0 : 1); + }; + // NOTE: because one work-group produces one output + // new_size == number_of_work_groups + auto global = [=](const std::size_t actual) { + return new_size(actual) * wgs; + }; + + // Initialize host-side storage + const auto length = reduce_opts.length; + + auto prng = [engine = std::default_random_engine{}, + dist = std::uniform_int_distribution{ + -1000, 1000 }]() mutable { return dist(engine); }; + + std::vector arr(length); + if (diag_opts.verbose) + std::cout << "Generating " << length + << " random numbers for reduction." << std::endl; + cl::sdk::fill_with_random(prng, arr); + + // Initialize device-side storage + cl::Buffer front{ queue, std::begin(arr), std::end(arr), false }, + back{ context, CL_MEM_READ_WRITE, + static_cast(new_size(arr.size()) + * sizeof(cl_int)) }; + + // Launch kernels + if (diag_opts.verbose) + { + std::cout << "Executing on device... "; + std::cout.flush(); + } + std::vector passes; + cl_ulong curr = static_cast(arr.size()); + auto dev_start = std::chrono::high_resolution_clock::now(); + while (curr > 1) + { + passes.push_back(reduce( + cl::EnqueueArgs{ queue, (size_t)global(curr), wgs }, front, + back, cl::Local(factor * sizeof(cl_int)), curr, zero_elem)); + + curr = static_cast(new_size(curr)); + if (curr > 1) std::swap(front, back); + } + cl::WaitForEvents(passes); + auto dev_end = std::chrono::high_resolution_clock::now(); + if (diag_opts.verbose) std::cout << "done." << std::endl; + + // calculate reference dataset + auto host_start = std::chrono::high_resolution_clock::now(); + auto seq_ref = + std::accumulate(arr.cbegin(), arr.cend(), zero_elem, host_op); + auto host_end = std::chrono::high_resolution_clock::now(); + + // Fetch results + cl_int dev_res; + cl::copy(queue, back, &dev_res, &dev_res + 1); + + // Validate + if (dev_res != seq_ref) + { + std::cerr << "Sequential reference: " << seq_ref << std::endl; + std::cerr << "Device result: " << dev_res << std::endl; + throw std::runtime_error{ "Validation failed!" }; + } + + if (!diag_opts.quiet) + { + std::cout << "Total device execution as seen by host: " + << std::chrono::duration_cast( + dev_end - dev_start) + .count() + << " us." << std::endl; + std::cout << "Reduction steps as measured by device :\n"; + for (auto& pass : passes) + std::cout << "\t" + << cl::util::get_duration( + pass) + .count() + << " us." << std::endl; + std::cout << "Reference execution as seen by host : " + << std::chrono::duration_cast( + host_end - host_start) + .count() + << " us." << std::endl; + } + } catch (cl::util::Error& e) + { + std::cerr << "OpenCL Utils error: " << e.what() << std::endl; + std::exit(e.err()); + } catch (cl::BuildError& e) + { + std::cerr << "OpenCL runtime error: " << e.what() << std::endl; + for (auto& build_log : e.getBuildLog()) + { + std::cerr << "\tBuild log for device: " + << build_log.first.getInfo() << "\n" + << std::endl; + std::cerr << build_log.second << "\n" << std::endl; + } + std::exit(e.err()); + } catch (cl::Error& e) + { + std::cerr << "OpenCL rutnime error: " << e.what() << std::endl; + std::exit(e.err()); + } catch (std::exception& e) + { + std::cerr << "Error: " << e.what() << std::endl; + std::exit(EXIT_FAILURE); + } + + return 0; +} diff --git a/samples/core/reduce/reduce.cl b/samples/core/reduce/reduce.cl new file mode 100644 index 00000000..e9bf7957 --- /dev/null +++ b/samples/core/reduce/reduce.cl @@ -0,0 +1,102 @@ +/* + * Copyright (c) 2020 The Khronos Group Inc. + * + * 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. + */ + +int op(int lhs, int rhs); +int work_group_reduce_op(int val); +int sub_group_reduce_op(int val); + +int read_local(local int* shared, size_t count, int zero, size_t i) +{ + return i < count ? shared[i] : zero; +} + +size_t zmin(size_t a, size_t b) +{ + return a < b ? a : b; +} + +kernel void reduce( + global int* front, + global int* back, + local int* shared, + unsigned long length, + int zero_elem +) +{ + const size_t lid = get_local_id(0), + lsi = get_local_size(0), + wid = get_group_id(0), + wsi = get_num_groups(0); + + const size_t wg_stride = lsi * 2, + valid_count = zmin(wg_stride, (size_t)(length) - wid * wg_stride); + + // Copy real data to local + event_t read; + async_work_group_copy( + shared, + front + wid * wg_stride, + valid_count, + read); + wait_group_events(1, &read); + barrier(CLK_LOCAL_MEM_FENCE); + +#ifdef USE_WORK_GROUP_REDUCE + int temp = work_group_reduce_op( + op( + read_local(shared, valid_count, zero_elem, lid), + read_local(shared, valid_count, zero_elem, lid + lsi) + ) + ); + if (lid == 0) back[wid] = temp; +#else // USE_WORK_GROUP_REDUCE +#ifdef USE_SUB_GROUP_REDUCE + const uint sid = get_sub_group_id(); + const uint ssi = get_sub_group_size(); + const uint slid= get_sub_group_local_id(); + for(int i = valid_count ; i != 0 ; i /= ssi*2) + { + int temp = zero_elem; + if (sid*ssi < valid_count) + { + temp = sub_group_reduce_op( + op( + read_local(shared, i, zero_elem, sid * 2 * ssi + slid), + read_local(shared, i, zero_elem, sid * 2 * ssi + slid + ssi) + ) + ); + } + barrier(CLK_LOCAL_MEM_FENCE); + if (sid*ssi < valid_count) + shared[sid] = temp; + barrier(CLK_LOCAL_MEM_FENCE); + } + if (lid == 0) back[wid] = shared[0]; +#else // USE_SUB_GROUP_REDUCE + for (int i = lsi; i != 0; i /= 2) + { + if (lid < i) + shared[lid] = + op( + read_local(shared, valid_count, zero_elem, lid), + read_local(shared, valid_count, zero_elem, lid + i) + ); + barrier(CLK_LOCAL_MEM_FENCE); + } + if (lid == 0) back[wid] = shared[0]; +#endif // USE_SUB_GROUP_REDUCE +#endif // USE_WORK_GROUP_REDUCE +} diff --git a/samples/core/saxpy/CMakeLists.txt b/samples/core/saxpy/CMakeLists.txt new file mode 100644 index 00000000..e4c3c6bb --- /dev/null +++ b/samples/core/saxpy/CMakeLists.txt @@ -0,0 +1,27 @@ +# Copyright (c) 2021 The Khronos Group Inc. +# +# 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. + +add_sample( + TEST + TARGET saxpy + VERSION 120 + SOURCES main.c + KERNELS saxpy.cl) + +add_sample( + TEST + TARGET saxpycpp + VERSION 120 + SOURCES main.cpp + KERNELS saxpy.cl) diff --git a/samples/core/saxpy/README.md b/samples/core/saxpy/README.md new file mode 100644 index 00000000..007d5585 --- /dev/null +++ b/samples/core/saxpy/README.md @@ -0,0 +1,47 @@ +# saxpy + +## Sample Purpose + +This sample intends to be a minimal end-to-end OpenCL application doing actual device-side computation. The structure of the sample rhymes well with the [How Does OpenCL Work?](https://github.com/KhronosGroup/OpenCL-Guide/blob/main/chapters/how_does_opencl_work.md) chapter of the OpenCL-Guide, particularly the [Executing an OpenCL Program](https://github.com/KhronosGroup/OpenCL-Guide/blob/main/chapters/how_does_opencl_work.md#executing-an-opencl-program) part. + +This sample is implemented using both C and C++ languages to demonstrate the difference in verbosity when using the naked C bindings compared to the C++ wrapper. + +## Key APIs and Concepts + +The most important aspect of this sample is to understand what entities / API objects are involved in the execution of a typical OpenCL application. + +### Application flow + +You may note that the actual order in creating the relevant API objects in this sample differs slightly from the list in [Executing an OpenCL Program](https://github.com/KhronosGroup/OpenCL-Guide/blob/main/chapters/how_does_opencl_work.md#executing-an-opencl-program). That is because the actual data dependence allows for some flexibility. The most important is obtaining a `cl_context`/`cl::Context`, because that is _the alpha and the omega_ of all other API objects in the runtime layer. For a distinction on where the platform layer ends and where the runtime layer begings, refer to **REF**. + +If we aim for absolute fastest execution, compiling our kernel may have been concurrent to initializing our input data. + +### Lazy buffer movement + +OpenCL buffers when created are bound to a context, not any specific device. Device-local physical memory is conceptually used as a cache to access the contents of the buffer. (See [OpenCL API - Memory Model: Fundamental Memory Regions](https://www.khronos.org/registry/OpenCL/specs/3.0-unified/html/OpenCL_API.html#_fundamental_memory_regions)) To paraphrase, one may think of buffers migrating from device-to-device as needed, while the OpenCL Runtime keeps track of where the most current (last written) contents reside. + +This sample creates buffers, specifies their initial content with an iterator range spanning host containers and launches a kernel using said buffer. The OpenCL Runtime will take care of dispatching data to device global memory. + +Reading buffer contents on host cannot happen lazily, as we have to obtain a pointer to the buffer's contents. This happens internally inside `cl::copy( cl::CommandQueue, cl::Buffer, Iter, Iter )`. + +#### Explicit host-device-host buffer movement + +Note that this sample uses the more minimal `cl::Buffer{ cl::Context, Iter, Iter, bool }` buffer constructor (henceforth CTOR) overload, but there exists a `cl::Buffer{ cl::CommandQueue, Iter, Iter, bool }` overload, which still inside the CTOR invokes obtains the context of the queue, creates the buffer with it, followed by a `cl::copy( cl::CommandQueue, Iter, Iter, cl::Buffer )` which copies to the device associated with the queue using `cl::CommandQueue::enqueueMapBuffer`. + +### In-order queue usage + +While our kernel launch operation is asynchronous (and the host validation set is calculated concurrently, even if we use `CL_DEVICE_TYPE_CPU`), one may think that if the host is fast enough it's possible to fetch buffer contents before the device finishes running the kernels. This doesn't happen, because the queue we created had no properties specified (no `cl::QueueProperties::OutOfOrder`) and therefore commands enqueued are not allowed to overtake each other, so `cl::copy` may only start once the previous kernel has finished executing (and it's memory operations are visible to subsequent commands). + +### Used API surface + +```c++ +cl::util::get_context(cl::util::Triplet) +cl::Context::getInfo() +cl::CommandQueue(cl::Context, cl::Device) +cl::Device::getInfo() +cl::util::get_program(cl::Context, cl::string) +cl::KernelFunctor<...>(cl::Program, const char*) +cl::sdk::fill_with_random(...) +cl::Buffer(cl::CommandQueue, Iter, Iter, bool) +cl::copy(cl::CommandQueue, cl::Buffer, Iter, Iter) +``` diff --git a/samples/core/saxpy/main.c b/samples/core/saxpy/main.c new file mode 100644 index 00000000..13804439 --- /dev/null +++ b/samples/core/saxpy/main.c @@ -0,0 +1,258 @@ +/* + * Copyright (c) 2021 The Khronos Group Inc. + * + * 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. + */ + +// OpenCL SDK includes +#include +#include +#include + +// STL includes +#include +#include +#include +#include + +// Sample-specific option +struct options_Saxpy +{ + size_t length; +}; + +cag_option SaxpyOptions[] = { { .identifier = 'l', + .access_letters = "l", + .access_name = "length", + .value_name = "(positive integer)", + .description = "Length of input" } }; + +ParseState parse_SaxpyOptions(const char identifier, + cag_option_context *cag_context, + struct options_Saxpy *opts) +{ + const char *value; + switch (identifier) + { + case 'l': + if ((value = cag_option_get_value(cag_context))) + { + opts->length = strtoul(value, NULL, 0); + return ParsedOK; + } + else + return ParseError; + } + return NotParsed; +} + +cl_int parse_options(int argc, char *argv[], + struct cl_sdk_options_Diagnostic *diag_opts, + struct cl_sdk_options_SingleDevice *dev_opts, + struct options_Saxpy *saxpy_opts) +{ + cl_int error = CL_SUCCESS; + struct cag_option *opts = NULL, *tmp = NULL; + size_t n = 0; + + /* Prepare all options array. */ + MEM_CHECK(opts = add_CLI_options(opts, &n, DiagnosticOptions, + CAG_ARRAY_SIZE(DiagnosticOptions)), + error, end); + MEM_CHECK(tmp = add_CLI_options(opts, &n, SingleDeviceOptions, + CAG_ARRAY_SIZE(SingleDeviceOptions)), + error, end); + opts = tmp; + MEM_CHECK(tmp = add_CLI_options(opts, &n, SaxpyOptions, + CAG_ARRAY_SIZE(SaxpyOptions)), + error, end); + opts = tmp; + + char identifier; + cag_option_context cag_context; + + /* Prepare the context and iterate over all options. */ + cag_option_prepare(&cag_context, opts, n, argc, argv); + while (cag_option_fetch(&cag_context)) + { + ParseState state = NotParsed; + identifier = cag_option_get(&cag_context); + + PARS_OPTIONS(parse_DiagnosticOptions(identifier, diag_opts), state); + PARS_OPTIONS( + parse_SingleDeviceOptions(identifier, &cag_context, dev_opts), + state); + PARS_OPTIONS(parse_SaxpyOptions(identifier, &cag_context, saxpy_opts), + state); + + if (identifier == 'h') + { + printf("Usage: saxpy [OPTION]...\n"); + printf("Demonstrates typical OpenCL application layout.\n\n"); + cag_option_print(opts, n, stdout); + exit((state == ParseError) ? CL_INVALID_ARG_VALUE : CL_SUCCESS); + } + } + +end: + free(opts); + return error; +} + +// Random number generator state +pcg32_random_t rng; + +int main(int argc, char *argv[]) +{ + cl_int error = CL_SUCCESS, end_error = CL_SUCCESS; + cl_platform_id platform; + cl_device_id device; + cl_context context; + cl_command_queue queue; + + const char *kernel_location = "./saxpy.cl"; + char *kernel = NULL; + size_t program_size = 0; + cl_program program = NULL; + + // Parse command-line options + struct cl_sdk_options_Diagnostic diag_opts = { .quiet = false, + .verbose = false }; + struct cl_sdk_options_SingleDevice dev_opts = { + .triplet = { 0, 0, CL_DEVICE_TYPE_ALL } + }; + struct options_Saxpy saxpy_opts = { .length = 1048576 }; + + OCLERROR_RET(parse_options(argc, argv, &diag_opts, &dev_opts, &saxpy_opts), + error, end); + + // Create runtime objects based on user preference or default + OCLERROR_PAR(device = cl_util_get_device(dev_opts.triplet.plat_index, + dev_opts.triplet.dev_index, + dev_opts.triplet.dev_type, &error), + error, end); + OCLERROR_PAR(context = + clCreateContext(NULL, 1, &device, NULL, NULL, &error), + error, end); + OCLERROR_PAR(queue = clCreateCommandQueue(context, device, 0, &error), + error, cont); + OCLERROR_RET(clGetDeviceInfo(device, CL_DEVICE_PLATFORM, + sizeof(cl_platform_id), &platform, NULL), + error, cont); +#if CL_HPP_TARGET_OPENCL_VERSION >= 200 + OCLERROR_PAR(queue = clCreateCommandQueueWithProperties(context, device, + NULL, &error), + error, cont); +#else + OCLERROR_PAR(queue = clCreateCommandQueue( + context, device, CL_QUEUE_PROFILING_ENABLE, &error), + error, cont); +#endif + + if (!diag_opts.quiet) + { + cl_util_print_device_info(device); + } + + // Compile kernel + OCLERROR_PAR( + kernel = cl_util_read_text_file(kernel_location, &program_size, &error), + error, que); + + OCLERROR_PAR(program = clCreateProgramWithSource( + context, 1, (const char **)&kernel, &program_size, &error), + error, ker); + OCLERROR_RET(cl_util_build_program(program, device, NULL), error, prg); + + cl_kernel saxpy; + OCLERROR_PAR(saxpy = clCreateKernel(program, "saxpy", &error), error, prg); + + // Initialize host-side storage + const size_t length = saxpy_opts.length; + + pcg32_srandom_r(&rng, 111111, -222); + cl_float *arr_x, *arr_y, a; + MEM_CHECK(arr_x = (cl_float *)malloc(sizeof(cl_float) * length), error, + sxp); + MEM_CHECK(arr_y = (cl_float *)malloc(sizeof(cl_float) * length), error, + arrx); + + cl_sdk_fill_with_random_floats_range(&rng, &a, 1, -100, 100); + cl_sdk_fill_with_random_floats_range(&rng, arr_x, length, -100, 100); + cl_sdk_fill_with_random_floats_range(&rng, arr_y, length, -100, 100); + + // Initialize device-side storage + cl_mem buf_x, buf_y; + OCLERROR_PAR( + buf_x = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, + sizeof(cl_float) * length, arr_x, &error), + error, arry); + OCLERROR_PAR(buf_y = clCreateBuffer( + context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, + sizeof(cl_float) * length, arr_y, &error), + error, bufx); + + // Execute kernel + OCLERROR_RET(clSetKernelArg(saxpy, 0, sizeof(cl_float), &a), error, bufy); + OCLERROR_RET(clSetKernelArg(saxpy, 1, sizeof(cl_mem), &buf_x), error, bufy); + OCLERROR_RET(clSetKernelArg(saxpy, 2, sizeof(cl_mem), &buf_y), error, bufy); + + OCLERROR_RET(clEnqueueNDRangeKernel(queue, saxpy, 1, NULL, &length, NULL, 0, + NULL, NULL), + error, bufy); + + // Concurrently calculate reference dataset + for (size_t i = 0; i < length; ++i) + arr_y[i] = + fmaf(a, arr_x[i], arr_y[i]); // arr_y[i] = a * arr_x[i] + arr_y[i]; + + // Fetch results + OCLERROR_RET(clEnqueueReadBuffer(queue, buf_y, CL_BLOCKING, 0, + sizeof(cl_float) * length, (void *)arr_x, + 0, NULL, NULL), + error, bufy); + + // Validate + for (size_t i = 0; i < length; ++i) + if (arr_y[i] != arr_x[i]) + { + printf("Verification failed! %f != %f at index %zu\n", arr_y[i], + arr_x[i], i); + error = CL_INVALID_VALUE; + if (!diag_opts.verbose) goto bufy; + } + if (error == CL_SUCCESS) printf("Verification passed.\n"); + + // Release resources +bufy: + OCLERROR_RET(clReleaseMemObject(buf_y), end_error, bufx); +bufx: + OCLERROR_RET(clReleaseMemObject(buf_x), end_error, arry); +arry: + free(arr_y); +arrx: + free(arr_x); +sxp: + OCLERROR_RET(clReleaseKernel(saxpy), end_error, prg); +prg: + OCLERROR_RET(clReleaseProgram(program), end_error, ker); +ker: + free(kernel); +que: + OCLERROR_RET(clReleaseCommandQueue(queue), end_error, cont); +cont: + OCLERROR_RET(clReleaseContext(context), end_error, end); +end: + if (error) cl_util_print_error(error); + return error; +} diff --git a/samples/core/saxpy/main.cpp b/samples/core/saxpy/main.cpp new file mode 100644 index 00000000..3b87e293 --- /dev/null +++ b/samples/core/saxpy/main.cpp @@ -0,0 +1,174 @@ +/* + * Copyright (c) 2020 The Khronos Group Inc. + * + * 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. + */ + +// OpenCL SDK includes +#include +#include +#include +#include +#include + +// STL includes +#include +#include +#include +#include +#include +#include // std::make_tuple + +// TCLAP includes +#include + +// Sample-specific option +struct SaxpyOptions +{ + size_t length; +}; + +// Add option to CLI parsing SDK utility +template <> auto cl::sdk::parse() +{ + return std::make_tuple(std::make_shared>( + "l", "length", "Length of input", false, 1'048'576, + "positive integral")); +} +template <> +SaxpyOptions cl::sdk::comprehend( + std::shared_ptr> length_arg) +{ + return SaxpyOptions{ length_arg->getValue() }; +} + +std::valarray fma(float x, std::valarray y, + std::valarray z) +{ + if (y.size() == z.size()) + { + size_t len = y.size(); + std::valarray res(len); + for (size_t i = 0; i < len; ++i) res[i] = fmaf(x, y[i], z[i]); + return res; + } + else + throw std::logic_error("Different sizes!"); +} + +int main(int argc, char* argv[]) +{ + try + { + // Parse command-line options + auto opts = + cl::sdk::parse_cli( + argc, argv); + const auto& diag_opts = std::get<0>(opts); + const auto& dev_opts = std::get<1>(opts); + const auto& saxpy_opts = std::get<2>(opts); + + // Create runtime objects based on user preference or default + cl::Context context = cl::sdk::get_context(dev_opts.triplet); + cl::Device device = context.getInfo().at(0); + cl::CommandQueue queue{ context, device }; + cl::Platform platform{ + device.getInfo() + }; // https://github.com/KhronosGroup/OpenCL-CLHPP/issues/150 + + if (!diag_opts.quiet) + { + std::cout << "Selected platform: " + << platform.getInfo() << "\n" + << "Selected device: " << device.getInfo() + << "\n" + << std::endl; + } + + // Compile kernel + const char* kernel_location = "./saxpy.cl"; + std::ifstream kernel_stream{ kernel_location }; + if (!kernel_stream.is_open()) + throw std::runtime_error{ + std::string{ "Cannot open kernel source: " } + kernel_location + }; + + cl::Program program{ context, + std::string{ std::istreambuf_iterator{ + kernel_stream }, + std::istreambuf_iterator{} } }; + program.build(device); + + auto saxpy = cl::KernelFunctor( + program, "saxpy"); + + // Initialize host-side storage + const auto length = saxpy_opts.length; + + auto prng = [engine = std::default_random_engine{}, + dist = std::uniform_real_distribution{ + -100.0, 100.0 }]() mutable { return dist(engine); }; + + cl_float a = prng(); + std::valarray arr_x(length), arr_y(length); + cl::sdk::fill_with_random(prng, arr_x, arr_y); + + // Initialize device-side storage + cl::Buffer buf_x{ context, std::begin(arr_x), std::end(arr_x), true }, + buf_y{ context, std::begin(arr_y), std::end(arr_y), false }; + + // Execute kernel + saxpy(cl::EnqueueArgs{ queue, cl::NDRange{ length } }, a, buf_x, buf_y); + + // Concurrently calculate reference dataset + arr_y = fma(a, arr_x, arr_y); // a * arr_x + arr_y; + + // Fetch results + cl::copy(queue, buf_y, std::begin(arr_x), std::end(arr_x)); + + // Validate + if (std::equal(std::begin(arr_x), std::end(arr_x), std::begin(arr_y), + std::end(arr_y))) + std::cout << "Verification passed." << std::endl; + else + throw std::runtime_error{ "Verification FAILED!" }; + + return 0; + } catch (cl::util::Error& e) + { + std::cerr << "OpenCL Utils error: " << e.what() << std::endl; + std::exit(e.err()); + } catch (cl::BuildError& e) + { + std::cerr << "OpenCL runtime error: " << e.what() << std::endl; + for (auto& build_log : e.getBuildLog()) + { + std::cerr << "\tBuild log for device: " + << build_log.first.getInfo() << "\n" + << std::endl; + std::cerr << build_log.second << "\n" << std::endl; + } + std::exit(e.err()); + } catch (cl::Error& e) + { + std::cerr << "OpenCL rutnime error: " << e.what() << std::endl; + std::exit(e.err()); + } catch (std::exception& e) + { + std::cerr << "Error: " << e.what() << std::endl; + std::exit(EXIT_FAILURE); + } + + return 0; +} \ No newline at end of file diff --git a/samples/core/saxpy/saxpy.cl b/samples/core/saxpy/saxpy.cl new file mode 100644 index 00000000..c5780872 --- /dev/null +++ b/samples/core/saxpy/saxpy.cl @@ -0,0 +1,8 @@ +__kernel void saxpy(float a, + __global float* x, + __global float* y) +{ + int gid = get_global_id(0); + + y[gid] = fma(a, x[gid], y[gid]); +} diff --git a/samples/extensions/CMakeLists.txt b/samples/extensions/CMakeLists.txt new file mode 100644 index 00000000..6a36d43a --- /dev/null +++ b/samples/extensions/CMakeLists.txt @@ -0,0 +1,15 @@ +# Copyright (c) 2020 The Khronos Group Inc. +# +# 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. + +add_subdirectory(khr) diff --git a/samples/extensions/khr/.keepme b/samples/extensions/khr/.keepme deleted file mode 100644 index e69de29b..00000000 diff --git a/samples/extensions/khr/CMakeLists.txt b/samples/extensions/khr/CMakeLists.txt new file mode 100644 index 00000000..82d4426f --- /dev/null +++ b/samples/extensions/khr/CMakeLists.txt @@ -0,0 +1,19 @@ +# Copyright (c) 2020 The Khronos Group Inc. +# +# 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. + +add_subdirectory(histogram) +if(OPENCL_SDK_BUILD_OPENGL_SAMPLES) + add_subdirectory(conway) + add_subdirectory(nbody) +endif() diff --git a/samples/extensions/khr/conway/CMakeLists.txt b/samples/extensions/khr/conway/CMakeLists.txt new file mode 100644 index 00000000..8dc523ef --- /dev/null +++ b/samples/extensions/khr/conway/CMakeLists.txt @@ -0,0 +1,23 @@ +# Copyright (c) 2021 The Khronos Group Inc. +# +# 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. + +add_sample( + TARGET conwaycpp + VERSION 120 + SOURCES main.cpp + KERNELS conway.cl + SHADERS + conway.vert.glsl + conway.frag.glsl + ) diff --git a/samples/extensions/khr/conway/README.md b/samples/extensions/khr/conway/README.md new file mode 100644 index 00000000..33429bfd --- /dev/null +++ b/samples/extensions/khr/conway/README.md @@ -0,0 +1,39 @@ +# Conway's Game of Life + +## Sample Purpose + +This sample intends to demonstrate how to share images (textures) between OpenCL and OpenGL. [How Does OpenCL-OpenGL Interop?](https://github.com/KhronosGroup/OpenCL-Guide/blob/main/chapters/how_does_opencl-opencl_interop.md) chapter of the OpenCL-Guide lays out the fundamentals of OpenCL-OpenGL interoperability. + +## Key APIs and Concepts + +The most important aspect of this sample is to understand how OpenCL-OpenGL interop contexts and shared resources are setup. The `cl::sdk::get_interop_context` function takes much of the tedium out of setting up such a context while the `cl::sdk::InteropWindow` adds "GLUT-like" features, dealing with typical windowed interop app control flow, making sure that API objects are created in the correct order. + +### Application flow + +Application flow is primarily dictated by `cl::sdk::InteropWindow`, more specifically by `cl::sdk::InteropWindow::run()`. For a deatiled overview of what the `InteropWindow` utility does, please refer to the [Utils documentation](../../../../lib/Utils.md). + +### Double buffering + +The kernel used to implement the stepping routine uses double-buffering of the shared textures. Without double buffering a data race arises between the pixels of the image. + +### Implicit interop context synchronization + +This sample uses basic and implicit interop context synchronization.For a detailed overview on the various ways OpenCL and OpenGL can be synchronized, refer to [Synchronizing the two APIs](https://github.com/KhronosGroup/OpenCL-Guide/blob/main/chapters/how_does_opencl-opencl_interop.md#Synchronizing-the-two-APIs) section of the OpenCL-OpenGL interop guide. + +## Kernel logic + +The kernel implements the classic [Game of Life rules](https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life#Rules). Each pixel of the texture is 1 byte in size, which is stored in the red channel and is used to code 1 bit of data. (The current 1:7 useful:waste bit ratio can be improved in multiple ways, most trivially by bitcoding the data and storing muliple lattice sites in one pixel coordinate.) + +### Used API surface + +```c++ +cl::util::get_context(cl::util::Triplet) +cl::Context::getInfo() +cl::CommandQueue(cl::Context, cl::Device) +cl::Device::getInfo() +cl::util::get_program(cl::Context, cl::string) +cl::KernelFunctor<...>(cl::Program, const char*) +cl::sdk::fill_with_random(...) +cl::Buffer(cl::CommandQueue, Iter, Iter, bool) +cl::copy(cl::CommandQueue, cl::Buffer, Iter, Iter) +``` \ No newline at end of file diff --git a/samples/extensions/khr/conway/conway.cl b/samples/extensions/khr/conway/conway.cl new file mode 100644 index 00000000..471455dd --- /dev/null +++ b/samples/extensions/khr/conway/conway.cl @@ -0,0 +1,25 @@ +#define read_cell(delta) read_imageui(front, periodic, (gidf + delta) * inv_image_size + d_2).x + +__kernel void conway( + __read_only image2d_t front, + __write_only image2d_t back, + float2 inv_image_size +) +{ + const sampler_t periodic = CLK_NORMALIZED_COORDS_TRUE | CLK_FILTER_NEAREST | CLK_ADDRESS_REPEAT; + + int2 gid = (int2)(get_global_id(0), get_global_id(1)); + float2 gidf = (float2)(gid.x, gid.y); + float2 d_2 = inv_image_size * 0.5f; + + uchar self = read_cell((float2)(0, 0)); + uchar count = + read_cell((float2)(-1,+1)) + read_cell((float2)(0,+1)) + read_cell((float2)(+1,+1)) + + read_cell((float2)(-1, 0)) + + read_cell((float2)(+1, 0)) + + read_cell((float2)(-1,-1)) + read_cell((float2)(0,-1)) + read_cell((float2)(+1,-1)); + + write_imageui(back, gid, self ? + (count < 2 || count > 3 ? 0 : 1) : + (count == 3 ? 1 : 0) + ); +} diff --git a/samples/extensions/khr/conway/conway.frag.glsl b/samples/extensions/khr/conway/conway.frag.glsl new file mode 100644 index 00000000..662afddf --- /dev/null +++ b/samples/extensions/khr/conway/conway.frag.glsl @@ -0,0 +1,19 @@ +#version 330 + +// VS locations +#define POSITION 0 +#define TEXCOORD 1 + +in block +{ + vec2 TexCoord; +} FS_In; + +out vec4 FragColor; + +uniform usampler2D texsampler; + +void main() +{ + FragColor = texture(texsampler, FS_In.TexCoord); +} diff --git a/samples/extensions/khr/conway/conway.vert.glsl b/samples/extensions/khr/conway/conway.vert.glsl new file mode 100644 index 00000000..9df52c64 --- /dev/null +++ b/samples/extensions/khr/conway/conway.vert.glsl @@ -0,0 +1,20 @@ +#version 330 + +// VS locations +#define POSITION 0 +#define TEXCOORD 1 + +layout(location = POSITION) in vec2 in_Position; +layout(location = TEXCOORD) in vec2 in_TexCoord; + +out block +{ + vec2 TexCoord; +} VS_Out; + +void main() +{ + gl_Position = vec4(in_Position, 0.0, 1.0); + + VS_Out.TexCoord = in_TexCoord; +} diff --git a/samples/extensions/khr/conway/main.cpp b/samples/extensions/khr/conway/main.cpp new file mode 100644 index 00000000..2e8a9061 --- /dev/null +++ b/samples/extensions/khr/conway/main.cpp @@ -0,0 +1,399 @@ +/* + * Copyright (c) 2020 The Khronos Group Inc. + * + * 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. + */ + +#include + +// OpenCL SDK includes +#include + +// OpenCL Utils includes +#include + +// STL includes +#include +#include +#include +#include +#include +#include // std::make_tuple + +// OpenGL includes +#include +#include + +template struct DoubleBuffer +{ + T front, back; + + void swap() { std::swap(front, back); } +}; + +class Conway : public cl::sdk::InteropWindow { +public: + explicit Conway(int width, int height, bool fullscreen, + cl_uint platform_id = 0, cl_uint device_id = 0, + cl_bitfield device_type = CL_DEVICE_TYPE_DEFAULT) + : InteropWindow{ + sf::VideoMode(width, height), + "Conway's Game of Life", + fullscreen ? sf::Style::Fullscreen : sf::Style::Default, + sf::ContextSettings{ 0, 0, 0, // Depth, Stencil, AA + 3, 3, // OpenGL version + sf::ContextSettings::Attribute::Core }, + platform_id, + device_id, + device_type + } + {} + +protected: + virtual void + initializeGL() override; // Function that initializes all OpenGL assets + // needed to draw a scene + virtual void + initializeCL() override; // Function that initializes all OpenCL assets + // needed to draw a scene + virtual void + updateScene() override; // Function that holds scene update guaranteed not + // to conflict with drawing + virtual void render() override; // Function that does the native rendering + virtual void event(const sf::Event& e) + override; // Function that handles render area resize + +private: + // OpenGL objects + cl_GLuint vertex_shader, fragment_shader, gl_program; + cl_GLuint vertex_buffer, vertex_array; + DoubleBuffer gl_images; + + // OpenCL objects + cl::Device device; + cl::CommandQueue queue; + cl::Program cl_program; + cl::Kernel kernel; + cl::Sampler sampler; + + DoubleBuffer cl_images; + cl::vector interop_resources; +}; + +inline bool checkError(const char* Title) +{ + int Error; + if ((Error = glGetError()) != GL_NO_ERROR) + { + std::string ErrorString; + switch (Error) + { + case GL_INVALID_ENUM: ErrorString = "GL_INVALID_ENUM"; break; + case GL_INVALID_VALUE: ErrorString = "GL_INVALID_VALUE"; break; + case GL_INVALID_OPERATION: + ErrorString = "GL_INVALID_OPERATION"; + break; + case GL_INVALID_FRAMEBUFFER_OPERATION: + ErrorString = "GL_INVALID_FRAMEBUFFER_OPERATION"; + break; + case GL_OUT_OF_MEMORY: ErrorString = "GL_OUT_OF_MEMORY"; break; + default: ErrorString = "UNKNOWN"; break; + } + std::cerr << "OpenGL Error(" << ErrorString.c_str() << "): " << Title + << std::endl; + } + return Error == GL_NO_ERROR; +} + +void Conway::initializeGL() +{ + if (glewInit() != GLEW_OK) std::exit(EXIT_FAILURE); + + auto create_shader = [](std::string file_path, cl_GLenum shader_stage) { + std::ifstream shader_stream(file_path); + std::string shader_string{ std::istreambuf_iterator{ + shader_stream }, + std::istreambuf_iterator{} }; + auto pshader_string = shader_string.c_str(); + GLuint shader = glCreateShader(shader_stage); + glShaderSource(shader, 1, &pshader_string, NULL); + checkError("glShaderSource(shader, 1, &pshader_string, NULL)"); + glCompileShader(shader); + checkError("glCompileShader(shader)"); + + GLint status = GL_FALSE; + glGetShaderiv(shader, GL_COMPILE_STATUS, &status); + checkError("glGetShaderiv(shader, GL_COMPILE_STATUS, &status)"); + if (status != GL_TRUE) + { + int log_length = 0; + glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_length); + checkError( + "glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_length)"); + std::vector shader_log(log_length); + glGetShaderInfoLog(shader, log_length, NULL, shader_log.data()); + checkError("glGetShaderInfoLog(shader, log_length, NULL, " + "shader_log.data())"); + std::cerr << std::string(shader_log.cbegin(), shader_log.cend()) + << std::endl; + } + + return shader; + }; + auto create_program = [](std::initializer_list shader_stages) { + GLuint program = glCreateProgram(); + checkError("glCreateProgram()"); + for (auto shader_stage : shader_stages) + { + glAttachShader(program, shader_stage); + checkError("glAttachShader(program, shader_stage)"); + } + + glLinkProgram(program); + checkError("glLinkProgram(program)"); + GLint status = GL_FALSE; + glGetProgramiv(program, GL_LINK_STATUS, &status); + checkError("glGetProgramiv(program, GL_LINK_STATUS, &status)"); + if (status != GL_TRUE) + { + int log_length = 0; + glGetProgramiv(program, GL_INFO_LOG_LENGTH, &log_length); + checkError( + "glGetProgramiv(program, GL_INFO_LOG_LENGTH, &log_length)"); + std::vector program_log(log_length); + glGetProgramInfoLog(program, log_length, NULL, program_log.data()); + checkError("glGetProgramInfoLog(program, log_length, NULL, " + "program_log.data())"); + std::cerr << std::string(program_log.cbegin(), program_log.cend()) + << std::endl; + } + + return program; + }; + + vertex_shader = create_shader("./conway.vert.glsl", GL_VERTEX_SHADER); + fragment_shader = create_shader("./conway.frag.glsl", GL_FRAGMENT_SHADER); + gl_program = create_program({ vertex_shader, fragment_shader }); + + std::vector quad = + // vertices , tex coords + // x , y , u , v + { -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f, 1.0f, + 1.0f, -1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f }; + + glGenBuffers(1, &vertex_buffer); + checkError("glGenBuffers(1, &vertex_buffer)"); + glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer); + checkError("glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer)"); + glBufferData(GL_ARRAY_BUFFER, quad.size() * sizeof(float), quad.data(), + GL_STATIC_DRAW); + checkError("glBufferData(GL_ARRAY_BUFFER, quad.size() * sizeof(float), " + "quad.data(), GL_STATIC_DRAW)"); + glBindBuffer(GL_ARRAY_BUFFER, 0); + checkError("glBindBuffer(GL_ARRAY_BUFFER, 0)"); + + glGenVertexArrays(1, &vertex_array); + checkError("glGenVertexArrays(1, &vertex_array)"); + glBindVertexArray(vertex_array); + checkError("glBindVertexArray(vertex_array)"); + glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer); + checkError("glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer)"); + glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), + (GLvoid*)(NULL)); + checkError("glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, " + "4*sizeof(float), (GLvoid *)(NULL))"); + glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), + (GLvoid*)(0 + 2 * sizeof(float))); + checkError("glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, " + "4*sizeof(float), (GLvoid *)(0 + 2 * sizeof(float)))"); + glEnableVertexAttribArray(0); + checkError("glEnableVertexAttribArray(0)"); + glEnableVertexAttribArray(1); + checkError("glEnableVertexAttribArray(1)"); + glBindVertexArray(0); + checkError("glBindVertexArray(0)"); + + std::vector texels; + std::generate_n( + std::back_inserter(texels), getSize().x * getSize().y, + [prng = std::ranlux48{ std::random_device{}() }, + dist = std::uniform_int_distribution{ + 0, 1 }]() mutable { return static_cast(dist(prng)); }); + + glUseProgram(gl_program); + checkError(""); + for (auto image : { &gl_images.front, &gl_images.back }) + { + glGenTextures(1, image); + checkError("glGenTextures(1, image);"); + glActiveTexture(GL_TEXTURE0); + checkError("glActiveTexture(GL_TEXTURE0);"); + glBindTexture(GL_TEXTURE_2D, *image); + checkError("glBindTexture(GL_TEXTURE_2D, *image);"); + glTexImage2D(GL_TEXTURE_2D, 0, GL_R8UI, getSize().x, getSize().y, 0, + GL_RED_INTEGER, GL_UNSIGNED_BYTE, texels.data()); + checkError( + "glTexImage2D(GL_TEXTURE_2D, 0, GL_R8UI, getSize().x, getSize().y, " + "0, GL_RED_INTEGER, GL_UNSIGNED_BYTE, texels.data())"); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + checkError( + "glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);"); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + checkError( + "glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);"); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + checkError("glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, " + "GL_NEAREST);"); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + checkError("glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, " + "GL_NEAREST);"); + glBindTexture(GL_TEXTURE_2D, 0); + checkError("glBindTexture(GL_TEXTURE_2D, 0);"); + } + glUseProgram(0); + checkError("glUseProgram(0);"); + + glViewport(0, 0, getSize().x, getSize().y); + checkError("glViewport(0, 0, getSize().x, getSize().y)"); + glDisable(GL_DEPTH_TEST); + checkError("glDisable(GL_DEPTH_TEST)"); +} + +void Conway::initializeCL() +{ + device = opencl_context.getInfo().at(0); + queue = cl::CommandQueue{ opencl_context, device }; + + // Compile kernel + const char* kernel_location = "./conway.cl"; + std::ifstream kernel_stream{ kernel_location }; + if (!kernel_stream.is_open()) + throw std::runtime_error{ std::string{ "Cannot open kernel source: " } + + kernel_location }; + + cl_program = cl::Program{ opencl_context, + std::string{ std::istreambuf_iterator{ + kernel_stream }, + std::istreambuf_iterator{} } }; + cl_program.build(device); + kernel = cl::Kernel{ cl_program, "conway" }; + + // Translate OpenGL object handles into OpenCL handles + cl_images.front = cl::ImageGL{ opencl_context, CL_MEM_READ_WRITE, + GL_TEXTURE_2D, 0, gl_images.front }; + cl_images.back = cl::ImageGL{ opencl_context, CL_MEM_READ_WRITE, + GL_TEXTURE_2D, 0, gl_images.back }; + + // Translate + interop_resources = + cl::vector{ cl_images.front, cl_images.back }; +} + +void Conway::updateScene() +{ + auto conway = + cl::KernelFunctor{ cl_program, + "conway" }; + cl::Event acquire, release; + + queue.enqueueAcquireGLObjects(&interop_resources, nullptr, &acquire); + + conway(cl::EnqueueArgs{ queue, cl::NDRange{ getSize().x, getSize().y } }, + cl_images.front, cl_images.back, + cl_float2{ 1.f / getSize().x, 1.f / getSize().y }); + + queue.enqueueReleaseGLObjects(&interop_resources, nullptr, &release); + + // Wait for all OpenCL commands to finish + if (!cl_khr_gl_event_supported) + cl::finish(); + else + release.wait(); + + // Swap front and back buffer handles + std::swap(cl_images.front, cl_images.back); + std::swap(gl_images.front, gl_images.back); +} + +void Conway::render() +{ + glClear(GL_COLOR_BUFFER_BIT); + + glUseProgram(gl_program); + glBindVertexArray(vertex_array); + glBindTexture(GL_TEXTURE_2D, gl_images.front); + + glDrawArrays(GL_TRIANGLE_STRIP, 0, static_cast(4)); + + glBindTexture(GL_TEXTURE_2D, 0); + glBindVertexArray(0); + glUseProgram(0); + + // Wait for all drawing commands to finish + if (!cl_khr_gl_event_supported) + glFinish(); + else + glFlush(); +} + +void Conway::event(const sf::Event& event) +{ + switch (event.type) + { + case sf::Event::Closed: close(); break; + } +} + +int main(int argc, char* argv[]) +{ + try + { + // Parse command-line options + auto opts = cl::sdk::parse_cli(argc, argv); + const auto& dev_opts = std::get<1>(opts).triplet; + const auto& win_opts = std::get<2>(opts); + + Conway window{ win_opts.width, win_opts.height, + win_opts.fullscreen, dev_opts.plat_index, + dev_opts.dev_index, dev_opts.dev_type }; + + window.run(); + } catch (cl::util::Error& e) + { + std::cerr << "OpenCL Utils error: " << e.what() << std::endl; + std::exit(e.err()); + } catch (cl::BuildError& e) + { + std::cerr << "OpenCL runtime error: " << e.what() << std::endl; + for (auto& build_log : e.getBuildLog()) + { + std::cerr << "\tBuild log for device: " + << build_log.first.getInfo() << "\n" + << std::endl; + std::cerr << build_log.second << "\n" << std::endl; + } + std::exit(e.err()); + } catch (cl::Error& e) + { + std::cerr << "OpenCL rutnime error: " << e.what() << std::endl; + std::exit(e.err()); + } catch (std::exception& e) + { + std::cerr << "Error: " << e.what() << std::endl; + std::exit(EXIT_FAILURE); + } + + return 0; +} diff --git a/samples/extensions/khr/histogram/CMakeLists.txt b/samples/extensions/khr/histogram/CMakeLists.txt new file mode 100644 index 00000000..f32e719f --- /dev/null +++ b/samples/extensions/khr/histogram/CMakeLists.txt @@ -0,0 +1,20 @@ +# Copyright (c) 2021 The Khronos Group Inc. +# +# 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. + +add_sample( + TEST + TARGET histogramcpp + VERSION 120 + SOURCES main.cpp + KERNELS histogram.cl) diff --git a/samples/extensions/khr/histogram/README.md b/samples/extensions/khr/histogram/README.md new file mode 100644 index 00000000..27d6ccb4 --- /dev/null +++ b/samples/extensions/khr/histogram/README.md @@ -0,0 +1,50 @@ +# histogram + +The sample calculate the histogram of a random sequence with global atomic add and when it is possible, it's using local atomic add. + +## Sample Purpose + +This sample intends to be a minimal end-to-end OpenCL application doing actual device-side computation. The structure of the sample rhymes well with the [How Does OpenCL Work?](https://github.com/KhronosGroup/OpenCL-Guide/blob/main/chapters/how_does_opencl_work.md) chapter of the OpenCL-Guide, particularly the [Executing an OpenCL Program](https://github.com/KhronosGroup/OpenCL-Guide/blob/main/chapters/how_does_opencl_work.md#executing-an-opencl-program) part. + +This sample is implemented using C++ languages. + +## Key APIs and Concepts + +The most important aspect of this sample is to understand what entities / API objects are involved in the execution of a typical OpenCL application. + +### Application flow + +You may note that the actual order in creating the relevant API objects in this sample differs slightly from the list in [Executing an OpenCL Program](https://github.com/KhronosGroup/OpenCL-Guide/blob/main/chapters/how_does_opencl_work.md#executing-an-opencl-program). That is because the actual data dependence allows for some flexibility. The most important is obtaining a `cl_context`/`cl::Context`, because that is _the alpha and the omega_ of all other API objects in the runtime layer. For a distinction on where the platform layer ends and where the runtime layer begings, refer to **REF**. + +If we aim for absolute fastest execution, compiling our kernel may have been concurrent to initializing our input data. + +### Lazy buffer movement + +OpenCL buffers when created are bound to a context, not any specific device. Device-local physical memory is conceptually used as a cache to access the contents of the buffer. (See [OpenCL API - Memory Model: Fundamental Memory Regions](https://www.khronos.org/registry/OpenCL/specs/3.0-unified/html/OpenCL_API.html#_fundamental_memory_regions)) To paraphrase, one may think of buffers migrating from device-to-device as needed, while the OpenCL Runtime keeps track of where the most current (last written) contents reside. + +This sample creates buffers, specifies their initial content with an iterator range spanning host containers and launches a kernel using said buffer. The OpenCL Runtime will take care of dispatching data to device global memory. + +Reading buffer contents on host cannot happen lazily, as we have to obtain a pointer to the buffer's contents. This happens internally inside `cl::copy( cl::CommandQueue, cl::Buffer, Iter, Iter )`. + +#### Explicit host-device-host buffer movement + +Note that this sample uses the more minimal `cl::Buffer{ cl::Context, Iter, Iter, bool }` buffer constructor (henceforth CTOR) overload, but there exists a `cl::Buffer{ cl::CommandQueue, Iter, Iter, bool }` overload, which still inside the CTOR invokes obtains the context of the queue, creates the buffer with it, followed by a `cl::copy( cl::CommandQueue, Iter, Iter, cl::Buffer )` which copies to the device associated with the queue using `cl::CommandQueue::enqueueMapBuffer`. + +### In-order queue usage + +While our kernel launch operation is asynchronous (and the host validation set is calculated concurrently, even if we use `CL_DEVICE_TYPE_CPU`), one may think that if the host is fast enough it's possible to fetch buffer contents before the device finishes running the kernels. This doesn't happen, because the queue we created had no properties specified (no `cl::QueueProperties::OutOfOrder`) and therefore commands enqueued are not allowed to overtake each other, so `cl::copy` may only start once the previous kernel has finished executing (and it's memory operations are visible to subsequent commands). + +### Used API surface + +```c++ +cl::util::get_context(cl::util::Triplet) +cl::Context::getInfo() +cl::CommandQueue(cl::Context, cl::Device) +cl::Device::getInfo() +cl::util::get_program(cl::Context, cl::string) +cl::KernelFunctor<...>(cl::Program, const char*) +cl::sdk::fill_with_random(...) +cl::Buffer(cl::CommandQueue, Iter, Iter, bool) +cl::copy(cl::CommandQueue, cl::Buffer, Iter, Iter) +unsigned int atomic_add (volatile __global unsigned int *p, unsigned int val) +``` diff --git a/samples/extensions/khr/histogram/histogram.cl b/samples/extensions/khr/histogram/histogram.cl new file mode 100644 index 00000000..f597b1a1 --- /dev/null +++ b/samples/extensions/khr/histogram/histogram.cl @@ -0,0 +1,91 @@ +uint binary_search(float value, __global float* levels_array, uint bins) +{ + int left_id = 0; + uint right_id = bins; + + while(left_id < right_id) + { + uint mid_id = (left_id + right_id) / 2; + float level = levels_array[mid_id]; + bool smaller = level <= value; + left_id = smaller ? mid_id + 1 : left_id; + right_id = smaller ? right_id : mid_id; + } + + return max(0, left_id - 1); +} + +__kernel void histogram_shared( + uint input_size, + uint bins, + uint items_per_thread, + __global float* input_array, + __global float* levels_array, + __local uint* block_histogram, + __global uint* histogram +) { + size_t gid = get_global_id(0); + int lid = get_local_id(0); + uint lsize = get_local_size(0); + uint channel_per_thread = ( bins + lsize - 1 ) / lsize; + + for( + uint channel = channel_per_thread * lid; + channel < min(channel_per_thread * (lid + 1) , bins); + channel++ + ){ + block_histogram[channel] = 0; + } + barrier(CLK_LOCAL_MEM_FENCE); + + + // Histogram calculation on shared memory + for( uint index = 0; index < items_per_thread; index++ ) + { + size_t element_index = gid * items_per_thread + index; + + if( element_index < input_size ) + { + float value = input_array[element_index]; + if( levels_array[0] < value && value < levels_array[bins] ) + { + uint channel = binary_search(value, levels_array, bins); + + atomic_add(&block_histogram[channel], 1); + } + } + } + barrier(CLK_LOCAL_MEM_FENCE); + + // Sum up the results to global memory + for( + uint channel = channel_per_thread * lid; + channel < min(channel_per_thread * (lid + 1) , bins); + channel++ + ){ + if( block_histogram[channel] > 0) + { + atomic_add(&histogram[channel], block_histogram[channel]); + } + } +} + +__kernel void histogram_global( + uint input_size, + uint bins, + __global float* input_array, + __global float* levels_array, + __global uint* histogram +) { + int gid = get_global_id(0); + + float value = input_array[gid]; + + if( levels_array[0] < value && value < levels_array[bins] ) + return; + + // binary search + uint channel = binary_search(input_array[gid], levels_array, bins); + + atomic_add(&histogram[channel], 1u); +} diff --git a/samples/extensions/khr/histogram/main.cpp b/samples/extensions/khr/histogram/main.cpp new file mode 100644 index 00000000..433ba2de --- /dev/null +++ b/samples/extensions/khr/histogram/main.cpp @@ -0,0 +1,213 @@ +/* + * Copyright (c) 2020 The Khronos Group Inc. + * + * 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. + */ + +// OpenCL SDK includes +#include +#include +#include +#include +#include + +// STL includes +#include +#include +#include +#include +#include +#include // std::make_tuple + +// TCLAP includes +#include + +// Sample-specific option +struct HistogramOptions +{ + size_t length; + size_t bins; +}; + +// Add option to CLI parsing SDK utility +template <> auto cl::sdk::parse() +{ + return std::make_tuple( + std::make_shared>( + "l", "length", "Length of input", false, 1'048'576, + "positive integral"), + std::make_shared>( + "b", "bins", "Bins of histogram", false, 100, "positive integral")); +} +template <> +HistogramOptions cl::sdk::comprehend( + std::shared_ptr> length_arg, + std::shared_ptr> bins_arg) +{ + return HistogramOptions{ length_arg->getValue(), bins_arg->getValue() }; +} + +int main(int argc, char* argv[]) +{ + try + { + // Parse command-line options + auto opts = cl::sdk::parse_cli(argc, argv); + const auto& diag_opts = std::get<0>(opts); + const auto& dev_opts = std::get<1>(opts); + const auto& histogram_opts = std::get<2>(opts); + + // Create runtime objects based on user preference or default + cl::Context context = cl::sdk::get_context(dev_opts.triplet); + cl::Device device = context.getInfo().at(0); + cl::CommandQueue queue{ context, device }; + cl::Platform platform{ + device.getInfo() + }; // https://github.com/KhronosGroup/OpenCL-CLHPP/issues/150 + + if (!diag_opts.quiet) + { + std::cout << "Selected platform: " + << platform.getInfo() << "\n" + << "Selected device: " << device.getInfo() + << "\n" + << "Selected local memory size: " + << device.getInfo() << "\n" + << std::endl; + } + + // Compile kernel + const char* kernel_location = "./histogram.cl"; + std::ifstream kernel_stream{ kernel_location }; + if (!kernel_stream.is_open()) + throw std::runtime_error{ + std::string{ "Cannot open kernel source: " } + kernel_location + }; + + cl::Program program{ context, + std::string{ std::istreambuf_iterator{ + kernel_stream }, + std::istreambuf_iterator{} } }; + program.build(device); + + auto histogram_shared = + cl::KernelFunctor( + program, "histogram_shared"); + auto histogram_global = + cl::KernelFunctor(program, "histogram_global"); + + // Initialize host-side storage + const auto length = histogram_opts.length; + const auto bins = histogram_opts.bins; + + const float min = -100.0f; + const float max = 100.0f; + + auto prng = [engine = std::default_random_engine{}, + dist = std::uniform_real_distribution{ + min, max }]() mutable { return dist(engine); }; + + std::valarray input(length); + std::valarray levels(bins + 1); + std::valarray histogram(length); + + // Initialize input variables + cl::sdk::fill_with_random(prng, input); + cl_float epsilon = (max - min) / bins; + for (cl_uint index = 0; index < bins; index++) + { + levels[index] = min + epsilon * index; + } + levels[bins] = max; + + // Initialize device-side storage + cl::Buffer buf_input{ context, std::begin(input), std::end(input), + true }, + buf_levels{ context, std::begin(levels), std::end(levels), true }, + buf_histogram{ context, std::begin(histogram), std::end(histogram), + false }; + + // Execute kernel + if (bins * sizeof(cl_uint) + <= device.getInfo()) + { + size_t items_per_thread = 32; + size_t grid_size = + (length + items_per_thread - 1) / items_per_thread; + histogram_shared(cl::EnqueueArgs{ queue, cl::NDRange{ grid_size } }, + length, bins, items_per_thread, buf_input, + buf_levels, cl::Local(bins * sizeof(cl_uint)), + buf_histogram); + } + else + { + histogram_global(cl::EnqueueArgs{ queue, cl::NDRange{ length } }, + length, bins, buf_input, buf_levels, + buf_histogram); + } + + // Concurrently calculate reference dataset + std::vector histogram_expected(bins, 0); + for (const auto value : input) + { + if (value >= levels[0] && value < levels[bins]) + { + const auto bin_iter = std::upper_bound(std::begin(levels), + std::end(levels), value); + histogram_expected[bin_iter - std::begin(levels) - 1]++; + } + } + + // Fetch results + cl::copy(queue, buf_histogram, std::begin(histogram), + std::end(histogram)); + + // Validate + if (std::equal(std::begin(histogram_expected), + std::end(histogram_expected), std::begin(histogram))) + std::cout << "Verification passed." << std::endl; + else + throw std::runtime_error{ "Verification FAILED!" }; + + return 0; + } catch (cl::util::Error& e) + { + std::cerr << "OpenCL Utils error: " << e.what() << std::endl; + std::exit(e.err()); + } catch (cl::BuildError& e) + { + std::cerr << "OpenCL runtime error: " << e.what() << std::endl; + for (auto& build_log : e.getBuildLog()) + { + std::cerr << "\tBuild log for device: " + << build_log.first.getInfo() << "\n" + << std::endl; + std::cerr << build_log.second << "\n" << std::endl; + } + std::exit(e.err()); + } catch (cl::Error& e) + { + std::cerr << "OpenCL rutnime error: " << e.what() << std::endl; + std::exit(e.err()); + } catch (std::exception& e) + { + std::cerr << "Error: " << e.what() << std::endl; + std::exit(EXIT_FAILURE); + } + + return 0; +} diff --git a/samples/extensions/khr/nbody/CMakeLists.txt b/samples/extensions/khr/nbody/CMakeLists.txt new file mode 100644 index 00000000..6685d88e --- /dev/null +++ b/samples/extensions/khr/nbody/CMakeLists.txt @@ -0,0 +1,23 @@ +# Copyright (c) 2021 The Khronos Group Inc. +# +# 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. + +add_sample( + TARGET nbodycpp + VERSION 120 + SOURCES main.cpp + KERNELS nbody.cl + SHADERS + nbody.vert.glsl + nbody.frag.glsl + ) diff --git a/samples/extensions/khr/nbody/README.md b/samples/extensions/khr/nbody/README.md new file mode 100644 index 00000000..139de3d4 --- /dev/null +++ b/samples/extensions/khr/nbody/README.md @@ -0,0 +1,39 @@ +# Gravitational NBody + +## Sample Purpose + +This sample intends to demonstrate how to share (vertex) buffers between OpenCL and OpenGL. [How Does OpenCL-OpenGL Interop?](https://github.com/KhronosGroup/OpenCL-Guide/blob/main/chapters/how_does_opencl-opencl_interop.md) chapter of the OpenCL-Guide lays out the fundamentals of OpenCL-OpenGL interoperability. + +## Key APIs and Concepts + +The most important aspect of this sample is to understand how OpenCL-OpenGL interop contexts and shared resources are setup. The `cl::util::get_interop_context` function takes much of the tedium out of setting up such a context while the `cl::util::InteropWindow` adds "GLUT-like" features, dealing with typical windowed interop app control flow, making sure that API objects are created in the correct order. + +### Application flow + +Application flow is primarily dictated by `cl::sdk::InteropWindow`, more specifically by `cl::ask::InteropWindow::run()`. For a detailed overview of what the `InteropWindow` utility does, please refer to the [SDK library documentation](../../../../lib/SDK.md). + +### Double buffering + +The kernel used to implement the gravitational interaction and time-stepping in a fused manner uses double-buffering of some of the data. It is not possible to calculate forces between the particles and carry out the forward-Euler in the same kernel without global syncing. (Some praticles may have already updated their position while others are still summing up forces, using the now out-of-sync positions.) + +### Implicit interop context synchronization + +This sample uses basic and implicit interop context synchronization. For a detailed overview on the various ways OpenCL and OpenGL can be synchronized, refer to [Synchronizing the two APIs](https://github.com/KhronosGroup/OpenCL-Guide/blob/main/chapters/how_does_opencl-opencl_interop.md#Synchronizing-the-two-APIs) section of the OpenCL-OpenGL interop guide. + +### Used API surface + +```c++ +cl::sdk::InteropWindow +cl::Context::getInfo() +cl::CommandQueue(cl::Context, cl::Device) +cl::util::get_program(cl::Context, cl::string) +cl::Program::build(cl::Device) +cl::KernelFunctor<...>(cl::Program, const char*) +cl::Buffer(cl::CommandQueue, Iter, Iter, bool) +cl::BufferGL::BufferGL(cl::Context, cl_mem_flags, cl_GLuint) +cl::copy(cl::CommandQueue, cl::Buffer, Iter, Iter) +cl::CommandQueue::enqueueAcquireGLObjects(const cl::vector*, const cl::vector*, cl::Event*) +cl::CommandQueue::enqueueReleaseGLObjects(const cl::vector*, const cl::vector*, cl::Event*) +cl::finish() +cl::Event::wait() +``` diff --git a/samples/extensions/khr/nbody/main.cpp b/samples/extensions/khr/nbody/main.cpp new file mode 100644 index 00000000..a27219b5 --- /dev/null +++ b/samples/extensions/khr/nbody/main.cpp @@ -0,0 +1,500 @@ +/* + * Copyright (c) 2020 The Khronos Group Inc. + * + * 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. + */ + +#include + +// OpenCL SDK includes +#include +#include + +// STL includes +#include +#include +#include +#include +#include +#include // std::make_tuple + +// TCLAP includes +#include + +// OpenGL includes +#include + +// GLM includes +#include +#include +#include + +template struct DoubleBuffer +{ + T front, back; + + void swap() { std::swap(front, back); } +}; + +class NBody : public cl::sdk::InteropWindow { +public: + explicit NBody(unsigned int platform_id = 0, unsigned int device_id = 0, + cl_bitfield device_type = CL_DEVICE_TYPE_DEFAULT) + : InteropWindow{ sf::VideoMode(800, 800), + "Gravitational NBody", + sf::Style::Default, + sf::ContextSettings{ + 32, 0, 0, // Depth, Stencil, AA + 3, 3, // OpenGL version + sf::ContextSettings::Attribute::Core }, + platform_id, + device_id, + device_type }, + particle_count(8192), x_abs_range(192.f), y_abs_range(128.f), + z_abs_range(32.f), mass_min(100.f), mass_max(500.f), + RMB_pressed(false), + dist(std::max({ x_abs_range, y_abs_range, z_abs_range }) * 3), phi(0), + theta(0), needMatrixReset(true) + {} + +protected: + virtual void + initializeGL() override; // Function that initializes all OpenGL assets + // needed to draw a scene + virtual void + initializeCL() override; // Function that initializes all OpenCL assets + // needed to draw a scene + virtual void + updateScene() override; // Function that holds scene update guaranteed not + // to conflict with drawing + virtual void render() override; // Function that does the native rendering + virtual void event(const sf::Event& e) + override; // Function that handles render area resize + +private: + // Simulation related variables + std::size_t particle_count; + float x_abs_range, y_abs_range, z_abs_range, mass_min, mass_max; + + // Host-side containers + std::vector pos_mass; + std::vector velocity; + std::vector forces; + + // OpenCL objects + cl::Device device; + cl::CommandQueue queue; + cl::Program cl_program; + cl::Kernel kernel; + cl::Sampler sampler; + + cl::Buffer velocity_buffer; + DoubleBuffer cl_pos_mass; + + cl::vector interop_resources; + cl::vector acquire_wait_list, release_wait_list; + cl::NDRange gws, lws; // Global/local work-sizes + cl::Kernel step_kernel; // Kernel + + // OpenGL objects + cl_GLuint vertex_shader, fragment_shader, gl_program; + DoubleBuffer vertex_array; + DoubleBuffer gl_pos_mass; + + bool RMB_pressed; // Variables to enable dragging + sf::Vector2 mousePos; // Variables to enable dragging + float dist, phi, theta; // Mouse polar coordinates + bool needMatrixReset; // Whether matrices need to be reset in shaders + + void + mouseDrag(const sf::Event::MouseMoveEvent& event); // Handle mouse dragging + void mouseWheel( + const sf::Event::MouseWheelEvent& event); // Handle mouse wheel movement + + void setMatrices(); // Update shader matrices +}; + +inline bool checkError(const char* Title) +{ + int Error; + if ((Error = glGetError()) != GL_NO_ERROR) + { + std::string ErrorString; + switch (Error) + { + case GL_INVALID_ENUM: ErrorString = "GL_INVALID_ENUM"; break; + case GL_INVALID_VALUE: ErrorString = "GL_INVALID_VALUE"; break; + case GL_INVALID_OPERATION: + ErrorString = "GL_INVALID_OPERATION"; + break; + case GL_INVALID_FRAMEBUFFER_OPERATION: + ErrorString = "GL_INVALID_FRAMEBUFFER_OPERATION"; + break; + case GL_OUT_OF_MEMORY: ErrorString = "GL_OUT_OF_MEMORY"; break; + default: ErrorString = "UNKNOWN"; break; + } + std::cerr << "OpenGL Error(" << ErrorString << "): " << Title + << std::endl; + } + return Error == GL_NO_ERROR; +} + +void NBody::initializeGL() +{ + if (glewInit() != GLEW_OK) std::exit(EXIT_FAILURE); + + auto create_shader = [](std::string file_path, cl_GLenum shader_stage) { + std::ifstream shader_stream(file_path); + std::string shader_string{ std::istreambuf_iterator{ + shader_stream }, + std::istreambuf_iterator{} }; + auto pshader_string = shader_string.c_str(); + GLuint shader = glCreateShader(shader_stage); + glShaderSource(shader, 1, &pshader_string, NULL); + checkError("glShaderSource(shader, 1, &pshader_string, NULL)"); + glCompileShader(shader); + checkError("glCompileShader(shader)"); + + GLint status = GL_FALSE; + glGetShaderiv(shader, GL_COMPILE_STATUS, &status); + checkError("glGetShaderiv(shader, GL_COMPILE_STATUS, &status)"); + if (status != GL_TRUE) + { + int log_length = 0; + glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_length); + checkError( + "glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_length)"); + std::vector shader_log(log_length); + glGetShaderInfoLog(shader, log_length, NULL, shader_log.data()); + checkError("glGetShaderInfoLog(shader, log_length, NULL, " + "shader_log.data())"); + std::cerr << std::string(shader_log.cbegin(), shader_log.cend()) + << std::endl; + } + + return shader; + }; + auto create_program = [](std::initializer_list shader_stages) { + GLuint program = glCreateProgram(); + checkError("glCreateProgram()"); + for (auto shader_stage : shader_stages) + { + glAttachShader(program, shader_stage); + checkError("glAttachShader(program, shader_stage)"); + } + + glLinkProgram(program); + checkError("glLinkProgram(program)"); + GLint status = GL_FALSE; + glGetProgramiv(program, GL_LINK_STATUS, &status); + checkError("glGetProgramiv(program, GL_LINK_STATUS, &status)"); + if (status != GL_TRUE) + { + int log_length = 0; + glGetProgramiv(program, GL_INFO_LOG_LENGTH, &log_length); + checkError( + "glGetProgramiv(program, GL_INFO_LOG_LENGTH, &log_length)"); + std::vector program_log(log_length); + glGetProgramInfoLog(program, log_length, NULL, program_log.data()); + checkError("glGetProgramInfoLog(program, log_length, NULL, " + "program_log.data())"); + std::cerr << std::string(program_log.cbegin(), program_log.cend()) + << std::endl; + } + + return program; + }; + + vertex_shader = create_shader("./nbody.vert.glsl", GL_VERTEX_SHADER); + fragment_shader = create_shader("./nbody.frag.glsl", GL_FRAGMENT_SHADER); + gl_program = create_program({ vertex_shader, fragment_shader }); + + using uni = std::uniform_real_distribution; + std::generate_n(std::back_inserter(pos_mass), particle_count, + [prng = std::default_random_engine(), + x_dist = uni(-x_abs_range, x_abs_range), + y_dist = uni(-y_abs_range, y_abs_range), + z_dist = uni(-z_abs_range, z_abs_range), + m_dist = uni(mass_min, mass_max)]() mutable { + return cl_float4{ x_dist(prng), y_dist(prng), + z_dist(prng), m_dist(prng) }; + }); + + glUseProgram(gl_program); + checkError("glUseProgram(gl_program)"); + for (auto vbo_vao : + { std::make_pair(&gl_pos_mass.front, &vertex_array.front), + std::make_pair(&gl_pos_mass.back, &vertex_array.back) }) + { + glGenBuffers(1, vbo_vao.first); + checkError("glGenBuffers(1, &vertex_buffer)"); + glBindBuffer(GL_ARRAY_BUFFER, *vbo_vao.first); + checkError("glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer)"); + glBufferData(GL_ARRAY_BUFFER, pos_mass.size() * sizeof(cl_float4), + pos_mass.data(), GL_STATIC_DRAW); + checkError("glBufferData(GL_ARRAY_BUFFER, quad.size() * sizeof(float), " + "quad.data(), GL_STATIC_DRAW)"); + glBindBuffer(GL_ARRAY_BUFFER, 0); + checkError("glBindBuffer(GL_ARRAY_BUFFER, 0)"); + + glGenVertexArrays(1, vbo_vao.second); + checkError("glGenVertexArrays(1, &vertex_array)"); + glBindVertexArray(*vbo_vao.second); + checkError("glBindVertexArray(vertex_array)"); + glBindBuffer(GL_ARRAY_BUFFER, *vbo_vao.first); + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(cl_float4), + (GLvoid*)(NULL)); + checkError("glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, " + "sizeof(cl_float4), (GLvoid *)(NULL))"); + glVertexAttribPointer(1, 1, GL_FLOAT, GL_FALSE, sizeof(cl_float4), + (GLvoid*)(0 + 3 * sizeof(float))); + checkError("glVertexAttribPointer(1, 1, GL_FLOAT, GL_FALSE, " + "sizeof(cl_float4), (GLvoid *)(0 + 3 * sizeof(float)))"); + glEnableVertexAttribArray(0); + checkError("glEnableVertexAttribArray(0)"); + glEnableVertexAttribArray(1); + checkError("glEnableVertexAttribArray(1)"); + glBindVertexArray(0); + checkError("glBindVertexArray(0)"); + } + + glViewport(0, 0, getSize().x, getSize().y); + checkError("glViewport(0, 0, getSize().x, getSize().y)"); + glClearColor(0.f, 0.f, 0.f, 1.f); + checkError("glClearColor(0.f, 0.f, 0.f, 0.f)"); + glEnable(GL_DEPTH_TEST); + checkError("glDisable(GL_DEPTH_TEST)"); + glDepthFunc(GL_LESS); + checkError("glDepthFunc(GL_LESS)"); + glDisable(GL_CULL_FACE); + checkError("glDisable(GL_CULL_FACE)"); + glPointSize(1.5f); +} + +void NBody::initializeCL() +{ + device = opencl_context.getInfo().at(0); + queue = cl::CommandQueue{ opencl_context, device }; + + // Compile kernel + const char* kernel_location = "./nbody.cl"; + std::ifstream kernel_stream{ kernel_location }; + if (!kernel_stream.is_open()) + throw std::runtime_error{ std::string{ "Cannot open kernel source: " } + + kernel_location }; + + cl_program = cl::Program{ opencl_context, + std::string{ std::istreambuf_iterator{ + kernel_stream }, + std::istreambuf_iterator{} } }; + cl_program.build(device); + kernel = cl::Kernel{ cl_program, "nbody" }; + + gws = cl::NDRange{ particle_count }; + lws = cl::NullRange; + + // velocity = std::vector(particle_count, cl_float4{ 0, 0, 0, 0 + // }); + velocity_buffer = cl::Buffer{ opencl_context, CL_MEM_READ_WRITE, + particle_count * sizeof(cl_float3), nullptr }; + queue.enqueueFillBuffer(velocity_buffer, cl_float4{ 0, 0, 0, 0 }, 0, + particle_count * sizeof(cl_float4)); + queue.finish(); + + // Translate OpenGL object handles into OpenCL handles + cl_pos_mass.front = + cl::BufferGL{ opencl_context, CL_MEM_READ_WRITE, gl_pos_mass.front }; + cl_pos_mass.back = + cl::BufferGL{ opencl_context, CL_MEM_READ_WRITE, gl_pos_mass.back }; + + // Translate + interop_resources = + cl::vector{ cl_pos_mass.front, cl_pos_mass.back }; +} + +void NBody::updateScene() +{ + auto nbody = cl::KernelFunctor{ cl_program, "nbody" }; + cl::Event acquire, release; + + queue.enqueueAcquireGLObjects(&interop_resources, nullptr, &acquire); + + nbody(cl::EnqueueArgs{ queue, cl::NDRange{ particle_count } }, + cl_pos_mass.front, cl_pos_mass.back, velocity_buffer, + static_cast(particle_count), 0.0001f); + + queue.enqueueReleaseGLObjects(&interop_resources, nullptr, &release); + + // Wait for all OpenCL commands to finish + if (!cl_khr_gl_event_supported) + cl::finish(); + else + release.wait(); + + // Swap front and back buffer handles + cl_pos_mass.swap(); + gl_pos_mass.swap(); +} + +void NBody::render() +{ + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + checkError("glClear(GL_COLOR_BUFFER_BIT)"); + + glUseProgram(gl_program); + checkError("glUseProgram(gl_program)"); + glBindVertexArray(vertex_array.front); + checkError("glBindVertexArray(vertex_array)"); + glBindBuffer(GL_ARRAY_BUFFER, gl_pos_mass.front); + checkError("glBindBuffer(GL_ARRAY_BUFFER, gl_pos_mass.front)"); + + if (needMatrixReset) setMatrices(); + + glDrawArrays(GL_POINTS, 0, static_cast(particle_count)); + checkError( + "glDrawArrays(GL_POINTS, 0, static_cast(particle_count))"); + + glBindBuffer(GL_ARRAY_BUFFER, 0); + checkError("glBindBuffer(GL_ARRAY_BUFFER, 0)"); + glBindVertexArray(0); + checkError("glBindVertexArray(0)"); + + // Wait for all drawing commands to finish + if (!cl_khr_gl_event_supported) + glFinish(); + else + glFlush(); + checkError("glFlush()/glFinish()"); +} + +void NBody::event(const sf::Event& event) +{ + switch (event.type) + { + case sf::Event::Closed: close(); break; + case sf::Event::Resized: + glViewport(0, 0, getSize().x, getSize().y); + checkError("glViewport(0, 0, getSize().x, getSize().y)"); + needMatrixReset = true; // projection matrix need to be recalculated + break; + case sf::Event::MouseButtonPressed: + if (event.mouseButton.button == sf::Mouse::Button::Right) + { + RMB_pressed = true; + mousePos = + sf::Vector2i{ event.mouseButton.x, event.mouseButton.y }; + } + break; + case sf::Event::MouseButtonReleased: + if (event.mouseButton.button == sf::Mouse::Button::Right) + RMB_pressed = false; + break; + case sf::Event::MouseMoved: + if (RMB_pressed) mouseDrag(event.mouseMove); + break; + case sf::Event::MouseWheelMoved: + dist += (float)sqrt(pow((double)x_abs_range, 2) + + pow((double)y_abs_range, 2)) + * 1.1f * event.mouseWheel.delta * (-0.2f); + dist = abs(dist); + needMatrixReset = true; // view matrix need to be recalculated + break; + } +} + +void NBody::mouseDrag(const sf::Event::MouseMoveEvent& event) +{ + if (sf::Vector2i{ event.x, event.y } != mousePos) + { + phi += 0.01f * (event.x - mousePos.x); + theta += 0.01f * (event.y - mousePos.y); + + needMatrixReset = true; + } + mousePos = sf::Vector2i{ event.x, event.y }; +} + +void NBody::setMatrices() +{ + // Set shader variables + const float fov = 45.f; + + // Set camera to view the origo from the z-axis with up along the y-axis + // and distance so the entire sim space is visible with given field-of-view + glm::vec3 vecTarget{ 0, 0, 0 }; + glm::vec3 vecUp{ 0, 1, 0 }; + glm::vec3 vecEye = vecTarget + glm::vec3{ 0, 0, dist }; + + glm::mat4 matWorld = glm::rotate( + glm::rotate(glm::identity(), theta, + glm::vec3{ 1, 0, 0 }), // theta rotates around z-axis + phi, glm::vec3{ 0, 0, 1 } // theta rotates around z-axis + ); + + glm::mat4 matView = glm::lookAt(vecEye, vecTarget, vecUp); + + glm::mat4 matProj = glm::perspective( + fov, static_cast(getSize().x) / getSize().y, 0.001f, 1000000.0f); + + auto loc_MVP = glGetUniformLocation(gl_program, "mat_MVP"); + checkError("glGetUniformLocation(gl_program, \"mat_MVP\");"); + glUniformMatrix4fv(loc_MVP, 1, GL_FALSE, + glm::value_ptr(matProj * matView * matWorld)); + checkError("glUniformMatrix4fv(loc_MVP, 1, GL_FALSE, " + "glm::value_ptr(matProj * matView * matWorld));"); + + needMatrixReset = false; +} + +int main(int argc, char* argv[]) +{ + try + { + // Parse command-line options + auto opts = + cl::sdk::parse_cli(argc, argv); + const auto& dev_opts = std::get<1>(opts).triplet; + + NBody window{ dev_opts.plat_index, dev_opts.dev_index, + dev_opts.dev_type }; + + window.run(); + } catch (cl::util::Error& e) + { + std::cerr << "OpenCL Utils error: " << e.what() << std::endl; + std::exit(e.err()); + } catch (cl::BuildError& e) + { + std::cerr << "OpenCL runtime error: " << e.what() << std::endl; + for (auto& build_log : e.getBuildLog()) + { + std::cerr << "\tBuild log for device: " + << build_log.first.getInfo() << "\n" + << std::endl; + std::cerr << build_log.second << "\n" << std::endl; + } + std::exit(e.err()); + } catch (cl::Error& e) + { + std::cerr << "OpenCL rutnime error: " << e.what() << std::endl; + std::exit(e.err()); + } catch (std::exception& e) + { + std::cerr << "Error: " << e.what() << std::endl; + std::exit(EXIT_FAILURE); + } + + return 0; +} diff --git a/samples/extensions/khr/nbody/nbody.cl b/samples/extensions/khr/nbody/nbody.cl new file mode 100644 index 00000000..1e80aae0 --- /dev/null +++ b/samples/extensions/khr/nbody/nbody.cl @@ -0,0 +1,46 @@ +#define G 1.0f +//6.67384e-11f + +#define epsilon_sq 1.f + +float3 calculate_force( + float3 first_pos, + float3 second_pos, + float first_mass, + float second_mass) +{ + float3 d = first_pos - second_pos; + float q = sqrt(dot(d, d) + epsilon_sq); + return -G * first_mass * second_mass * d / ( q*q*q ); +} + +kernel void nbody(global const float4* pos_mass_front, + global float4* pos_mass_back, + global float4* velocity, + uint particle_count, + float dt) +{ + size_t gid = get_global_id(0); + float3 my_pos = pos_mass_front[gid].xyz; + float my_mass = pos_mass_front[gid].w; + float3 my_vel = velocity[gid].xyz; + + float3 acc = (float3)0.f; + for (uint i = 0; i < particle_count; i++) + { + acc += calculate_force( + my_pos, + pos_mass_front[i].xyz, + my_mass, + pos_mass_front[i].w + ); + } + + // updated position and velocity + my_pos += my_vel * dt + acc * 0.5f * dt * dt; + my_vel += acc * dt; + + // write to global memory + pos_mass_back[gid] = (float4)(my_pos, my_mass); + velocity[gid] = (float4)(my_vel, 0.f); +} diff --git a/samples/extensions/khr/nbody/nbody.frag.glsl b/samples/extensions/khr/nbody/nbody.frag.glsl new file mode 100644 index 00000000..8b3d6a45 --- /dev/null +++ b/samples/extensions/khr/nbody/nbody.frag.glsl @@ -0,0 +1,21 @@ +#version 330 + +// VS locations +#define POSITION 0 +#define COLOR 1 + +// FS locations +#define FRAG_COLOR 0 + +in block +{ + float Color; +} FS_In; + +out vec4 FragColor; + +void main() +{ + float factor = FS_In.Color / 500.f; + FragColor = vec4(factor, factor, factor ,1.0f); +} diff --git a/samples/extensions/khr/nbody/nbody.vert.glsl b/samples/extensions/khr/nbody/nbody.vert.glsl new file mode 100644 index 00000000..d269dcc6 --- /dev/null +++ b/samples/extensions/khr/nbody/nbody.vert.glsl @@ -0,0 +1,25 @@ +#version 330 + +// VS locations +#define POSITION 0 +#define COLOR 1 + +// FS locations +#define FRAG_COLOR 0 + +layout(location = POSITION) in vec3 in_Position; +layout(location = COLOR) in float in_Color; + +out block +{ + float Color; +} VS_Out; + +uniform mat4 mat_MVP; + +void main() +{ + gl_Position = mat_MVP * vec4(in_Position, 1.0); + + VS_Out.Color = in_Color; +} diff --git a/test/cmake/findmodule/CMakeLists.txt b/test/cmake/findmodule/CMakeLists.txt new file mode 100644 index 00000000..4fee1e80 --- /dev/null +++ b/test/cmake/findmodule/CMakeLists.txt @@ -0,0 +1,81 @@ +cmake_minimum_required(VERSION 3.0) + +project(FindModuleTest) + +include(CTest) + +find_package(OpenCL + MODULE + REQUIRED +) + +# Test consuming from C++ source files +# +# NOTE: At the time of writing, the presence of the +# C++ headers don't manifest as a COMPONENT. +# They are usually expected to reside next to +# the C headers, even though they live in +# different `apt` packages for eg. + +add_executable(${PROJECT_NAME}_cpp + ../platformenum.cpp +) + +if(${CMAKE_VERSION} VERSION_LESS 3.7) + target_include_directories(${PROJECT_NAME}_cpp + PRIVATE + ${OpenCL_INCLUDE_DIR} + ) + target_link_libraries(${PROJECT_NAME}_cpp + PRIVATE + ${OpenCL_LIBRARY} + ) +else() + target_link_libraries(${PROJECT_NAME}_cpp + PRIVATE + OpenCL::OpenCL + ) +endif() + +target_compile_definitions(${PROJECT_NAME}_cpp + PRIVATE + CL_HPP_ENABLE_EXCEPTIONS + CL_HPP_TARGET_OPENCL_VERSION=300 +) + +add_test( + NAME ${PROJECT_NAME}_cpp + COMMAND ${PROJECT_NAME}_cpp +) + +# Test consuming from C source files + +add_executable(${PROJECT_NAME}_c + ../platformenum.c +) + +if(${CMAKE_VERSION} VERSION_LESS 3.7) + target_include_directories(${PROJECT_NAME}_c + PRIVATE + ${OpenCL_INCLUDE_DIR} + ) + target_link_libraries(${PROJECT_NAME}_c + PRIVATE + ${OpenCL_LIBRARY} + ) +else() + target_link_libraries(${PROJECT_NAME}_c + PRIVATE + OpenCL::OpenCL + ) +endif() + +target_compile_definitions(${PROJECT_NAME}_c + PRIVATE + CL_TARGET_OPENCL_VERSION=300 +) + +add_test( + NAME ${PROJECT_NAME}_c + COMMAND ${PROJECT_NAME}_c +) diff --git a/test/cmake/pkgconfig/CMakeLists.txt b/test/cmake/pkgconfig/CMakeLists.txt new file mode 100644 index 00000000..ac146910 --- /dev/null +++ b/test/cmake/pkgconfig/CMakeLists.txt @@ -0,0 +1,58 @@ +cmake_minimum_required(VERSION 3.0) + +project(PkgConfigTest) + +find_package(OpenCL + REQUIRED + CONFIG + COMPONENTS + HeadersCpp + Headers + OpenCL +) + +# Test consuming from C++ source files + +add_executable(${PROJECT_NAME}_cpp + ../platformenum.cpp +) + +target_link_libraries(${PROJECT_NAME}_cpp + PRIVATE + OpenCL::HeadersCpp + OpenCL::Headers + OpenCL::OpenCL +) + +target_compile_definitions(${PROJECT_NAME}_cpp + PRIVATE + CL_HPP_ENABLE_EXCEPTIONS + CL_HPP_TARGET_OPENCL_VERSION=300 +) + +add_test( + NAME ${PROJECT_NAME}_cpp + COMMAND ${PROJECT_NAME}_cpp +) + +# Test consuming from C source files + +add_executable(${PROJECT_NAME}_c + ../platformenum.c +) + +target_link_libraries(${PROJECT_NAME}_c + PRIVATE + OpenCL::Headers + OpenCL::OpenCL +) + +target_compile_definitions(${PROJECT_NAME}_c + PRIVATE + CL_TARGET_OPENCL_VERSION=300 +) + +add_test( + NAME ${PROJECT_NAME}_c + COMMAND ${PROJECT_NAME}_c +) diff --git a/test/cmake/platformenum.c b/test/cmake/platformenum.c new file mode 100644 index 00000000..0c787caa --- /dev/null +++ b/test/cmake/platformenum.c @@ -0,0 +1,26 @@ +// OpenCL includes +#include + +// C standard includes +#include + +#ifdef _MSC_VER +#define print(...) printf_s(__VA_ARGS__) +#else +#define print(...) printf(__VA_ARGS__) +#endif + +int main() +{ + cl_int CL_err = CL_SUCCESS; + cl_uint numPlatforms = 0; + + CL_err = clGetPlatformIDs(0, NULL, &numPlatforms); + + if (CL_err == CL_SUCCESS) + print("%u platform(s) found\n", numPlatforms); + else + print("clGetPlatformIDs(%i)\n", CL_err); + + return 0; +} diff --git a/test/cmake/platformenum.cpp b/test/cmake/platformenum.cpp new file mode 100644 index 00000000..b91e630f --- /dev/null +++ b/test/cmake/platformenum.cpp @@ -0,0 +1,46 @@ +#include + +#include // std::vector +#include // std::runtime_error, std::exception +#include // std::cout +#include // EXIT_FAILURE + +int main() +{ + try + { + std::vector platforms; + cl::Platform::get(&platforms); + + std::cout << "Found " << platforms.size() << " platform" + << (platforms.size() > 1 ? "s.\n" : ".\n") << std::endl; + + for (const auto& platform : platforms) + { + std::cout << platform.getInfo() << std::endl; + + std::vector devices; + platform.getDevices(CL_DEVICE_TYPE_ALL, &devices); + + for (const auto& device : devices) + std::cout << "\t" << device.getInfo() + << std::endl; + } + } catch (cl::Error& error) // If any OpenCL error occurs + { + if (error.err() == CL_PLATFORM_NOT_FOUND_KHR) + { + std::cout << "No OpenCL platform found." << std::endl; + std::exit(EXIT_SUCCESS); + } + else + { + std::cerr << error.what() << "(" << error.err() << ")" << std::endl; + std::exit(error.err()); + } + } catch (std::exception& error) // If STL/CRT error occurs + { + std::cerr << error.what() << std::endl; + std::exit(EXIT_FAILURE); + } +} diff --git a/third_party/cargs/CMakeLists.txt b/third_party/cargs/CMakeLists.txt new file mode 100644 index 00000000..853768d1 --- /dev/null +++ b/third_party/cargs/CMakeLists.txt @@ -0,0 +1,11 @@ +# cargs +add_library(cargs STATIC ${CMAKE_CURRENT_SOURCE_DIR}/cargs.c) + +target_include_directories(cargs PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}) + +set_target_properties(cargs + PROPERTIES + RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/library + POSITION_INDEPENDENT_CODE ON + C_STANDARD 99 +) diff --git a/third_party/cargs/cargs.c b/third_party/cargs/cargs.c new file mode 100644 index 00000000..a55fb78a --- /dev/null +++ b/third_party/cargs/cargs.c @@ -0,0 +1,499 @@ +/** + * https://github.com/likle/cargs + * + * MIT License + * + * Copyright (c) 2020 Leonard Iklé + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files + * (the "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, + * publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE + * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * This is a simple alternative cross-platform implementation of getopt, which + * is used to parse argument strings submitted to the executable (argc and argv + * which are received in the main function). + */ + +/* Changes: Copyright (c) 2021 The Khronos Group Inc. */ + +#include +#include +#include +#include + +#include + +static void cag_option_print_value(const cag_option *option, + int *accessor_length, FILE *destination) +{ + if (option->value_name != NULL) + { + *accessor_length += fprintf(destination, "=%s", option->value_name); + } +} + +static void cag_option_print_letters(const cag_option *option, bool *first, + int *accessor_length, FILE *destination) +{ + const char *access_letter; + access_letter = option->access_letters; + if (access_letter != NULL) + { + while (*access_letter) + { + if (*first) + { + *accessor_length += fprintf(destination, "-%c", *access_letter); + *first = false; + } + else + { + *accessor_length += + fprintf(destination, ", -%c", *access_letter); + } + ++access_letter; + } + } +} + +static void cag_option_print_name(const cag_option *option, bool *first, + int *accessor_length, FILE *destination) +{ + if (option->access_name != NULL) + { + if (*first) + { + *accessor_length += + fprintf(destination, "--%s", option->access_name); + } + else + { + *accessor_length += + fprintf(destination, ", --%s", option->access_name); + } + } +} + +void cag_option_print(const cag_option *options, size_t option_count, + FILE *destination) +{ + size_t option_index; + const cag_option *option; + bool first; + int i, accessor_length, max_accessor_length = 0; + + FILE *tmp; + if ((tmp = tmpfile())) + { + for (option_index = 0; option_index < option_count; ++option_index) + { + option = &options[option_index]; + accessor_length = 0; + first = true; + + cag_option_print_letters(option, &first, &accessor_length, tmp); + cag_option_print_name(option, &first, &accessor_length, tmp); + cag_option_print_value(option, &accessor_length, tmp); + + if (accessor_length > max_accessor_length) + max_accessor_length = accessor_length; + } + } + + for (option_index = 0; option_index < option_count; ++option_index) + { + option = &options[option_index]; + accessor_length = 0; + first = true; + + fputs(" ", destination); + + cag_option_print_letters(option, &first, &accessor_length, destination); + cag_option_print_name(option, &first, &accessor_length, destination); + cag_option_print_value(option, &accessor_length, destination); + + for (i = accessor_length; i < max_accessor_length; ++i) + { + fputs(" ", destination); + } + + fputs(" ", destination); + fputs(option->description, destination); + + fprintf(destination, "\n"); + } +} + +void cag_option_prepare(cag_option_context *context, const cag_option *options, + size_t option_count, int argc, char **argv) +{ + // This just initialized the values to the beginning of all the arguments. + context->options = options; + context->option_count = option_count; + context->argc = argc; + context->argv = argv; + context->index = 1; + context->inner_index = 0; + context->forced_end = false; +} + +static const cag_option *cag_option_find_by_name(cag_option_context *context, + char *name, size_t name_size) +{ + const cag_option *option; + size_t i; + + // We loop over all the available options and stop as soon as we have found + // one. We don't use any hash map table, since there won't be that many + // arguments anyway. + for (i = 0; i < context->option_count; ++i) + { + option = &context->options[i]; + + // The option might not have an item name, we can just skip those. + if (option->access_name == NULL) + { + continue; + } + + // Try to compare the name of the access name. We can use the name_size + // or this comparison, since we are guaranteed to have null-terminated + // access names. + if (strncmp(option->access_name, name, name_size) == 0) + { + return option; + } + } + + return NULL; +} + +static const cag_option *cag_option_find_by_letter(cag_option_context *context, + char letter) +{ + const cag_option *option; + size_t i; + + // We loop over all the available options and stop as soon as we have found + // one. We don't use any look up table, since there won't be that many + // arguments anyway. + for (i = 0; i < context->option_count; ++i) + { + option = &context->options[i]; + + // If this option doesn't have any access letters we will skip them. + if (option->access_letters == NULL) + { + continue; + } + + // Verify whether this option has the access letter in it's access + // letter string. If it does, then this is our option. + if (strchr(option->access_letters, letter) != NULL) + { + return option; + } + } + + return NULL; +} + +static void cag_option_parse_value(cag_option_context *context, + const cag_option *option, char **c) +{ + // And now let's check whether this option is supposed to have a value, + // which is the case if there is a value name set. The value can be either + // submitted with a '=' sign or a space, which means we would have to jump + // over to the next argv index. This is somewhat ugly, but we do it to + // behave the same as the other option parsers. + if (option->value_name != NULL) + { + if (**c == '=') + { + context->value = ++(*c); + } + else + { + // If the next index is larger or equal to the argument count, then + // the parameter for this option is missing. The user will know + // about this, since the value pointer of the context will be NULL + // because we don't set it here in that case. + if (context->argc > context->index + 1) + { + // We consider this argv to be the value, no matter what the + // contents are. + ++context->index; + *c = context->argv[context->index]; + context->value = *c; + } + } + + // Move c to the end of the value, to not confuse the caller about our + // position. + while (**c) + { + ++(*c); + } + } +} + +static void cag_option_parse_access_name(cag_option_context *context, char **c) +{ + const cag_option *option; + char *n; + + // Now we need to extract the access name, which is any symbol up to a '=' + // or a '\0'. + n = *c; + while (**c && **c != '=') + { + ++*c; + } + + // Now this will obviously always be true, but we are paranoid. Sometimes. + // It doesn't hurt to check. + assert(*c >= n); + + // Figure out which option this name belongs to. This might return NULL if + // the name is not registered, which means the user supplied an unknown + // option. In that case we return true to indicate that we finished with + // this option. We have to skip the value parsing since we don't know + // whether the user thinks this option has one or not. Since we don't set + // any identifier specifically, it will remain '?' within the context. + option = cag_option_find_by_name(context, n, (size_t)(*c - n)); + if (option == NULL) + { + // Since this option is invalid, we will move on to the next index. + // There is nothing we can do about this. + ++context->index; + return; + } + + // We found an option and now we can specify the identifier within the + // context. + context->identifier = option->identifier; + + // And now we try to parse the value. This function will also check whether + // this option is actually supposed to have a value. + cag_option_parse_value(context, option, c); + + // And finally we move on to the next index. + ++context->index; +} + +static void cag_option_parse_access_letter(cag_option_context *context, + char **c) +{ + const cag_option *option; + char *n = *c; + char *v; + + // Figure out which option this letter belongs to. This might return NULL if + // the letter is not registered, which means the user supplied an unknown + // option. In that case we return true to indicate that we finished with + // this option. We have to skip the value parsing since we don't know + // whether the user thinks this option has one or not. Since we don't set + // any identifier specifically, it will remain '?' within the context. + option = cag_option_find_by_letter(context, n[context->inner_index]); + if (option == NULL) + { + ++context->index; + context->inner_index = 0; + return; + } + + // We found an option and now we can specify the identifier within the + // context. + context->identifier = option->identifier; + + // And now we try to parse the value. This function will also check whether + // this option is actually supposed to have a value. + v = &n[++context->inner_index]; + cag_option_parse_value(context, option, &v); + + // Check whether we reached the end of this option argument. + if (*v == '\0') + { + ++context->index; + context->inner_index = 0; + } +} + +static void cag_option_shift(cag_option_context *context, int start, int option, + int end) +{ + char *tmp; + int a_index, shift_index, shift_count, left_index, right_index; + + shift_count = option - start; + + // There is no shift is required if the start and the option have the same + // index. + if (shift_count == 0) + { + return; + } + + // Lets loop through the option strings first, which we will move towards + // the beginning. + for (a_index = option; a_index < end; ++a_index) + { + // First remember the current option value, because we will have to save + // that later at the beginning. + tmp = context->argv[a_index]; + + // Let's loop over all option values and shift them one towards the end. + // This will override the option value we just stored temporarily. + for (shift_index = 0; shift_index < shift_count; ++shift_index) + { + left_index = a_index - shift_index; + right_index = a_index - shift_index - 1; + context->argv[left_index] = context->argv[right_index]; + } + + // Now restore the saved option value at the beginning. + context->argv[a_index - shift_count] = tmp; + } + + // The new index will be before all non-option values, in such a way that + // they all will be moved again in the next fetch call. + context->index = end - shift_count; +} + +static bool cag_option_is_argument_string(const char *c) +{ + return *c == '-' && *(c + 1) != '\0'; +} + +static int cag_option_find_next(cag_option_context *context) +{ + int next_index, next_option_index; + char *c; + + // Prepare to search the next option at the next index. + next_index = context->index; + next_option_index = next_index; + + // Grab a pointer to the string and verify that it is not the end. If it is + // the end, we have to return false to indicate that we finished. + c = context->argv[next_option_index]; + if (context->forced_end || c == NULL) + { + return -1; + } + + // Check whether it is a '-'. We need to find the next option - and an + // option always starts with a '-'. If there is a string "-\0", we don't + // consider it as an option neither. + while (!cag_option_is_argument_string(c)) + { + c = context->argv[++next_option_index]; + if (c == NULL) + { + // We reached the end and did not find any argument anymore. Let's + // tell our caller that we reached the end. + return -1; + } + } + + // Indicate that we found an option which can be processed. The index of the + // next option will be returned. + return next_option_index; +} + +bool cag_option_fetch(cag_option_context *context) +{ + char *c; + int old_index, new_index; + + // Reset our identifier to a question mark, which indicates an "unknown" + // option. The value is set to NULL, to make sure we are not carrying the + // parameter from the previous option to this one. + context->identifier = '?'; + context->value = NULL; + + // Check whether there are any options left to parse and remember the old + // index as well as the new index. In the end we will move the option junk + // to the beginning, so that non option arguments can be read. + old_index = context->index; + new_index = cag_option_find_next(context); + if (new_index >= 0) + { + context->index = new_index; + } + else + { + return false; + } + + // Grab a pointer to the beginning of the option. At this point, the next + // character must be a '-', since if it was not the prepare function would + // have returned false. We will skip that symbol and proceed. + c = context->argv[context->index]; + assert(*c == '-'); + ++c; + + // Check whether this is a long option, starting with a double "--". + if (*c == '-') + { + ++c; + + // This might be a double "--" which indicates the end of options. If + // this is the case, we will not move to the next index. That ensures + // that another call to the fetch function will not skip the "--". + if (*c == '\0') + { + context->forced_end = true; + } + else + { + // We parse now the access name. All information about it will be + // written to the context. + cag_option_parse_access_name(context, &c); + } + } + else + { + // This is no long option, so we can just parse an access letter. + cag_option_parse_access_letter(context, &c); + } + + // Move the items so that the options come first followed by non-option + // arguments. + cag_option_shift(context, old_index, new_index, context->index); + + return context->forced_end == false; +} + +char cag_option_get(const cag_option_context *context) +{ + // We just return the identifier here. + return context->identifier; +} + +const char *cag_option_get_value(const cag_option_context *context) +{ + // We just return the internal value pointer of the context. + return context->value; +} + +int cag_option_get_index(const cag_option_context *context) +{ + // Either we point to a value item, + return context->index; +} diff --git a/third_party/cargs/cargs.h b/third_party/cargs/cargs.h new file mode 100644 index 00000000..831ba57b --- /dev/null +++ b/third_party/cargs/cargs.h @@ -0,0 +1,163 @@ +#pragma once + +/** + * https://github.com/likle/cargs + * + * MIT License + * + * Copyright (c) 2020 Leonard Iklé + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + * This is a simple alternative cross-platform implementation of getopt, which + * is used to parse argument strings submitted to the executable (argc and argv + * which are received in the main function). + */ + +/* Changes: Copyright (c) 2021 The Khronos Group Inc. */ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * An option is used to describe a flag/argument option submitted when the + * program is run. + */ +typedef struct cag_option +{ + const char identifier; + const char *access_letters; + const char *access_name; + const char *value_name; + const char *description; +} cag_option; + +/** + * A context is used to iterate over all options provided. It stores the parsing + * state. + */ +typedef struct cag_option_context +{ + const struct cag_option *options; + size_t option_count; + int argc; + char **argv; + int index; + int inner_index; + bool forced_end; + char identifier; + char *value; +} cag_option_context; + +/** + * This is just a small macro which calculates the size of an array. + */ +#define CAG_ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0])) + + +/** + * @brief Prints all options to the terminal. + * + * This function prints all options to the terminal. This can be used to + * generate the output for a "--help" option. + * + * @param options The options which will be printed. + * @param option_count The option count which will be printed. + * @param destination The destination where the output will be printed. + */ +void cag_option_print(const cag_option *options, size_t option_count, + FILE *destination); + +/** + * @brief Prepare argument options context for parsing. + * + * This function prepares the context for iteration and initializes the context + * with the supplied options and arguments. After the context has been prepared, + * it can be used to fetch arguments from it. + * + * @param context The context which will be initialized. + * @param options The registered options which are available for the program. + * @param option_count The amount of options which are available for the + * program. + * @param argc The amount of arguments the user supplied in the main function. + * @param argv A pointer to the arguments of the main function. + */ +void cag_option_prepare(cag_option_context *context, const cag_option *options, + size_t option_count, int argc, char **argv); + +/** + * @brief Fetches an option from the argument list. + * + * This function fetches a single option from the argument list. The context + * will be moved to that item. Information can be extracted from the context + * after the item has been fetched. + * The arguments will be re-ordered, which means that non-option arguments will + * be moved to the end of the argument list. After all options have been + * fetched, all non-option arguments will be positioned after the index of + * the context. + * + * @param context The context from which we will fetch the option. + * @return Returns true if there was another option or false if the end is + * reached. + */ +bool cag_option_fetch(cag_option_context *context); + +/** + * @brief Gets the identifier of the option. + * + * This function gets the identifier of the option, which should be unique to + * this option and can be used to determine what kind of option this is. + * + * @param context The context from which the option was fetched. + * @return Returns the identifier of the option. + */ +char cag_option_get(const cag_option_context *context); + +/** + * @brief Gets the value from the option. + * + * This function gets the value from the option, if any. If the option does not + * contain a value, this function will return NULL. + * + * @param context The context from which the option was fetched. + * @return Returns a pointer to the value or NULL if there is no value. + */ +const char *cag_option_get_value(const cag_option_context *context); + +/** + * @brief Gets the current index of the context. + * + * This function gets the index within the argv arguments of the context. The + * context always points to the next item which it will inspect. This is + * particularly useful to inspect the original argument array, or to get + * non-option arguments after option fetching has finished. + * + * @param context The context from which the option was fetched. + * @return Returns the current index of the context. + */ +int cag_option_get_index(const cag_option_context *context); + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/utils/include/CL/utils/.keepme b/utils/include/CL/utils/.keepme deleted file mode 100644 index e69de29b..00000000 diff --git a/utils/src/.keepme b/utils/src/.keepme deleted file mode 100644 index e69de29b..00000000